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