Refactor parse analysis of EXECUTE command

From 7c5bc30a02ec34646c8e49af1499fe4113bc9e5e Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Thu, 31 Oct 2019 09:54:07 +0100
Subject: [PATCH] Refactor parse analysis of EXECUTE command

Move the parse analysis component of ExecuteQuery() and
EvaluateParams() into a new transformExecuteStmt() that is called from
transformStmt().  This makes EXECUTE behave more like other utility
commands.  It also allows error messages to have position information,
and it allows using external parameters in the arguments of the
EXECUTE command.
---
 src/backend/commands/createas.c       |  2 +-
 src/backend/commands/prepare.c        | 72 ++--------------------
 src/backend/parser/analyze.c          | 89 +++++++++++++++++++++++++++
 src/backend/tcop/utility.c            |  2 +-
 src/include/commands/prepare.h        |  2 +-
 src/test/regress/expected/prepare.out | 25 ++++++++
 src/test/regress/sql/prepare.sql      | 21 +++++++
 7 files changed, 143 insertions(+), 70 deletions(-)

diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
index b7d220699f..e4244f84e2 100644
--- a/src/backend/commands/createas.c
+++ b/src/backend/commands/createas.c
@@ -271,7 +271,7 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 		ExecuteStmt *estmt = castNode(ExecuteStmt, query->utilityStmt);
 
 		Assert(!is_matview);	/* excluded by syntax */
-		ExecuteQuery(estmt, into, queryString, params, dest, completionTag);
+		ExecuteQuery(estmt, into, params, dest, completionTag);
 
 		/* get object address that intorel_startup saved for us */
 		address = ((DR_intorel *) dest)->reladdr;
diff --git a/src/backend/commands/prepare.c b/src/backend/commands/prepare.c
index 7e0a041fab..0aba6a7b00 100644
--- a/src/backend/commands/prepare.c
+++ b/src/backend/commands/prepare.c
@@ -47,7 +47,7 @@ static HTAB *prepared_queries = NULL;
 
 static void InitQueryHashTable(void);
 static ParamListInfo EvaluateParams(PreparedStatement *pstmt, List *params,
-									const char *queryString, EState *estate);
+									EState *estate);
 static Datum build_regtype_array(Oid *param_types, int num_params);
 
 /*
@@ -189,16 +189,10 @@ PrepareQuery(PrepareStmt *stmt, const char *queryString,
  * indicated by passing a non-null intoClause.  The DestReceiver is already
  * set up correctly for CREATE TABLE AS, but we still have to make a few
  * other adjustments here.
- *
- * Note: this is one of very few places in the code that needs to deal with
- * two query strings at once.  The passed-in queryString is that of the
- * EXECUTE, which we might need for error reporting while processing the
- * parameter expressions.  The query_string that we copy from the plan
- * source is that of the original PREPARE.
  */
 void
 ExecuteQuery(ExecuteStmt *stmt, IntoClause *intoClause,
-			 const char *queryString, ParamListInfo params,
+			 ParamListInfo params,
 			 DestReceiver *dest, char *completionTag)
 {
 	PreparedStatement *entry;
@@ -229,8 +223,7 @@ ExecuteQuery(ExecuteStmt *stmt, IntoClause *intoClause,
 		 */
 		estate = CreateExecutorState();
 		estate->es_param_list_info = params;
-		paramLI = EvaluateParams(entry, stmt->params,
-								 queryString, estate);
+		paramLI = EvaluateParams(entry, stmt->params, estate);
 	}
 
 	/* Create a new portal to run the query in */
@@ -316,7 +309,6 @@ ExecuteQuery(ExecuteStmt *stmt, IntoClause *intoClause,
  *
  * pstmt: statement we are getting parameters for.
  * params: list of given parameter expressions (raw parser output!)
- * queryString: source text for error messages.
  * estate: executor state to use.
  *
  * Returns a filled-in ParamListInfo -- this can later be passed to
@@ -324,72 +316,19 @@ ExecuteQuery(ExecuteStmt *stmt, IntoClause *intoClause,
  * during query execution.
  */
 static ParamListInfo
-EvaluateParams(PreparedStatement *pstmt, List *params,
-			   const char *queryString, EState *estate)
+EvaluateParams(PreparedStatement *pstmt, List *params, EState *estate)
 {
 	Oid		   *param_types = pstmt->plansource->param_types;
 	int			num_params = pstmt->plansource->num_params;
-	int			nparams = list_length(params);
-	ParseState *pstate;
 	ParamListInfo paramLI;
 	List	   *exprstates;
 	ListCell   *l;
 	int			i;
 
-	if (nparams != num_params)
-		ereport(ERROR,
-				(errcode(ERRCODE_SYNTAX_ERROR),
-				 errmsg("wrong number of parameters for prepared statement \"%s\"",
-						pstmt->stmt_name),
-				 errdetail("Expected %d parameters but got %d.",
-						   num_params, nparams)));
-
 	/* Quick exit if no parameters */
 	if (num_params == 0)
 		return NULL;
 
-	/*
-	 * We have to run parse analysis for the expressions.  Since the parser is
-	 * not cool about scribbling on its input, copy first.
-	 */
-	params = copyObject(params);
-
-	pstate = make_parsestate(NULL);
-	pstate->p_sourcetext = queryString;
-
-	i = 0;
-	foreach(l, params)
-	{
-		Node	   *expr = lfirst(l);
-		Oid			expected_type_id = param_types[i];
-		Oid			given_type_id;
-
-		expr = transformExpr(pstate, expr, EXPR_KIND_EXECUTE_PARAMETER);
-
-		given_type_id = exprType(expr);
-
-		expr = coerce_to_target_type(pstate, expr, given_type_id,
-									 expected_type_id, -1,
-									 COERCION_ASSIGNMENT,
-									 COERCE_IMPLICIT_CAST,
-									 -1);
-
-		if (expr == NULL)
-			ereport(ERROR,
-					(errcode(ERRCODE_DATATYPE_MISMATCH),
-					 errmsg("parameter $%d of type %s cannot be coerced to the expected type %s",
-							i + 1,
-							format_type_be(given_type_id),
-							format_type_be(expected_type_id)),
-					 errhint("You will need to rewrite or cast the expression.")));
-
-		/* Take care of collations in the finished expression. */
-		assign_expr_collations(pstate, expr);
-
-		lfirst(l) = expr;
-		i++;
-	}
-
 	/* Prepare the expressions for execution */
 	exprstates = ExecPrepareExprList(params, estate);
 
@@ -655,8 +594,7 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es,
 		 */
 		estate = CreateExecutorState();
 		estate->es_param_list_info = params;
-		paramLI = EvaluateParams(entry, execstmt->params,
-								 queryString, estate);
+		paramLI = EvaluateParams(entry, execstmt->params, estate);
 	}
 
 	/* Replan if needed, and acquire a transient refcount */
diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c
index 85d7a96406..943e1764bd 100644
--- a/src/backend/parser/analyze.c
+++ b/src/backend/parser/analyze.c
@@ -26,6 +26,7 @@
 
 #include "access/sysattr.h"
 #include "catalog/pg_type.h"
+#include "commands/prepare.h"
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "nodes/nodeFuncs.h"
@@ -44,6 +45,7 @@
 #include "parser/parse_target.h"
 #include "parser/parsetree.h"
 #include "rewrite/rewriteManip.h"
+#include "utils/builtins.h"
 #include "utils/rel.h"
 
 
@@ -72,6 +74,7 @@ static List *transformUpdateTargetList(ParseState *pstate,
 									   List *targetList);
 static Query *transformDeclareCursorStmt(ParseState *pstate,
 										 DeclareCursorStmt *stmt);
+static Query *transformExecuteStmt(ParseState *pstate, ExecuteStmt *stmt);
 static Query *transformExplainStmt(ParseState *pstate,
 								   ExplainStmt *stmt);
 static Query *transformCreateTableAsStmt(ParseState *pstate,
@@ -312,6 +315,11 @@ transformStmt(ParseState *pstate, Node *parseTree)
 												(DeclareCursorStmt *) parseTree);
 			break;
 
+		case T_ExecuteStmt:
+			result = transformExecuteStmt(pstate,
+										  (ExecuteStmt *) parseTree);
+			break;
+
 		case T_ExplainStmt:
 			result = transformExplainStmt(pstate,
 										  (ExplainStmt *) parseTree);
@@ -2511,6 +2519,87 @@ transformDeclareCursorStmt(ParseState *pstate, DeclareCursorStmt *stmt)
 	return result;
 }
 
+/*
+ * transformExexecuteStmt -
+ *	transform an EXECUTE Statement
+ *
+ * This checks that the number of parameters passed to EXECUTE matches the
+ * prepared statement, and it transforms the passed parameter expressions.
+ */
+static Query *
+transformExecuteStmt(ParseState *pstate, ExecuteStmt *stmt)
+{
+	PreparedStatement *pstmt;
+	Oid		   *param_types;
+	int			num_params;
+	int			nparams;
+	List	   *params;
+	ListCell   *l;
+	int			i;
+	Query	   *result;
+
+	pstmt = FetchPreparedStatement(stmt->name, true);
+
+	param_types = pstmt->plansource->param_types;
+	num_params = pstmt->plansource->num_params;
+	nparams = list_length(stmt->params);
+
+	if (nparams != num_params)
+		ereport(ERROR,
+				(errcode(ERRCODE_SYNTAX_ERROR),
+				 errmsg("wrong number of parameters for prepared statement \"%s\"",
+						pstmt->stmt_name),
+				 errdetail("Expected %d parameters but got %d.",
+						   num_params, nparams)));
+
+	/*
+	 * We have to run parse analysis for the expressions.  Since the parser is
+	 * not cool about scribbling on its input, copy first.
+	 */
+	params = copyObject(stmt->params);
+	i = 0;
+	foreach(l, params)
+	{
+		Node	   *expr = lfirst(l);
+		Oid			expected_type_id = param_types[i];
+		Oid			given_type_id;
+
+		expr = transformExpr(pstate, expr, EXPR_KIND_EXECUTE_PARAMETER);
+
+		given_type_id = exprType(expr);
+
+		expr = coerce_to_target_type(pstate, expr, given_type_id,
+									 expected_type_id, -1,
+									 COERCION_ASSIGNMENT,
+									 COERCE_IMPLICIT_CAST,
+									 -1);
+
+		if (expr == NULL)
+			ereport(ERROR,
+					(errcode(ERRCODE_DATATYPE_MISMATCH),
+					 errmsg("parameter $%d of type %s cannot be coerced to the expected type %s",
+							i + 1,
+							format_type_be(given_type_id),
+							format_type_be(expected_type_id)),
+					 errhint("You will need to rewrite or cast the expression."),
+					 parser_errposition(pstate, exprLocation(lfirst(l)))));
+
+		/* Take care of collations in the finished expression. */
+		assign_expr_collations(pstate, expr);
+
+		lfirst(l) = expr;
+		i++;
+	}
+
+	stmt->params = params;
+
+	result = makeNode(Query);
+	result->commandType = CMD_UTILITY;
+	result->utilityStmt = (Node *) stmt;
+
+	return result;
+}
+
 
 /*
  * transformExplainStmt -
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index c6faa6619d..f2d00b0084 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -565,7 +565,7 @@ standard_ProcessUtility(PlannedStmt *pstmt,
 
 		case T_ExecuteStmt:
 			ExecuteQuery((ExecuteStmt *) parsetree, NULL,
-						 queryString, params,
+						 params,
 						 dest, completionTag);
 			break;
 
diff --git a/src/include/commands/prepare.h b/src/include/commands/prepare.h
index 2ce832419f..ff24797fce 100644
--- a/src/include/commands/prepare.h
+++ b/src/include/commands/prepare.h
@@ -38,7 +38,7 @@ typedef struct
 extern void PrepareQuery(PrepareStmt *stmt, const char *queryString,
 						 int stmt_location, int stmt_len);
 extern void ExecuteQuery(ExecuteStmt *stmt, IntoClause *intoClause,
-						 const char *queryString, ParamListInfo params,
+						 ParamListInfo params,
 						 DestReceiver *dest, char *completionTag);
 extern void DeallocateQuery(DeallocateStmt *stmt);
 extern void ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into,
diff --git a/src/test/regress/expected/prepare.out b/src/test/regress/expected/prepare.out
index 717732300d..a0fec13c6b 100644
--- a/src/test/regress/expected/prepare.out
+++ b/src/test/regress/expected/prepare.out
@@ -113,6 +113,8 @@ DETAIL:  Expected 5 parameters but got 6.
 -- wrong param types
 EXECUTE q3(5::smallint, 10.5::float, false, 4::bigint, 'bytea');
 ERROR:  parameter $3 of type boolean cannot be coerced to the expected type double precision
+LINE 1: EXECUTE q3(5::smallint, 10.5::float, false, 4::bigint, 'byte...
+                                             ^
 HINT:  You will need to rewrite or cast the expression.
 -- invalid type
 PREPARE q4(nonexistenttype) AS SELECT $1;
@@ -185,3 +187,26 @@ SELECT name, statement, parameter_types FROM pg_prepared_statements
 ------+-----------+-----------------
 (0 rows)
 
+-- check parameter handling
+CREATE TABLE t1 (a int);
+PREPARE p1 AS INSERT INTO t1 (a) VALUES ($1);
+CREATE FUNCTION f1(x int) RETURNS int
+LANGUAGE SQL
+AS $$
+EXECUTE p1($1);
+SELECT null::int;
+$$;
+SELECT f1(2);
+ f1 
+----
+   
+(1 row)
+
+SELECT * FROM t1;
+ a 
+---
+ 2
+(1 row)
+
+DROP FUNCTION f1(int);
+DROP TABLE t1;
diff --git a/src/test/regress/sql/prepare.sql b/src/test/regress/sql/prepare.sql
index 985d0f05c9..6a16858482 100644
--- a/src/test/regress/sql/prepare.sql
+++ b/src/test/regress/sql/prepare.sql
@@ -78,3 +78,24 @@ CREATE TEMPORARY TABLE q5_prep_nodata AS EXECUTE q5(200, 'DTAAAA')
 DEALLOCATE ALL;
 SELECT name, statement, parameter_types FROM pg_prepared_statements
     ORDER BY name;
+
+
+-- check parameter handling
+
+CREATE TABLE t1 (a int);
+
+PREPARE p1 AS INSERT INTO t1 (a) VALUES ($1);
+
+CREATE FUNCTION f1(x int) RETURNS int
+LANGUAGE SQL
+AS $$
+EXECUTE p1($1);
+SELECT null::int;
+$$;
+
+SELECT f1(2);
+
+SELECT * FROM t1;
+
+DROP FUNCTION f1(int);
+DROP TABLE t1;
-- 
2.23.0

From d4580b9750523f4cfde8c90b8304110f66967ebe Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Mon, 25 Nov 2019 09:15:56 +0100
Subject: [PATCH v2] Make better use of ParseState in ProcessUtility

Pass ParseState into the functions called from
standard_ProcessUtility() instead passing the query string and query
environment separately.  No functionality change, but it makes the
notation consistent.  We had already started moving things into
that direction piece by piece, but this completes it.
---
 src/backend/commands/createas.c   |  6 ++--
 src/backend/commands/explain.c    |  7 ++---
 src/backend/commands/portalcmds.c |  9 +++---
 src/backend/commands/prepare.c    | 52 ++++++++++++-------------------
 src/backend/tcop/utility.c        | 20 ++++++------
 src/include/commands/createas.h   |  2 +-
 src/include/commands/explain.h    |  4 +--
 src/include/commands/portalcmds.h |  5 +--
 src/include/commands/prepare.h    |  7 +++--
 9 files changed, 51 insertions(+), 61 deletions(-)

diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
index 2bf7083719..d413a7c80d 100644
--- a/src/backend/commands/createas.c
+++ b/src/backend/commands/createas.c
@@ -223,7 +223,7 @@ create_ctas_nodata(List *tlist, IntoClause *into)
  * ExecCreateTableAs -- execute a CREATE TABLE AS command
  */
 ObjectAddress
-ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
+ExecCreateTableAs(ParseState *pstate, CreateTableAsStmt *stmt,
 				  ParamListInfo params, QueryEnvironment *queryEnv,
 				  char *completionTag)
 {
@@ -270,7 +270,7 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 		ExecuteStmt *estmt = castNode(ExecuteStmt, query->utilityStmt);
 
 		Assert(!is_matview);	/* excluded by syntax */
-		ExecuteQuery(estmt, into, queryString, params, dest, completionTag);
+		ExecuteQuery(pstate, estmt, into, params, dest, completionTag);
 
 		/* get object address that intorel_startup saved for us */
 		address = ((DR_intorel *) dest)->reladdr;
@@ -342,7 +342,7 @@ ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
 		UpdateActiveSnapshotCommandId();
 
 		/* Create a QueryDesc, redirecting output to our tuple receiver */
-		queryDesc = CreateQueryDesc(plan, queryString,
+		queryDesc = CreateQueryDesc(plan, pstate->p_sourcetext,
 									GetActiveSnapshot(), InvalidSnapshot,
 									dest, params, queryEnv, 0);
 
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 62fb3434a3..7d174ec739 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -139,9 +139,8 @@ static void escape_yaml(StringInfo buf, const char *str);
  *	  execute an EXPLAIN command
  */
 void
-ExplainQuery(ParseState *pstate, ExplainStmt *stmt, const char *queryString,
-			 ParamListInfo params, QueryEnvironment *queryEnv,
-			 DestReceiver *dest)
+ExplainQuery(ParseState *pstate, ExplainStmt *stmt,
+			 ParamListInfo params, DestReceiver *dest)
 {
 	ExplainState *es = NewExplainState();
 	TupOutputState *tstate;
@@ -254,7 +253,7 @@ ExplainQuery(ParseState *pstate, ExplainStmt *stmt, const char *queryString,
 		{
 			ExplainOneQuery(lfirst_node(Query, l),
 							CURSOR_OPT_PARALLEL_OK, NULL, es,
-							queryString, params, queryEnv);
+							pstate->p_sourcetext, params, pstate->p_queryEnv);
 
 			/* Separate plans with an appropriate separator */
 			if (lnext(rewritten, l) != NULL)
diff --git a/src/backend/commands/portalcmds.c b/src/backend/commands/portalcmds.c
index 83f9959d54..e100cf379c 100644
--- a/src/backend/commands/portalcmds.c
+++ b/src/backend/commands/portalcmds.c
@@ -39,14 +39,15 @@
  *		Execute SQL DECLARE CURSOR command.
  */
 void
-PerformCursorOpen(DeclareCursorStmt *cstmt, ParamListInfo params,
-				  const char *queryString, bool isTopLevel)
+PerformCursorOpen(ParseState *pstate, DeclareCursorStmt *cstmt, ParamListInfo params,
+				  bool isTopLevel)
 {
 	Query	   *query = castNode(Query, cstmt->query);
 	List	   *rewritten;
 	PlannedStmt *plan;
 	Portal		portal;
 	MemoryContext oldContext;
+	char	   *queryString;
 
 	/*
 	 * Disallow empty-string cursor name (conflicts with protocol-level
@@ -92,7 +93,7 @@ PerformCursorOpen(DeclareCursorStmt *cstmt, ParamListInfo params,
 	plan = pg_plan_query(query, cstmt->options, params);
 
 	/*
-	 * Create a portal and copy the plan and queryString into its memory.
+	 * Create a portal and copy the plan and query string into its memory.
 	 */
 	portal = CreatePortal(cstmt->portalname, false, false);
 
@@ -100,7 +101,7 @@ PerformCursorOpen(DeclareCursorStmt *cstmt, ParamListInfo params,
 
 	plan = copyObject(plan);
 
-	queryString = pstrdup(queryString);
+	queryString = pstrdup(pstate->p_sourcetext);
 
 	PortalDefineQuery(portal,
 					  NULL,
diff --git a/src/backend/commands/prepare.c b/src/backend/commands/prepare.c
index 47bae957dc..604dd3fac6 100644
--- a/src/backend/commands/prepare.c
+++ b/src/backend/commands/prepare.c
@@ -46,15 +46,16 @@
 static HTAB *prepared_queries = NULL;
 
 static void InitQueryHashTable(void);
-static ParamListInfo EvaluateParams(PreparedStatement *pstmt, List *params,
-									const char *queryString, EState *estate);
+static ParamListInfo EvaluateParams(ParseState *pstate,
+									PreparedStatement *pstmt, List *params,
+									EState *estate);
 static Datum build_regtype_array(Oid *param_types, int num_params);
 
 /*
  * Implements the 'PREPARE' utility statement.
  */
 void
-PrepareQuery(PrepareStmt *stmt, const char *queryString,
+PrepareQuery(ParseState *pstate, PrepareStmt *stmt,
 			 int stmt_location, int stmt_len)
 {
 	RawStmt    *rawstmt;
@@ -90,7 +91,7 @@ PrepareQuery(PrepareStmt *stmt, const char *queryString,
 	 * Create the CachedPlanSource before we do parse analysis, since it needs
 	 * to see the unmodified raw parse tree.
 	 */
-	plansource = CreateCachedPlan(rawstmt, queryString,
+	plansource = CreateCachedPlan(rawstmt, pstate->p_sourcetext,
 								  CreateCommandTag(stmt->query));
 
 	/* Transform list of TypeNames to array of type OIDs */
@@ -98,16 +99,8 @@ PrepareQuery(PrepareStmt *stmt, const char *queryString,
 
 	if (nargs)
 	{
-		ParseState *pstate;
 		ListCell   *l;
 
-		/*
-		 * typenameTypeId wants a ParseState to carry the source query string.
-		 * Is it worth refactoring its API to avoid this?
-		 */
-		pstate = make_parsestate(NULL);
-		pstate->p_sourcetext = queryString;
-
 		argtypes = (Oid *) palloc(nargs * sizeof(Oid));
 		i = 0;
 
@@ -125,7 +118,7 @@ PrepareQuery(PrepareStmt *stmt, const char *queryString,
 	 * passed in from above us will not be visible to it), allowing
 	 * information about unknown parameters to be deduced from context.
 	 */
-	query = parse_analyze_varparams(rawstmt, queryString,
+	query = parse_analyze_varparams(rawstmt, pstate->p_sourcetext,
 									&argtypes, &nargs);
 
 	/*
@@ -189,16 +182,11 @@ PrepareQuery(PrepareStmt *stmt, const char *queryString,
  * indicated by passing a non-null intoClause.  The DestReceiver is already
  * set up correctly for CREATE TABLE AS, but we still have to make a few
  * other adjustments here.
- *
- * Note: this is one of very few places in the code that needs to deal with
- * two query strings at once.  The passed-in queryString is that of the
- * EXECUTE, which we might need for error reporting while processing the
- * parameter expressions.  The query_string that we copy from the plan
- * source is that of the original PREPARE.
  */
 void
-ExecuteQuery(ExecuteStmt *stmt, IntoClause *intoClause,
-			 const char *queryString, ParamListInfo params,
+ExecuteQuery(ParseState *pstate,
+			 ExecuteStmt *stmt, IntoClause *intoClause,
+			 ParamListInfo params,
 			 DestReceiver *dest, char *completionTag)
 {
 	PreparedStatement *entry;
@@ -229,8 +217,7 @@ ExecuteQuery(ExecuteStmt *stmt, IntoClause *intoClause,
 		 */
 		estate = CreateExecutorState();
 		estate->es_param_list_info = params;
-		paramLI = EvaluateParams(entry, stmt->params,
-								 queryString, estate);
+		paramLI = EvaluateParams(pstate, entry, stmt->params, estate);
 	}
 
 	/* Create a new portal to run the query in */
@@ -314,9 +301,9 @@ ExecuteQuery(ExecuteStmt *stmt, IntoClause *intoClause,
 /*
  * EvaluateParams: evaluate a list of parameters.
  *
+ * pstate: parse state
  * pstmt: statement we are getting parameters for.
  * params: list of given parameter expressions (raw parser output!)
- * queryString: source text for error messages.
  * estate: executor state to use.
  *
  * Returns a filled-in ParamListInfo -- this can later be passed to
@@ -324,13 +311,12 @@ ExecuteQuery(ExecuteStmt *stmt, IntoClause *intoClause,
  * during query execution.
  */
 static ParamListInfo
-EvaluateParams(PreparedStatement *pstmt, List *params,
-			   const char *queryString, EState *estate)
+EvaluateParams(ParseState *pstate, PreparedStatement *pstmt, List *params,
+			   EState *estate)
 {
 	Oid		   *param_types = pstmt->plansource->param_types;
 	int			num_params = pstmt->plansource->num_params;
 	int			nparams = list_length(params);
-	ParseState *pstate;
 	ParamListInfo paramLI;
 	List	   *exprstates;
 	ListCell   *l;
@@ -354,9 +340,6 @@ EvaluateParams(PreparedStatement *pstmt, List *params,
 	 */
 	params = copyObject(params);
 
-	pstate = make_parsestate(NULL);
-	pstate->p_sourcetext = queryString;
-
 	i = 0;
 	foreach(l, params)
 	{
@@ -648,6 +631,11 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es,
 	/* Evaluate parameters, if any */
 	if (entry->plansource->num_params)
 	{
+		ParseState *pstate;
+
+		pstate = make_parsestate(NULL);
+		pstate->p_sourcetext = queryString;
+
 		/*
 		 * Need an EState to evaluate parameters; must not delete it till end
 		 * of query, in case parameters are pass-by-reference.  Note that the
@@ -656,8 +644,8 @@ ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es,
 		 */
 		estate = CreateExecutorState();
 		estate->es_param_list_info = params;
-		paramLI = EvaluateParams(entry, execstmt->params,
-								 queryString, estate);
+
+		paramLI = EvaluateParams(pstate, entry, execstmt->params, estate);
 	}
 
 	/* Replan if needed, and acquire a transient refcount */
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index 3a03ca7e2f..0fb8c694bd 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -396,6 +396,7 @@ standard_ProcessUtility(PlannedStmt *pstmt,
 
 	pstate = make_parsestate(NULL);
 	pstate->p_sourcetext = queryString;
+	pstate->p_queryEnv = queryEnv;
 
 	switch (nodeTag(parsetree))
 	{
@@ -500,8 +501,8 @@ standard_ProcessUtility(PlannedStmt *pstmt,
 			 * Portal (cursor) manipulation
 			 */
 		case T_DeclareCursorStmt:
-			PerformCursorOpen((DeclareCursorStmt *) parsetree, params,
-							  queryString, isTopLevel);
+			PerformCursorOpen(pstate, (DeclareCursorStmt *) parsetree, params,
+							  isTopLevel);
 			break;
 
 		case T_ClosePortalStmt:
@@ -558,13 +559,14 @@ standard_ProcessUtility(PlannedStmt *pstmt,
 
 		case T_PrepareStmt:
 			CheckRestrictedOperation("PREPARE");
-			PrepareQuery((PrepareStmt *) parsetree, queryString,
+			PrepareQuery(pstate, (PrepareStmt *) parsetree,
 						 pstmt->stmt_location, pstmt->stmt_len);
 			break;
 
 		case T_ExecuteStmt:
-			ExecuteQuery((ExecuteStmt *) parsetree, NULL,
-						 queryString, params,
+			ExecuteQuery(pstate,
+						 (ExecuteStmt *) parsetree, NULL,
+						 params,
 						 dest, completionTag);
 			break;
 
@@ -667,8 +669,7 @@ standard_ProcessUtility(PlannedStmt *pstmt,
 			break;
 
 		case T_ExplainStmt:
-			ExplainQuery(pstate, (ExplainStmt *) parsetree, queryString, params,
-						 queryEnv, dest);
+			ExplainQuery(pstate, (ExplainStmt *) parsetree, params, dest);
 			break;
 
 		case T_AlterSystemStmt:
@@ -1490,9 +1491,8 @@ ProcessUtilitySlow(ParseState *pstate,
 				break;
 
 			case T_CreateTableAsStmt:
-				address = ExecCreateTableAs((CreateTableAsStmt *) parsetree,
-											queryString, params, queryEnv,
-											completionTag);
+				address = ExecCreateTableAs(pstate, (CreateTableAsStmt *) parsetree,
+											params, queryEnv, completionTag);
 				break;
 
 			case T_RefreshMatViewStmt:
diff --git a/src/include/commands/createas.h b/src/include/commands/createas.h
index abd0525290..a5467bcba4 100644
--- a/src/include/commands/createas.h
+++ b/src/include/commands/createas.h
@@ -21,7 +21,7 @@
 #include "utils/queryenvironment.h"
 
 
-extern ObjectAddress ExecCreateTableAs(CreateTableAsStmt *stmt, const char *queryString,
+extern ObjectAddress ExecCreateTableAs(ParseState *pstate, CreateTableAsStmt *stmt,
 									   ParamListInfo params, QueryEnvironment *queryEnv, char *completionTag);
 
 extern int	GetIntoRelEFlags(IntoClause *intoClause);
diff --git a/src/include/commands/explain.h b/src/include/commands/explain.h
index 8639891c16..98d5b46337 100644
--- a/src/include/commands/explain.h
+++ b/src/include/commands/explain.h
@@ -63,8 +63,8 @@ typedef const char *(*explain_get_index_name_hook_type) (Oid indexId);
 extern PGDLLIMPORT explain_get_index_name_hook_type explain_get_index_name_hook;
 
 
-extern void ExplainQuery(ParseState *pstate, ExplainStmt *stmt, const char *queryString,
-						 ParamListInfo params, QueryEnvironment *queryEnv, DestReceiver *dest);
+extern void ExplainQuery(ParseState *pstate, ExplainStmt *stmt,
+						 ParamListInfo params, DestReceiver *dest);
 
 extern ExplainState *NewExplainState(void);
 
diff --git a/src/include/commands/portalcmds.h b/src/include/commands/portalcmds.h
index 73220981ee..640e663ed7 100644
--- a/src/include/commands/portalcmds.h
+++ b/src/include/commands/portalcmds.h
@@ -15,11 +15,12 @@
 #define PORTALCMDS_H
 
 #include "nodes/parsenodes.h"
+#include "parser/parse_node.h"
 #include "utils/portal.h"
 
 
-extern void PerformCursorOpen(DeclareCursorStmt *cstmt, ParamListInfo params,
-							  const char *queryString, bool isTopLevel);
+extern void PerformCursorOpen(ParseState *pstate, DeclareCursorStmt *cstmt, ParamListInfo params,
+							  bool isTopLevel);
 
 extern void PerformPortalFetch(FetchStmt *stmt, DestReceiver *dest,
 							   char *completionTag);
diff --git a/src/include/commands/prepare.h b/src/include/commands/prepare.h
index 2ce832419f..c828f62473 100644
--- a/src/include/commands/prepare.h
+++ b/src/include/commands/prepare.h
@@ -35,10 +35,11 @@ typedef struct
 
 
 /* Utility statements PREPARE, EXECUTE, DEALLOCATE, EXPLAIN EXECUTE */
-extern void PrepareQuery(PrepareStmt *stmt, const char *queryString,
+extern void PrepareQuery(ParseState *pstate, PrepareStmt *stmt,
 						 int stmt_location, int stmt_len);
-extern void ExecuteQuery(ExecuteStmt *stmt, IntoClause *intoClause,
-						 const char *queryString, ParamListInfo params,
+extern void ExecuteQuery(ParseState *pstate,
+						 ExecuteStmt *stmt, IntoClause *intoClause,
+						 ParamListInfo params,
 						 DestReceiver *dest, char *completionTag);
 extern void DeallocateQuery(DeallocateStmt *stmt);
 extern void ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into,
-- 
2.24.0