Implement parser hooks for processing ColumnRef and ParamRef nodes, as per my

recent proposal.  As proof of concept, remove knowledge of Params from the
core parser, arranging for them to be handled entirely by parser hook
functions.  It turns out we need an additional hook for that --- I had
forgotten about the code that handles inferring a parameter's type from
context.

This is a preliminary step towards letting plpgsql handle its variables
through parser hooks.  Additional work remains to be done to expose the
facility through SPI, but I think this is all the changes needed in the core
parser.

1 files changed, 307 insertions, 0 deletions

diff --git a/src/backend/parser/parse_param.c b/src/backend/parser/parse_param.c
new file mode 100644
index 00000000000..1c399706558
--- /dev/null
+++ b/src/backend/parser/parse_param.c
@@ -0,0 +1,307 @@
+/*-------------------------------------------------------------------------
+ *
+ * parse_param.c
+ *	  handle parameters in parser
+ *
+ * This code covers two cases that are used within the core backend:
+ *		* a fixed list of parameters with known types
+ *		* an expandable list of parameters whose types can optionally
+ *		  be determined from context
+ * In both cases, only explicit $n references (ParamRef nodes) are supported.
+ *
+ * Note that other approaches to parameters are possible using the parser
+ * hooks defined in ParseState.
+ *
+ * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  $PostgreSQL: pgsql/src/backend/parser/parse_param.c,v 2.1 2009/10/31 01:41:31 tgl Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include <limits.h>
+
+#include "catalog/pg_type.h"
+#include "nodes/nodeFuncs.h"
+#include "parser/parse_param.h"
+#include "utils/builtins.h"
+
+
+typedef struct FixedParamState
+{
+	Oid		   *paramTypes;		/* array of parameter type OIDs */
+	int			numParams;		/* number of array entries */
+} FixedParamState;
+
+/*
+ * In the varparams case, the caller-supplied OID array (if any) can be
+ * re-palloc'd larger at need.  A zero array entry means that parameter number
+ * hasn't been seen, while UNKNOWNOID means the parameter has been used but
+ * its type is not yet known.
+ */
+typedef struct VarParamState
+{
+	Oid		  **paramTypes;		/* array of parameter type OIDs */
+	int		   *numParams;		/* number of array entries */
+} VarParamState;
+
+static Node *fixed_paramref_hook(ParseState *pstate, ParamRef *pref);
+static Node *variable_paramref_hook(ParseState *pstate, ParamRef *pref);
+static Node *variable_coerce_param_hook(ParseState *pstate, Param *param,
+										Oid targetTypeId, int32 targetTypeMod,
+										int location);
+static bool check_parameter_resolution_walker(Node *node, ParseState *pstate);
+
+
+/*
+ * Set up to process a query containing references to fixed parameters.
+ */
+void
+parse_fixed_parameters(ParseState *pstate,
+					   Oid *paramTypes, int numParams)
+{
+	FixedParamState *parstate = palloc(sizeof(FixedParamState));
+
+	parstate->paramTypes = paramTypes;
+	parstate->numParams = numParams;
+	pstate->p_ref_hook_state = (void *) parstate;
+	pstate->p_paramref_hook = fixed_paramref_hook;
+	/* no need to use p_coerce_param_hook */
+}
+
+/*
+ * Set up to process a query containing references to variable parameters.
+ */
+void
+parse_variable_parameters(ParseState *pstate,
+						  Oid **paramTypes, int *numParams)
+{
+	VarParamState *parstate = palloc(sizeof(VarParamState));
+
+	parstate->paramTypes = paramTypes;
+	parstate->numParams = numParams;
+	pstate->p_ref_hook_state = (void *) parstate;
+	pstate->p_paramref_hook = variable_paramref_hook;
+	pstate->p_coerce_param_hook = variable_coerce_param_hook;
+}
+
+/*
+ * Transform a ParamRef using fixed parameter types.
+ */
+static Node *
+fixed_paramref_hook(ParseState *pstate, ParamRef *pref)
+{
+	FixedParamState *parstate = (FixedParamState *) pstate->p_ref_hook_state;
+	int			paramno = pref->number;
+	Param	   *param;
+
+	/* Check parameter number is in range */
+	if (paramno <= 0 || paramno > parstate->numParams)
+		ereport(ERROR,
+				(errcode(ERRCODE_UNDEFINED_PARAMETER),
+				 errmsg("there is no parameter $%d", paramno),
+				 parser_errposition(pstate, pref->location)));
+
+	param = makeNode(Param);
+	param->paramkind = PARAM_EXTERN;
+	param->paramid = paramno;
+	param->paramtype = parstate->paramTypes[paramno - 1];
+	param->paramtypmod = -1;
+	param->location = pref->location;
+
+	return (Node *) param;
+}
+
+/*
+ * Transform a ParamRef using variable parameter types.
+ *
+ * The only difference here is we must enlarge the parameter type array
+ * as needed.
+ */
+static Node *
+variable_paramref_hook(ParseState *pstate, ParamRef *pref)
+{
+	VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
+	int			paramno = pref->number;
+	Oid		   *pptype;
+	Param	   *param;
+
+	/* Check parameter number is in range */
+	if (paramno <= 0 || paramno > INT_MAX / sizeof(Oid))
+		ereport(ERROR,
+				(errcode(ERRCODE_UNDEFINED_PARAMETER),
+				 errmsg("there is no parameter $%d", paramno),
+				 parser_errposition(pstate, pref->location)));
+	if (paramno > *parstate->numParams)
+	{
+		/* Need to enlarge param array */
+		if (*parstate->paramTypes)
+			*parstate->paramTypes = (Oid *) repalloc(*parstate->paramTypes,
+													 paramno * sizeof(Oid));
+		else
+			*parstate->paramTypes = (Oid *) palloc(paramno * sizeof(Oid));
+		/* Zero out the previously-unreferenced slots */
+		MemSet(*parstate->paramTypes + *parstate->numParams,
+			   0,
+			   (paramno - *parstate->numParams) * sizeof(Oid));
+		*parstate->numParams = paramno;
+	}
+
+	/* Locate param's slot in array */
+	pptype = &(*parstate->paramTypes)[paramno - 1];
+
+	/* If not seen before, initialize to UNKNOWN type */
+	if (*pptype == InvalidOid)
+		*pptype = UNKNOWNOID;
+
+	param = makeNode(Param);
+	param->paramkind = PARAM_EXTERN;
+	param->paramid = paramno;
+	param->paramtype = *pptype;
+	param->paramtypmod = -1;
+	param->location = pref->location;
+
+	return (Node *) param;
+}
+
+/*
+ * Coerce a Param to a query-requested datatype, in the varparams case.
+ */
+static Node *
+variable_coerce_param_hook(ParseState *pstate, Param *param,
+						   Oid targetTypeId, int32 targetTypeMod,
+						   int location)
+{
+	if (param->paramkind == PARAM_EXTERN && param->paramtype == UNKNOWNOID)
+	{
+		/*
+		 * Input is a Param of previously undetermined type, and we want to
+		 * update our knowledge of the Param's type.
+		 */
+		VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
+		Oid		   *paramTypes = *parstate->paramTypes;
+		int			paramno = param->paramid;
+
+		if (paramno <= 0 ||		/* shouldn't happen, but... */
+			paramno > *parstate->numParams)
+			ereport(ERROR,
+					(errcode(ERRCODE_UNDEFINED_PARAMETER),
+					 errmsg("there is no parameter $%d", paramno),
+					 parser_errposition(pstate, param->location)));
+
+		if (paramTypes[paramno - 1] == UNKNOWNOID)
+		{
+			/* We've successfully resolved the type */
+			paramTypes[paramno - 1] = targetTypeId;
+		}
+		else if (paramTypes[paramno - 1] == targetTypeId)
+		{
+			/* We previously resolved the type, and it matches */
+		}
+		else
+		{
+			/* Ooops */
+			ereport(ERROR,
+					(errcode(ERRCODE_AMBIGUOUS_PARAMETER),
+					 errmsg("inconsistent types deduced for parameter $%d",
+							paramno),
+					 errdetail("%s versus %s",
+							   format_type_be(paramTypes[paramno - 1]),
+							   format_type_be(targetTypeId)),
+					 parser_errposition(pstate, param->location)));
+		}
+
+		param->paramtype = targetTypeId;
+
+		/*
+		 * Note: it is tempting here to set the Param's paramtypmod to
+		 * targetTypeMod, but that is probably unwise because we have no
+		 * infrastructure that enforces that the value delivered for a Param
+		 * will match any particular typmod.  Leaving it -1 ensures that a
+		 * run-time length check/coercion will occur if needed.
+		 */
+		param->paramtypmod = -1;
+
+		/* Use the leftmost of the param's and coercion's locations */
+		if (location >= 0 &&
+			(param->location < 0 || location < param->location))
+			param->location = location;
+
+		return (Node *) param;
+	}
+
+	/* Else signal to proceed with normal coercion */
+	return NULL;
+}
+
+/*
+ * Check for consistent assignment of variable parameters after completion
+ * of parsing with parse_variable_parameters.
+ *
+ * Note: this code intentionally does not check that all parameter positions
+ * were used, nor that all got non-UNKNOWN types assigned.  Caller of parser
+ * should enforce that if it's important.
+ */
+void
+check_variable_parameters(ParseState *pstate, Query *query)
+{
+	VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
+
+	/* If numParams is zero then no Params were generated, so no work */
+	if (*parstate->numParams > 0)
+		(void) query_tree_walker(query,
+								 check_parameter_resolution_walker,
+								 (void *) pstate, 0);
+}
+
+/*
+ * Traverse a fully-analyzed tree to verify that parameter symbols
+ * match their types.  We need this because some Params might still
+ * be UNKNOWN, if there wasn't anything to force their coercion,
+ * and yet other instances seen later might have gotten coerced.
+ */
+static bool
+check_parameter_resolution_walker(Node *node, ParseState *pstate)
+{
+	if (node == NULL)
+		return false;
+	if (IsA(node, Param))
+	{
+		Param	   *param = (Param *) node;
+
+		if (param->paramkind == PARAM_EXTERN)
+		{
+			VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
+			int			paramno = param->paramid;
+
+			if (paramno <= 0 || /* shouldn't happen, but... */
+				paramno > *parstate->numParams)
+				ereport(ERROR,
+						(errcode(ERRCODE_UNDEFINED_PARAMETER),
+						 errmsg("there is no parameter $%d", paramno),
+						 parser_errposition(pstate, param->location)));
+
+			if (param->paramtype != (*parstate->paramTypes)[paramno - 1])
+				ereport(ERROR,
+						(errcode(ERRCODE_AMBIGUOUS_PARAMETER),
+					 errmsg("could not determine data type of parameter $%d",
+							paramno),
+						 parser_errposition(pstate, param->location)));
+		}
+		return false;
+	}
+	if (IsA(node, Query))
+	{
+		/* Recurse into RTE subquery or not-yet-planned sublink subquery */
+		return query_tree_walker((Query *) node,
+								 check_parameter_resolution_walker,
+								 (void *) pstate, 0);
+	}
+	return expression_tree_walker(node, check_parameter_resolution_walker,
+								  (void *) pstate);
+}