PostgreSQL Source Code  git master
parse_node.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * parse_node.c
4  * various routines that make nodes for querytrees
5  *
6  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/parser/parse_node.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 #include "postgres.h"
16 
17 #include "access/htup_details.h"
18 #include "access/table.h"
19 #include "catalog/pg_type.h"
20 #include "mb/pg_wchar.h"
21 #include "nodes/makefuncs.h"
22 #include "nodes/miscnodes.h"
23 #include "nodes/nodeFuncs.h"
24 #include "nodes/subscripting.h"
25 #include "parser/parse_node.h"
26 #include "utils/builtins.h"
27 #include "utils/lsyscache.h"
28 
29 static void pcb_error_callback(void *arg);
30 
31 
32 /*
33  * make_parsestate
34  * Allocate and initialize a new ParseState.
35  *
36  * Caller should eventually release the ParseState via free_parsestate().
37  */
38 ParseState *
39 make_parsestate(ParseState *parentParseState)
40 {
41  ParseState *pstate;
42 
43  pstate = palloc0(sizeof(ParseState));
44 
45  pstate->parentParseState = parentParseState;
46 
47  /* Fill in fields that don't start at null/false/zero */
48  pstate->p_next_resno = 1;
49  pstate->p_resolve_unknowns = true;
50 
51  if (parentParseState)
52  {
53  pstate->p_sourcetext = parentParseState->p_sourcetext;
54  /* all hooks are copied from parent */
55  pstate->p_pre_columnref_hook = parentParseState->p_pre_columnref_hook;
56  pstate->p_post_columnref_hook = parentParseState->p_post_columnref_hook;
57  pstate->p_paramref_hook = parentParseState->p_paramref_hook;
58  pstate->p_coerce_param_hook = parentParseState->p_coerce_param_hook;
59  pstate->p_ref_hook_state = parentParseState->p_ref_hook_state;
60  /* query environment stays in context for the whole parse analysis */
61  pstate->p_queryEnv = parentParseState->p_queryEnv;
62  }
63 
64  return pstate;
65 }
66 
67 /*
68  * free_parsestate
69  * Release a ParseState and any subsidiary resources.
70  */
71 void
73 {
74  /*
75  * Check that we did not produce too many resnos; at the very least we
76  * cannot allow more than 2^16, since that would exceed the range of a
77  * AttrNumber. It seems safest to use MaxTupleAttributeNumber.
78  */
79  if (pstate->p_next_resno - 1 > MaxTupleAttributeNumber)
80  ereport(ERROR,
81  (errcode(ERRCODE_TOO_MANY_COLUMNS),
82  errmsg("target lists can have at most %d entries",
84 
85  if (pstate->p_target_relation != NULL)
87 
88  pfree(pstate);
89 }
90 
91 
92 /*
93  * parser_errposition
94  * Report a parse-analysis-time cursor position, if possible.
95  *
96  * This is expected to be used within an ereport() call. The return value
97  * is a dummy (always 0, in fact).
98  *
99  * The locations stored in raw parsetrees are byte offsets into the source
100  * string. We have to convert them to 1-based character indexes for reporting
101  * to clients. (We do things this way to avoid unnecessary overhead in the
102  * normal non-error case: computing character indexes would be much more
103  * expensive than storing token offsets.)
104  */
105 int
106 parser_errposition(ParseState *pstate, int location)
107 {
108  int pos;
109 
110  /* No-op if location was not provided */
111  if (location < 0)
112  return 0;
113  /* Can't do anything if source text is not available */
114  if (pstate == NULL || pstate->p_sourcetext == NULL)
115  return 0;
116  /* Convert offset to character number */
117  pos = pg_mbstrlen_with_len(pstate->p_sourcetext, location) + 1;
118  /* And pass it to the ereport mechanism */
119  return errposition(pos);
120 }
121 
122 
123 /*
124  * setup_parser_errposition_callback
125  * Arrange for non-parser errors to report an error position
126  *
127  * Sometimes the parser calls functions that aren't part of the parser
128  * subsystem and can't reasonably be passed a ParseState; yet we would
129  * like any errors thrown in those functions to be tagged with a parse
130  * error location. Use this function to set up an error context stack
131  * entry that will accomplish that. Usage pattern:
132  *
133  * declare a local variable "ParseCallbackState pcbstate"
134  * ...
135  * setup_parser_errposition_callback(&pcbstate, pstate, location);
136  * call function that might throw error;
137  * cancel_parser_errposition_callback(&pcbstate);
138  */
139 void
141  ParseState *pstate, int location)
142 {
143  /* Setup error traceback support for ereport() */
144  pcbstate->pstate = pstate;
145  pcbstate->location = location;
147  pcbstate->errcallback.arg = (void *) pcbstate;
149  error_context_stack = &pcbstate->errcallback;
150 }
151 
152 /*
153  * Cancel a previously-set-up errposition callback.
154  */
155 void
157 {
158  /* Pop the error context stack */
160 }
161 
162 /*
163  * Error context callback for inserting parser error location.
164  *
165  * Note that this will be called for *any* error occurring while the
166  * callback is installed. We avoid inserting an irrelevant error location
167  * if the error is a query cancel --- are there any other important cases?
168  */
169 static void
171 {
172  ParseCallbackState *pcbstate = (ParseCallbackState *) arg;
173 
174  if (geterrcode() != ERRCODE_QUERY_CANCELED)
175  (void) parser_errposition(pcbstate->pstate, pcbstate->location);
176 }
177 
178 
179 /*
180  * transformContainerType()
181  * Identify the actual container type for a subscripting operation.
182  *
183  * containerType/containerTypmod are modified if necessary to identify
184  * the actual container type and typmod. This mainly involves smashing
185  * any domain to its base type, but there are some special considerations.
186  * Note that caller still needs to check if the result type is a container.
187  */
188 void
189 transformContainerType(Oid *containerType, int32 *containerTypmod)
190 {
191  /*
192  * If the input is a domain, smash to base type, and extract the actual
193  * typmod to be applied to the base type. Subscripting a domain is an
194  * operation that necessarily works on the base container type, not the
195  * domain itself. (Note that we provide no method whereby the creator of a
196  * domain over a container type could hide its ability to be subscripted.)
197  */
198  *containerType = getBaseTypeAndTypmod(*containerType, containerTypmod);
199 
200  /*
201  * We treat int2vector and oidvector as though they were domains over
202  * int2[] and oid[]. This is needed because array slicing could create an
203  * array that doesn't satisfy the dimensionality constraints of the
204  * xxxvector type; so we want the result of a slice operation to be
205  * considered to be of the more general type.
206  */
207  if (*containerType == INT2VECTOROID)
208  *containerType = INT2ARRAYOID;
209  else if (*containerType == OIDVECTOROID)
210  *containerType = OIDARRAYOID;
211 }
212 
213 /*
214  * transformContainerSubscripts()
215  * Transform container (array, etc) subscripting. This is used for both
216  * container fetch and container assignment.
217  *
218  * In a container fetch, we are given a source container value and we produce
219  * an expression that represents the result of extracting a single container
220  * element or a container slice.
221  *
222  * Container assignments are treated basically the same as container fetches
223  * here. The caller will modify the result node to insert the source value
224  * that is to be assigned to the element or slice that a fetch would have
225  * retrieved. The execution result will be a new container value with
226  * the source value inserted into the right part of the container.
227  *
228  * For both cases, if the source is of a domain-over-container type, the
229  * result is the same as if it had been of the container type; essentially,
230  * we must fold a domain to its base type before applying subscripting.
231  * (Note that int2vector and oidvector are treated as domains here.)
232  *
233  * pstate Parse state
234  * containerBase Already-transformed expression for the container as a whole
235  * containerType OID of container's datatype (should match type of
236  * containerBase, or be the base type of containerBase's
237  * domain type)
238  * containerTypMod typmod for the container
239  * indirection Untransformed list of subscripts (must not be NIL)
240  * isAssignment True if this will become a container assignment.
241  */
244  Node *containerBase,
245  Oid containerType,
246  int32 containerTypMod,
247  List *indirection,
248  bool isAssignment)
249 {
250  SubscriptingRef *sbsref;
251  const SubscriptRoutines *sbsroutines;
252  Oid elementType;
253  bool isSlice = false;
254  ListCell *idx;
255 
256  /*
257  * Determine the actual container type, smashing any domain. In the
258  * assignment case the caller already did this, since it also needs to
259  * know the actual container type.
260  */
261  if (!isAssignment)
262  transformContainerType(&containerType, &containerTypMod);
263 
264  /*
265  * Verify that the container type is subscriptable, and get its support
266  * functions and typelem.
267  */
268  sbsroutines = getSubscriptingRoutines(containerType, &elementType);
269  if (!sbsroutines)
270  ereport(ERROR,
271  (errcode(ERRCODE_DATATYPE_MISMATCH),
272  errmsg("cannot subscript type %s because it does not support subscripting",
273  format_type_be(containerType)),
274  parser_errposition(pstate, exprLocation(containerBase))));
275 
276  /*
277  * Detect whether any of the indirection items are slice specifiers.
278  *
279  * A list containing only simple subscripts refers to a single container
280  * element. If any of the items are slice specifiers (lower:upper), then
281  * the subscript expression means a container slice operation.
282  */
283  foreach(idx, indirection)
284  {
286 
287  if (ai->is_slice)
288  {
289  isSlice = true;
290  break;
291  }
292  }
293 
294  /*
295  * Ready to build the SubscriptingRef node.
296  */
297  sbsref = makeNode(SubscriptingRef);
298 
299  sbsref->refcontainertype = containerType;
300  sbsref->refelemtype = elementType;
301  /* refrestype is to be set by container-specific logic */
302  sbsref->reftypmod = containerTypMod;
303  /* refcollid will be set by parse_collate.c */
304  /* refupperindexpr, reflowerindexpr are to be set by container logic */
305  sbsref->refexpr = (Expr *) containerBase;
306  sbsref->refassgnexpr = NULL; /* caller will fill if it's an assignment */
307 
308  /*
309  * Call the container-type-specific logic to transform the subscripts and
310  * determine the subscripting result type.
311  */
312  sbsroutines->transform(sbsref, indirection, pstate,
313  isSlice, isAssignment);
314 
315  /*
316  * Verify we got a valid type (this defends, for example, against someone
317  * using array_subscript_handler as typsubscript without setting typelem).
318  */
319  if (!OidIsValid(sbsref->refrestype))
320  ereport(ERROR,
321  (errcode(ERRCODE_DATATYPE_MISMATCH),
322  errmsg("cannot subscript type %s because it does not support subscripting",
323  format_type_be(containerType))));
324 
325  return sbsref;
326 }
327 
328 /*
329  * make_const
330  *
331  * Convert an A_Const node (as returned by the grammar) to a Const node
332  * of the "natural" type for the constant. Note that this routine is
333  * only used when there is no explicit cast for the constant, so we
334  * have to guess what type is wanted.
335  *
336  * For string literals we produce a constant of type UNKNOWN ---- whose
337  * representation is the same as cstring, but it indicates to later type
338  * resolution that we're not sure yet what type it should be considered.
339  * Explicit "NULL" constants are also typed as UNKNOWN.
340  *
341  * For integers and floats we produce int4, int8, or numeric depending
342  * on the value of the number. XXX We should produce int2 as well,
343  * but additional cleanup is needed before we can do that; there are
344  * too many examples that fail if we try.
345  */
346 Const *
347 make_const(ParseState *pstate, A_Const *aconst)
348 {
349  Const *con;
350  Datum val;
351  Oid typeid;
352  int typelen;
353  bool typebyval;
354  ParseCallbackState pcbstate;
355 
356  if (aconst->isnull)
357  {
358  /* return a null const */
359  con = makeConst(UNKNOWNOID,
360  -1,
361  InvalidOid,
362  -2,
363  (Datum) 0,
364  true,
365  false);
366  con->location = aconst->location;
367  return con;
368  }
369 
370  switch (nodeTag(&aconst->val))
371  {
372  case T_Integer:
373  val = Int32GetDatum(intVal(&aconst->val));
374 
375  typeid = INT4OID;
376  typelen = sizeof(int32);
377  typebyval = true;
378  break;
379 
380  case T_Float:
381  {
382  /* could be an oversize integer as well as a float ... */
383 
384  ErrorSaveContext escontext = {T_ErrorSaveContext};
385  int64 val64;
386 
387  val64 = pg_strtoint64_safe(aconst->val.fval.fval, (Node *) &escontext);
388  if (!escontext.error_occurred)
389  {
390  /*
391  * It might actually fit in int32. Probably only INT_MIN
392  * can occur, but we'll code the test generally just to be
393  * sure.
394  */
395  int32 val32 = (int32) val64;
396 
397  if (val64 == (int64) val32)
398  {
399  val = Int32GetDatum(val32);
400 
401  typeid = INT4OID;
402  typelen = sizeof(int32);
403  typebyval = true;
404  }
405  else
406  {
407  val = Int64GetDatum(val64);
408 
409  typeid = INT8OID;
410  typelen = sizeof(int64);
411  typebyval = FLOAT8PASSBYVAL; /* int8 and float8 alike */
412  }
413  }
414  else
415  {
416  /* arrange to report location if numeric_in() fails */
417  setup_parser_errposition_callback(&pcbstate, pstate, aconst->location);
419  CStringGetDatum(aconst->val.fval.fval),
421  Int32GetDatum(-1));
423 
424  typeid = NUMERICOID;
425  typelen = -1; /* variable len */
426  typebyval = false;
427  }
428  break;
429  }
430 
431  case T_Boolean:
432  val = BoolGetDatum(boolVal(&aconst->val));
433 
434  typeid = BOOLOID;
435  typelen = 1;
436  typebyval = true;
437  break;
438 
439  case T_String:
440 
441  /*
442  * We assume here that UNKNOWN's internal representation is the
443  * same as CSTRING
444  */
445  val = CStringGetDatum(strVal(&aconst->val));
446 
447  typeid = UNKNOWNOID; /* will be coerced later */
448  typelen = -2; /* cstring-style varwidth type */
449  typebyval = false;
450  break;
451 
452  case T_BitString:
453  /* arrange to report location if bit_in() fails */
454  setup_parser_errposition_callback(&pcbstate, pstate, aconst->location);
456  CStringGetDatum(aconst->val.bsval.bsval),
458  Int32GetDatum(-1));
460  typeid = BITOID;
461  typelen = -1;
462  typebyval = false;
463  break;
464 
465  default:
466  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(&aconst->val));
467  return NULL; /* keep compiler quiet */
468  }
469 
470  con = makeConst(typeid,
471  -1, /* typmod -1 is OK for all cases */
472  InvalidOid, /* all cases are uncollatable types */
473  typelen,
474  val,
475  false,
476  typebyval);
477  con->location = aconst->location;
478 
479  return con;
480 }
Datum idx(PG_FUNCTION_ARGS)
Definition: _int_op.c:259
Datum numeric_in(PG_FUNCTION_ARGS)
Definition: numeric.c:628
signed int int32
Definition: c.h:494
#define FLOAT8PASSBYVAL
Definition: c.h:635
#define OidIsValid(objectId)
Definition: c.h:775
int geterrcode(void)
Definition: elog.c:1563
ErrorContextCallback * error_context_stack
Definition: elog.c:94
int errcode(int sqlerrcode)
Definition: elog.c:859
int errmsg(const char *fmt,...)
Definition: elog.c:1072
int errposition(int cursorpos)
Definition: elog.c:1448
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
#define ereport(elevel,...)
Definition: elog.h:149
Datum Int64GetDatum(int64 X)
Definition: fmgr.c:1807
#define DirectFunctionCall3(func, arg1, arg2, arg3)
Definition: fmgr.h:646
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
#define MaxTupleAttributeNumber
Definition: htup_details.h:34
long val
Definition: informix.c:670
#define NoLock
Definition: lockdefs.h:34
Oid getBaseTypeAndTypmod(Oid typid, int32 *typmod)
Definition: lsyscache.c:2516
const struct SubscriptRoutines * getSubscriptingRoutines(Oid typid, Oid *typelemp)
Definition: lsyscache.c:3108
Const * makeConst(Oid consttype, int32 consttypmod, Oid constcollid, int constlen, Datum constvalue, bool constisnull, bool constbyval)
Definition: makefuncs.c:301
int pg_mbstrlen_with_len(const char *mbstr, int limit)
Definition: mbutils.c:1057
void pfree(void *pointer)
Definition: mcxt.c:1520
void * palloc0(Size size)
Definition: mcxt.c:1346
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1386
#define nodeTag(nodeptr)
Definition: nodes.h:133
#define makeNode(_type_)
Definition: nodes.h:155
int64 pg_strtoint64_safe(const char *s, Node *escontext)
Definition: numutils.c:651
void cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
Definition: parse_node.c:156
void free_parsestate(ParseState *pstate)
Definition: parse_node.c:72
SubscriptingRef * transformContainerSubscripts(ParseState *pstate, Node *containerBase, Oid containerType, int32 containerTypMod, List *indirection, bool isAssignment)
Definition: parse_node.c:243
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
void setup_parser_errposition_callback(ParseCallbackState *pcbstate, ParseState *pstate, int location)
Definition: parse_node.c:140
ParseState * make_parsestate(ParseState *parentParseState)
Definition: parse_node.c:39
void transformContainerType(Oid *containerType, int32 *containerTypmod)
Definition: parse_node.c:189
static void pcb_error_callback(void *arg)
Definition: parse_node.c:170
Const * make_const(ParseState *pstate, A_Const *aconst)
Definition: parse_node.c:347
void * arg
#define lfirst_node(type, lc)
Definition: pg_list.h:176
uintptr_t Datum
Definition: postgres.h:64
static Datum BoolGetDatum(bool X)
Definition: postgres.h:102
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
static Datum CStringGetDatum(const char *X)
Definition: postgres.h:350
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
bool isnull
Definition: parsenodes.h:363
union ValUnion val
Definition: parsenodes.h:362
ParseLoc location
Definition: parsenodes.h:364
bool is_slice
Definition: parsenodes.h:459
char * bsval
Definition: value.h:76
struct ErrorContextCallback * previous
Definition: elog.h:295
void(* callback)(void *arg)
Definition: elog.h:296
bool error_occurred
Definition: miscnodes.h:46
char * fval
Definition: value.h:52
Definition: pg_list.h:54
Definition: nodes.h:129
ErrorContextCallback errcallback
Definition: parse_node.h:336
ParseState * pstate
Definition: parse_node.h:334
ParseState * parentParseState
Definition: parse_node.h:192
void * p_ref_hook_state
Definition: parse_node.h:239
ParseParamRefHook p_paramref_hook
Definition: parse_node.h:237
PreParseColumnRefHook p_pre_columnref_hook
Definition: parse_node.h:235
QueryEnvironment * p_queryEnv
Definition: parse_node.h:220
const char * p_sourcetext
Definition: parse_node.h:193
bool p_resolve_unknowns
Definition: parse_node.h:217
int p_next_resno
Definition: parse_node.h:212
Relation p_target_relation
Definition: parse_node.h:207
CoerceParamHook p_coerce_param_hook
Definition: parse_node.h:238
PostParseColumnRefHook p_post_columnref_hook
Definition: parse_node.h:236
SubscriptTransform transform
Definition: subscripting.h:160
Expr * refassgnexpr
Definition: primnodes.h:673
Expr * refexpr
Definition: primnodes.h:671
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
BitString bsval
Definition: parsenodes.h:354
Float fval
Definition: parsenodes.h:351
#define boolVal(v)
Definition: value.h:81
#define intVal(v)
Definition: value.h:79
#define strVal(v)
Definition: value.h:82
Datum bit_in(PG_FUNCTION_ARGS)
Definition: varbit.c:147