Add pg_analyze_and_rewrite_varparams()

This new function extracts common code from PrepareQuery() and
exec_parse_message().  It is then exactly analogous to the existing
pg_analyze_and_rewrite_fixedparams() and
pg_analyze_and_rewrite_withcb().

To unify these two code paths, this makes PrepareQuery() now subject
to log_parser_stats.  Also, both paths now invoke
TRACE_POSTGRESQL_QUERY_REWRITE_START().  PrepareQuery() no longer
checks whether a utility statement was specified.  The grammar doesn't
allow that anyway, and exec_parse_message() supports it, so
restricting it doesn't seem necessary.

This also adds QueryEnvironment support to the *varparams functions,
for consistency with its cousins, even though it is not used right
now.

Reviewed-by: Nathan Bossart <bossartn@amazon.com>
Discussion: https://www.postgresql.org/message-id/flat/c67ce276-52b4-0239-dc0e-39875bf81840@enterprisedb.com

diff --git a/src/backend/commands/prepare.c b/src/backend/commands/prepare.c
index d2d8ee120c32c8365b7a13e679447dc4eb3f3e75..80738547ed80a8cdd259c785ae49cfc49db93104 100644 (file)
--- a/src/backend/commands/prepare.c
+++ b/src/backend/commands/prepare.c
@@ -63,9 +63,7 @@ PrepareQuery(ParseState *pstate, PrepareStmt *stmt,
        CachedPlanSource *plansource;
        Oid                *argtypes = NULL;
        int                     nargs;
-       Query      *query;
        List       *query_list;
-       int                     i;
 
        /*
         * Disallow empty-string statement name (conflicts with protocol-level
@@ -97,6 +95,7 @@ PrepareQuery(ParseState *pstate, PrepareStmt *stmt,
 
        if (nargs)
        {
+               int                     i;
                ListCell   *l;
 
                argtypes = (Oid *) palloc(nargs * sizeof(Oid));
@@ -115,44 +114,10 @@ PrepareQuery(ParseState *pstate, PrepareStmt *stmt,
         * Analyze the statement using these parameter types (any parameters
         * passed in from above us will not be visible to it), allowing
         * information about unknown parameters to be deduced from context.
+        * Rewrite the query. The result could be 0, 1, or many queries.
         */
-       query = parse_analyze_varparams(rawstmt, pstate->p_sourcetext,
-                                                                       &argtypes, &nargs);
-
-       /*
-        * Check that all parameter types were determined.
-        */
-       for (i = 0; i < nargs; i++)
-       {
-               Oid                     argtype = argtypes[i];
-
-               if (argtype == InvalidOid || argtype == UNKNOWNOID)
-                       ereport(ERROR,
-                                       (errcode(ERRCODE_INDETERMINATE_DATATYPE),
-                                        errmsg("could not determine data type of parameter $%d",
-                                                       i + 1)));
-       }
-
-       /*
-        * grammar only allows PreparableStmt, so this check should be redundant
-        */
-       switch (query->commandType)
-       {
-               case CMD_SELECT:
-               case CMD_INSERT:
-               case CMD_UPDATE:
-               case CMD_DELETE:
-                       /* OK */
-                       break;
-               default:
-                       ereport(ERROR,
-                                       (errcode(ERRCODE_INVALID_PSTATEMENT_DEFINITION),
-                                        errmsg("utility statements cannot be prepared")));
-                       break;
-       }
-
-       /* Rewrite the query. The result could be 0, 1, or many queries. */
-       query_list = QueryRewrite(query);
+       query_list = pg_analyze_and_rewrite_varparams(rawstmt, pstate->p_sourcetext,
+                                                                                                 &argtypes, &nargs, NULL);
 
        /* Finish filling in the CachedPlanSource */
        CompleteCachedPlan(plansource,

diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c
index 19d97fe731be1e2a5f6af5c91c82a91894c037e7..53c11b3a15644ee57718c26b7246dd64b48f83f7 100644 (file)
--- a/src/backend/parser/analyze.c
+++ b/src/backend/parser/analyze.c
@@ -148,7 +148,8 @@ parse_analyze_fixedparams(RawStmt *parseTree, const char *sourceText,
  */
 Query *
 parse_analyze_varparams(RawStmt *parseTree, const char *sourceText,
-                                               Oid **paramTypes, int *numParams)
+                                               Oid **paramTypes, int *numParams,
+                                               QueryEnvironment *queryEnv)
 {
        ParseState *pstate = make_parsestate(NULL);
        Query      *query;
@@ -160,6 +161,8 @@ parse_analyze_varparams(RawStmt *parseTree, const char *sourceText,
 
        setup_parse_variable_parameters(pstate, paramTypes, numParams);
 
+       pstate->p_queryEnv = queryEnv;
+
        query = transformTopLevelStmt(pstate, parseTree);
 
        /* make sure all is well with parameter types */

diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index c087db4445696dae854fc239fa7f60c26e3d2f31..d7e39aed64bceb3ba804710520f4fde6726e582b 100644 (file)
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -637,9 +637,11 @@ pg_parse_query(const char *query_string)
  * NOTE: for reasons mentioned above, this must be separate from raw parsing.
  */
 List *
-pg_analyze_and_rewrite_fixedparams(RawStmt *parsetree, const char *query_string,
-                                          const Oid *paramTypes, int numParams,
-                                          QueryEnvironment *queryEnv)
+pg_analyze_and_rewrite_fixedparams(RawStmt *parsetree,
+                                                                  const char *query_string,
+                                                                  const Oid *paramTypes,
+                                                                  int numParams,
+                                                                  QueryEnvironment *queryEnv)
 {
        Query      *query;
        List       *querytree_list;
@@ -668,6 +670,59 @@ pg_analyze_and_rewrite_fixedparams(RawStmt *parsetree, const char *query_string,
        return querytree_list;
 }
 
+/*
+ * Do parse analysis and rewriting.  This is the same as
+ * pg_analyze_and_rewrite_fixedparams except that it's okay to deduce
+ * information about $n symbol datatypes from context.
+ */
+List *
+pg_analyze_and_rewrite_varparams(RawStmt *parsetree,
+                                                                const char *query_string,
+                                                                Oid **paramTypes,
+                                                                int *numParams,
+                                                                QueryEnvironment *queryEnv)
+{
+       Query      *query;
+       List       *querytree_list;
+
+       TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);
+
+       /*
+        * (1) Perform parse analysis.
+        */
+       if (log_parser_stats)
+               ResetUsage();
+
+       query = parse_analyze_varparams(parsetree, query_string, paramTypes, numParams,
+                                                 queryEnv);
+
+       /*
+        * Check all parameter types got determined.
+        */
+       for (int i = 0; i < *numParams; i++)
+       {
+               Oid                     ptype = (*paramTypes)[i];
+
+               if (ptype == InvalidOid || ptype == UNKNOWNOID)
+                       ereport(ERROR,
+                                       (errcode(ERRCODE_INDETERMINATE_DATATYPE),
+                                        errmsg("could not determine data type of parameter $%d",
+                                                       i + 1)));
+       }
+
+       if (log_parser_stats)
+               ShowUsage("PARSE ANALYSIS STATISTICS");
+
+       /*
+        * (2) Rewrite the queries, as necessary
+        */
+       querytree_list = pg_rewrite_query(query);
+
+       TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string);
+
+       return querytree_list;
+}
+
 /*
  * Do parse analysis and rewriting.  This is the same as
  * pg_analyze_and_rewrite_fixedparams except that, instead of a fixed list of
@@ -1409,7 +1464,6 @@ exec_parse_message(const char *query_string,      /* string to execute */
 
        if (parsetree_list != NIL)
        {
-               Query      *query;
                bool            snapshot_set = false;
 
                raw_parse_tree = linitial_node(RawStmt, parsetree_list);
@@ -1449,34 +1503,13 @@ exec_parse_message(const char *query_string,    /* string to execute */
                /*
                 * Analyze and rewrite the query.  Note that the originally specified
                 * parameter set is not required to be complete, so we have to use
-                * parse_analyze_varparams().
-                */
-               if (log_parser_stats)
-                       ResetUsage();
-
-               query = parse_analyze_varparams(raw_parse_tree,
-                                                                               query_string,
-                                                                               &paramTypes,
-                                                                               &numParams);
-
-               /*
-                * Check all parameter types got determined.
+                * pg_analyze_and_rewrite_varparams().
                 */
-               for (int i = 0; i < numParams; i++)
-               {
-                       Oid                     ptype = paramTypes[i];
-
-                       if (ptype == InvalidOid || ptype == UNKNOWNOID)
-                               ereport(ERROR,
-                                               (errcode(ERRCODE_INDETERMINATE_DATATYPE),
-                                                errmsg("could not determine data type of parameter $%d",
-                                                               i + 1)));
-               }
-
-               if (log_parser_stats)
-                       ShowUsage("PARSE ANALYSIS STATISTICS");
-
-               querytree_list = pg_rewrite_query(query);
+               querytree_list = pg_analyze_and_rewrite_varparams(raw_parse_tree,
+                                                                                                                 query_string,
+                                                                                                                 &paramTypes,
+                                                                                                                 &numParams,
+                                                                                                                 NULL);
 
                /* Done with the snapshot used for parsing */
                if (snapshot_set)

diff --git a/src/include/parser/analyze.h b/src/include/parser/analyze.h
index ed989bb1413a6a4be03a9d25e7adc10b33173ec2..06b237c39c7ab268371a210b462f21b6302af7a3 100644 (file)
--- a/src/include/parser/analyze.h
+++ b/src/include/parser/analyze.h
@@ -27,7 +27,7 @@ extern PGDLLIMPORT post_parse_analyze_hook_type post_parse_analyze_hook;
 extern Query *parse_analyze_fixedparams(RawStmt *parseTree, const char *sourceText,
                                                        const Oid *paramTypes, int numParams, QueryEnvironment *queryEnv);
 extern Query *parse_analyze_varparams(RawStmt *parseTree, const char *sourceText,
-                                                                         Oid **paramTypes, int *numParams);
+                                                                         Oid **paramTypes, int *numParams, QueryEnvironment *queryEnv);
 
 extern Query *parse_sub_analyze(Node *parseTree, ParseState *parentParseState,
                                                                CommonTableExpr *parentCTE,

diff --git a/src/include/tcop/tcopprot.h b/src/include/tcop/tcopprot.h
index 00c20966ab89db4ecfbeb8842a8ac799b9cc88f9..92291a750d38cddbc1d8ac1f6e6a3008ae3f344a 100644 (file)
--- a/src/include/tcop/tcopprot.h
+++ b/src/include/tcop/tcopprot.h
@@ -49,6 +49,11 @@ extern List *pg_analyze_and_rewrite_fixedparams(RawStmt *parsetree,
                                                                        const char *query_string,
                                                                        const Oid *paramTypes, int numParams,
                                                                        QueryEnvironment *queryEnv);
+extern List *pg_analyze_and_rewrite_varparams(RawStmt *parsetree,
+                                                                                         const char *query_string,
+                                                                                         Oid **paramTypes,
+                                                                                         int *numParams,
+                                                                                         QueryEnvironment *queryEnv);
 extern List *pg_analyze_and_rewrite_withcb(RawStmt *parsetree,
                                                                                   const char *query_string,
                                                                                   ParserSetupHook parserSetup,