PostgreSQL Source Code: src/backend/parser/parse_param.c Source File

PostgreSQL Source Code git master
parse_param.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * parse_param.c
4 * handle parameters in parser
5 *
6 * This code covers two cases that are used within the core backend:
7 * * a fixed list of parameters with known types
8 * * an expandable list of parameters whose types can optionally
9 * be determined from context
10 * In both cases, only explicit $n references (ParamRef nodes) are supported.
11 *
12 * Note that other approaches to parameters are possible using the parser
13 * hooks defined in ParseState.
14 *
15 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
16 * Portions Copyright (c) 1994, Regents of the University of California
17 *
18 *
19 * IDENTIFICATION
20 * src/backend/parser/parse_param.c
21 *
22 *-------------------------------------------------------------------------
23 */
24
25#include "postgres.h"
26
27#include <limits.h>
28
29#include "catalog/pg_type.h"
30#include "nodes/nodeFuncs.h"
31#include "parser/parse_param.h"
32#include "utils/builtins.h"
33#include "utils/lsyscache.h"
34#include "utils/memutils.h"
35
36
37 typedef struct FixedParamState
38{
39 const Oid *paramTypes; /* array of parameter type OIDs */
40 int numParams; /* number of array entries */
41 } FixedParamState;
42
43/*
44 * In the varparams case, the caller-supplied OID array (if any) can be
45 * re-palloc'd larger at need. A zero array entry means that parameter number
46 * hasn't been seen, while UNKNOWNOID means the parameter has been used but
47 * its type is not yet known.
48 */
49 typedef struct VarParamState
50{
51 Oid **paramTypes; /* array of parameter type OIDs */
52 int *numParams; /* number of array entries */
53 } VarParamState;
54
55static Node *fixed_paramref_hook(ParseState *pstate, ParamRef *pref);
56static Node *variable_paramref_hook(ParseState *pstate, ParamRef *pref);
57static Node *variable_coerce_param_hook(ParseState *pstate, Param *param,
58 Oid targetTypeId, int32 targetTypeMod,
59 int location);
60static bool check_parameter_resolution_walker(Node *node, ParseState *pstate);
61static bool query_contains_extern_params_walker(Node *node, void *context);
62
63
64/*
65 * Set up to process a query containing references to fixed parameters.
66 */
67void
68 setup_parse_fixed_parameters(ParseState *pstate,
69 const Oid *paramTypes, int numParams)
70{
71 FixedParamState *parstate = palloc(sizeof(FixedParamState));
72
73 parstate->paramTypes = paramTypes;
74 parstate->numParams = numParams;
75 pstate->p_ref_hook_state = parstate;
76 pstate->p_paramref_hook = fixed_paramref_hook;
77 /* no need to use p_coerce_param_hook */
78}
79
80/*
81 * Set up to process a query containing references to variable parameters.
82 */
83void
84 setup_parse_variable_parameters(ParseState *pstate,
85 Oid **paramTypes, int *numParams)
86{
87 VarParamState *parstate = palloc(sizeof(VarParamState));
88
89 parstate->paramTypes = paramTypes;
90 parstate->numParams = numParams;
91 pstate->p_ref_hook_state = parstate;
92 pstate->p_paramref_hook = variable_paramref_hook;
93 pstate->p_coerce_param_hook = variable_coerce_param_hook;
94}
95
96/*
97 * Transform a ParamRef using fixed parameter types.
98 */
99static Node *
100 fixed_paramref_hook(ParseState *pstate, ParamRef *pref)
101{
102 FixedParamState *parstate = (FixedParamState *) pstate->p_ref_hook_state;
103 int paramno = pref->number;
104 Param *param;
105
106 /* Check parameter number is valid */
107 if (paramno <= 0 || paramno > parstate->numParams ||
108 !OidIsValid(parstate->paramTypes[paramno - 1]))
109 ereport(ERROR,
110 (errcode(ERRCODE_UNDEFINED_PARAMETER),
111 errmsg("there is no parameter $%d", paramno),
112 parser_errposition(pstate, pref->location)));
113
114 param = makeNode(Param);
115 param->paramkind = PARAM_EXTERN;
116 param->paramid = paramno;
117 param->paramtype = parstate->paramTypes[paramno - 1];
118 param->paramtypmod = -1;
119 param->paramcollid = get_typcollation(param->paramtype);
120 param->location = pref->location;
121
122 return (Node *) param;
123}
124
125/*
126 * Transform a ParamRef using variable parameter types.
127 *
128 * The only difference here is we must enlarge the parameter type array
129 * as needed.
130 */
131static Node *
132 variable_paramref_hook(ParseState *pstate, ParamRef *pref)
133{
134 VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
135 int paramno = pref->number;
136 Oid *pptype;
137 Param *param;
138
139 /* Check parameter number is in range */
140 if (paramno <= 0 || paramno > MaxAllocSize / sizeof(Oid))
141 ereport(ERROR,
142 (errcode(ERRCODE_UNDEFINED_PARAMETER),
143 errmsg("there is no parameter $%d", paramno),
144 parser_errposition(pstate, pref->location)));
145 if (paramno > *parstate->numParams)
146 {
147 /* Need to enlarge param array */
148 if (*parstate->paramTypes)
149 *parstate->paramTypes = repalloc0_array(*parstate->paramTypes, Oid,
150 *parstate->numParams, paramno);
151 else
152 *parstate->paramTypes = palloc0_array(Oid, paramno);
153 *parstate->numParams = paramno;
154 }
155
156 /* Locate param's slot in array */
157 pptype = &(*parstate->paramTypes)[paramno - 1];
158
159 /* If not seen before, initialize to UNKNOWN type */
160 if (*pptype == InvalidOid)
161 *pptype = UNKNOWNOID;
162
163 /*
164 * If the argument is of type void and it's procedure call, interpret it
165 * as unknown. This allows the JDBC driver to not have to distinguish
166 * function and procedure calls. See also another component of this hack
167 * in ParseFuncOrColumn().
168 */
169 if (*pptype == VOIDOID && pstate->p_expr_kind == EXPR_KIND_CALL_ARGUMENT)
170 *pptype = UNKNOWNOID;
171
172 param = makeNode(Param);
173 param->paramkind = PARAM_EXTERN;
174 param->paramid = paramno;
175 param->paramtype = *pptype;
176 param->paramtypmod = -1;
177 param->paramcollid = get_typcollation(param->paramtype);
178 param->location = pref->location;
179
180 return (Node *) param;
181}
182
183/*
184 * Coerce a Param to a query-requested datatype, in the varparams case.
185 */
186static Node *
187 variable_coerce_param_hook(ParseState *pstate, Param *param,
188 Oid targetTypeId, int32 targetTypeMod,
189 int location)
190{
191 if (param->paramkind == PARAM_EXTERN && param->paramtype == UNKNOWNOID)
192 {
193 /*
194 * Input is a Param of previously undetermined type, and we want to
195 * update our knowledge of the Param's type.
196 */
197 VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
198 Oid *paramTypes = *parstate->paramTypes;
199 int paramno = param->paramid;
200
201 if (paramno <= 0 || /* shouldn't happen, but... */
202 paramno > *parstate->numParams)
203 ereport(ERROR,
204 (errcode(ERRCODE_UNDEFINED_PARAMETER),
205 errmsg("there is no parameter $%d", paramno),
206 parser_errposition(pstate, param->location)));
207
208 if (paramTypes[paramno - 1] == UNKNOWNOID)
209 {
210 /* We've successfully resolved the type */
211 paramTypes[paramno - 1] = targetTypeId;
212 }
213 else if (paramTypes[paramno - 1] == targetTypeId)
214 {
215 /* We previously resolved the type, and it matches */
216 }
217 else
218 {
219 /* Oops */
220 ereport(ERROR,
221 (errcode(ERRCODE_AMBIGUOUS_PARAMETER),
222 errmsg("inconsistent types deduced for parameter $%d",
223 paramno),
224 errdetail("%s versus %s",
225 format_type_be(paramTypes[paramno - 1]),
226 format_type_be(targetTypeId)),
227 parser_errposition(pstate, param->location)));
228 }
229
230 param->paramtype = targetTypeId;
231
232 /*
233 * Note: it is tempting here to set the Param's paramtypmod to
234 * targetTypeMod, but that is probably unwise because we have no
235 * infrastructure that enforces that the value delivered for a Param
236 * will match any particular typmod. Leaving it -1 ensures that a
237 * run-time length check/coercion will occur if needed.
238 */
239 param->paramtypmod = -1;
240
241 /*
242 * This module always sets a Param's collation to be the default for
243 * its datatype. If that's not what you want, you should be using the
244 * more general parser substitution hooks.
245 */
246 param->paramcollid = get_typcollation(param->paramtype);
247
248 /* Use the leftmost of the param's and coercion's locations */
249 if (location >= 0 &&
250 (param->location < 0 || location < param->location))
251 param->location = location;
252
253 return (Node *) param;
254 }
255
256 /* Else signal to proceed with normal coercion */
257 return NULL;
258}
259
260/*
261 * Check for consistent assignment of variable parameters after completion
262 * of parsing with parse_variable_parameters.
263 *
264 * Note: this code intentionally does not check that all parameter positions
265 * were used, nor that all got non-UNKNOWN types assigned. Caller of parser
266 * should enforce that if it's important.
267 */
268void
269 check_variable_parameters(ParseState *pstate, Query *query)
270{
271 VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
272
273 /* If numParams is zero then no Params were generated, so no work */
274 if (*parstate->numParams > 0)
275 (void) query_tree_walker(query,
276 check_parameter_resolution_walker,
277 pstate, 0);
278}
279
280/*
281 * Traverse a fully-analyzed tree to verify that parameter symbols
282 * match their types. We need this because some Params might still
283 * be UNKNOWN, if there wasn't anything to force their coercion,
284 * and yet other instances seen later might have gotten coerced.
285 */
286static bool
287 check_parameter_resolution_walker(Node *node, ParseState *pstate)
288{
289 if (node == NULL)
290 return false;
291 if (IsA(node, Param))
292 {
293 Param *param = (Param *) node;
294
295 if (param->paramkind == PARAM_EXTERN)
296 {
297 VarParamState *parstate = (VarParamState *) pstate->p_ref_hook_state;
298 int paramno = param->paramid;
299
300 if (paramno <= 0 || /* shouldn't happen, but... */
301 paramno > *parstate->numParams)
302 ereport(ERROR,
303 (errcode(ERRCODE_UNDEFINED_PARAMETER),
304 errmsg("there is no parameter $%d", paramno),
305 parser_errposition(pstate, param->location)));
306
307 if (param->paramtype != (*parstate->paramTypes)[paramno - 1])
308 ereport(ERROR,
309 (errcode(ERRCODE_AMBIGUOUS_PARAMETER),
310 errmsg("could not determine data type of parameter $%d",
311 paramno),
312 parser_errposition(pstate, param->location)));
313 }
314 return false;
315 }
316 if (IsA(node, Query))
317 {
318 /* Recurse into RTE subquery or not-yet-planned sublink subquery */
319 return query_tree_walker((Query *) node,
320 check_parameter_resolution_walker,
321 pstate, 0);
322 }
323 return expression_tree_walker(node, check_parameter_resolution_walker,
324 pstate);
325}
326
327/*
328 * Check to see if a fully-parsed query tree contains any PARAM_EXTERN Params.
329 */
330bool
331 query_contains_extern_params(Query *query)
332{
333 return query_tree_walker(query,
334 query_contains_extern_params_walker,
335 NULL, 0);
336}
337
338static bool
339 query_contains_extern_params_walker(Node *node, void *context)
340{
341 if (node == NULL)
342 return false;
343 if (IsA(node, Param))
344 {
345 Param *param = (Param *) node;
346
347 if (param->paramkind == PARAM_EXTERN)
348 return true;
349 return false;
350 }
351 if (IsA(node, Query))
352 {
353 /* Recurse into RTE subquery or not-yet-planned sublink subquery */
354 return query_tree_walker((Query *) node,
355 query_contains_extern_params_walker,
356 context, 0);
357 }
358 return expression_tree_walker(node, query_contains_extern_params_walker,
359 context);
360}
int32_t int32
Definition: c.h:534
#define OidIsValid(objectId)
Definition: c.h:774
int errdetail(const char *fmt,...)
Definition: elog.c:1207
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:150
#define MaxAllocSize
Definition: fe_memutils.h:22
#define palloc0_array(type, count)
Definition: fe_memutils.h:77
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:81
Oid get_typcollation(Oid typid)
Definition: lsyscache.c:3223
void * palloc(Size size)
Definition: mcxt.c:1365
#define query_tree_walker(q, w, c, f)
Definition: nodeFuncs.h:158
#define expression_tree_walker(n, w, c)
Definition: nodeFuncs.h:153
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
#define makeNode(_type_)
Definition: nodes.h:161
#define repalloc0_array(pointer, type, oldcount, count)
Definition: palloc.h:109
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
@ EXPR_KIND_CALL_ARGUMENT
Definition: parse_node.h:81
void check_variable_parameters(ParseState *pstate, Query *query)
Definition: parse_param.c:269
struct FixedParamState FixedParamState
bool query_contains_extern_params(Query *query)
Definition: parse_param.c:331
void setup_parse_variable_parameters(ParseState *pstate, Oid **paramTypes, int *numParams)
Definition: parse_param.c:84
static Node * variable_coerce_param_hook(ParseState *pstate, Param *param, Oid targetTypeId, int32 targetTypeMod, int location)
Definition: parse_param.c:187
static Node * variable_paramref_hook(ParseState *pstate, ParamRef *pref)
Definition: parse_param.c:132
void setup_parse_fixed_parameters(ParseState *pstate, const Oid *paramTypes, int numParams)
Definition: parse_param.c:68
struct VarParamState VarParamState
static Node * fixed_paramref_hook(ParseState *pstate, ParamRef *pref)
Definition: parse_param.c:100
static bool check_parameter_resolution_walker(Node *node, ParseState *pstate)
Definition: parse_param.c:287
static bool query_contains_extern_params_walker(Node *node, void *context)
Definition: parse_param.c:339
#define InvalidOid
Definition: postgres_ext.h:37
unsigned int Oid
Definition: postgres_ext.h:32
@ PARAM_EXTERN
Definition: primnodes.h:384
const Oid * paramTypes
Definition: parse_param.c:39
Definition: nodes.h:135
ParseLoc location
Definition: parsenodes.h:322
int number
Definition: parsenodes.h:321
Definition: primnodes.h:391
ParseLoc location
Definition: primnodes.h:403
int32 paramtypmod
Definition: primnodes.h:399
int paramid
Definition: primnodes.h:396
Oid paramtype
Definition: primnodes.h:397
ParamKind paramkind
Definition: primnodes.h:395
Oid paramcollid
Definition: primnodes.h:401
void * p_ref_hook_state
Definition: parse_node.h:242
ParseExprKind p_expr_kind
Definition: parse_node.h:214
ParseParamRefHook p_paramref_hook
Definition: parse_node.h:240
CoerceParamHook p_coerce_param_hook
Definition: parse_node.h:241
Definition: parsenodes.h:118
Oid ** paramTypes
Definition: parse_param.c:51
int * numParams
Definition: parse_param.c:52

AltStyle によって変換されたページ (->オリジナル) /