1/*-------------------------------------------------------------------------
2 *
3 * parse_node.c
4 * various routines that make nodes for querytrees
5 *
6 * Portions Copyright (c) 1996-2019, 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 "parser/parsetree.h"
24#include "parser/parse_coerce.h"
25#include "parser/parse_expr.h"
26#include "parser/parse_relation.h"
27#include "utils/builtins.h"
28#include "utils/int8.h"
29#include "utils/lsyscache.h"
30#include "utils/syscache.h"
31#include "utils/varbit.h"
32
33
34static 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 */
43ParseState *
44make_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 */
76void
77free_parsestate(ParseState *pstate)
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",
88 MaxTupleAttributeNumber)));
89
90 if (pstate->p_target_relation != NULL)
91 table_close(pstate->p_target_relation, NoLock);
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 */
110int
111parser_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 */
144void
145setup_parser_errposition_callback(ParseCallbackState *pcbstate,
146 ParseState *pstate, int location)
147{
148 /* Setup error traceback support for ereport() */
149 pcbstate->pstate = pstate;
150 pcbstate->location = location;
151 pcbstate->errcallback.callback = pcb_error_callback;
152 pcbstate->errcallback.arg = (void *) pcbstate;
153 pcbstate->errcallback.previous = error_context_stack;
154 error_context_stack = &pcbstate->errcallback;
155}
156
157/*
158 * Cancel a previously-set-up errposition callback.
159 */
160void
161cancel_parser_errposition_callback(ParseCallbackState *pcbstate)
162{
163 /* Pop the error context stack */
164 error_context_stack = pcbstate->errcallback.previous;
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 */
174static void
175pcb_error_callback(void *arg)
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 * make_var
186 * Build a Var node for an attribute identified by RTE and attrno
187 */
188Var *
189make_var(ParseState *pstate, RangeTblEntry *rte, int attrno, int location)
190{
191 Var *result;
192 int vnum,
193 sublevels_up;
194 Oid vartypeid;
195 int32 type_mod;
196 Oid varcollid;
197
198 vnum = RTERangeTablePosn(pstate, rte, &sublevels_up);
199 get_rte_attribute_type(rte, attrno, &vartypeid, &type_mod, &varcollid);
200 result = makeVar(vnum, attrno, vartypeid, type_mod, varcollid, sublevels_up);
201 result->location = location;
202 return result;
203}
204
205/*
206 * transformContainerType()
207 * Identify the types involved in a subscripting operation for container
208 *
209 *
210 * On entry, containerType/containerTypmod identify the type of the input value
211 * to be subscripted (which could be a domain type). These are modified if
212 * necessary to identify the actual container type and typmod, and the
213 * container's element type is returned. An error is thrown if the input isn't
214 * an array type.
215 */
216Oid
217transformContainerType(Oid *containerType, int32 *containerTypmod)
218{
219 Oid origContainerType = *containerType;
220 Oid elementType;
221 HeapTuple type_tuple_container;
222 Form_pg_type type_struct_container;
223
224 /*
225 * If the input is a domain, smash to base type, and extract the actual
226 * typmod to be applied to the base type. Subscripting a domain is an
227 * operation that necessarily works on the base container type, not the
228 * domain itself. (Note that we provide no method whereby the creator of a
229 * domain over a container type could hide its ability to be subscripted.)
230 */
231 *containerType = getBaseTypeAndTypmod(*containerType, containerTypmod);
232
233 /*
234 * Here is an array specific code. We treat int2vector and oidvector as
235 * though they were domains over int2[] and oid[]. This is needed because
236 * array slicing could create an array that doesn't satisfy the
237 * dimensionality constraints of the xxxvector type; so we want the result
238 * of a slice operation to be considered to be of the more general type.
239 */
240 if (*containerType == INT2VECTOROID)
241 *containerType = INT2ARRAYOID;
242 else if (*containerType == OIDVECTOROID)
243 *containerType = OIDARRAYOID;
244
245 /* Get the type tuple for the container */
246 type_tuple_container = SearchSysCache1(TYPEOID, ObjectIdGetDatum(*containerType));
247 if (!HeapTupleIsValid(type_tuple_container))
248 elog(ERROR, "cache lookup failed for type %u", *containerType);
249 type_struct_container = (Form_pg_type) GETSTRUCT(type_tuple_container);
250
251 /* needn't check typisdefined since this will fail anyway */
252
253 elementType = type_struct_container->typelem;
254 if (elementType == InvalidOid)
255 ereport(ERROR,
256 (errcode(ERRCODE_DATATYPE_MISMATCH),
257 errmsg("cannot subscript type %s because it is not an array",
258 format_type_be(origContainerType))));
259
260 ReleaseSysCache(type_tuple_container);
261
262 return elementType;
263}
264
265/*
266 * transformContainerSubscripts()
267 * Transform container (array, etc) subscripting. This is used for both
268 * container fetch and container assignment.
269 *
270 * In a container fetch, we are given a source container value and we produce
271 * an expression that represents the result of extracting a single container
272 * element or a container slice.
273 *
274 * In a container assignment, we are given a destination container value plus a
275 * source value that is to be assigned to a single element or a slice of that
276 * container. We produce an expression that represents the new container value
277 * with the source data inserted into the right part of the container.
278 *
279 * For both cases, if the source container is of a domain-over-array type,
280 * the result is of the base array type or its element type; essentially,
281 * we must fold a domain to its base type before applying subscripting.
282 * (Note that int2vector and oidvector are treated as domains here.)
283 *
284 * pstate Parse state
285 * containerBase Already-transformed expression for the container as a whole
286 * containerType OID of container's datatype (should match type of
287 * containerBase, or be the base type of containerBase's
288 * domain type)
289 * elementType OID of container's element type (fetch with
290 * transformContainerType, or pass InvalidOid to do it here)
291 * containerTypMod typmod for the container (which is also typmod for the
292 * elements)
293 * indirection Untransformed list of subscripts (must not be NIL)
294 * assignFrom NULL for container fetch, else transformed expression for
295 * source.
296 */
297SubscriptingRef *
298transformContainerSubscripts(ParseState *pstate,
299 Node *containerBase,
300 Oid containerType,
301 Oid elementType,
302 int32 containerTypMod,
303 List *indirection,
304 Node *assignFrom)
305{
306 bool isSlice = false;
307 List *upperIndexpr = NIL;
308 List *lowerIndexpr = NIL;
309 ListCell *idx;
310 SubscriptingRef *sbsref;
311
312 /*
313 * Caller may or may not have bothered to determine elementType. Note
314 * that if the caller did do so, containerType/containerTypMod must be as
315 * modified by transformContainerType, ie, smash domain to base type.
316 */
317 if (!OidIsValid(elementType))
318 elementType = transformContainerType(&containerType, &containerTypMod);
319
320 /*
321 * A list containing only simple subscripts refers to a single container
322 * element. If any of the items are slice specifiers (lower:upper), then
323 * the subscript expression means a container slice operation. In this
324 * case, we convert any non-slice items to slices by treating the single
325 * subscript as the upper bound and supplying an assumed lower bound of 1.
326 * We have to prescan the list to see if there are any slice items.
327 */
328 foreach(idx, indirection)
329 {
330 A_Indices *ai = (A_Indices *) lfirst(idx);
331
332 if (ai->is_slice)
333 {
334 isSlice = true;
335 break;
336 }
337 }
338
339 /*
340 * Transform the subscript expressions.
341 */
342 foreach(idx, indirection)
343 {
344 A_Indices *ai = lfirst_node(A_Indices, idx);
345 Node *subexpr;
346
347 if (isSlice)
348 {
349 if (ai->lidx)
350 {
351 subexpr = transformExpr(pstate, ai->lidx, pstate->p_expr_kind);
352 /* If it's not int4 already, try to coerce */
353 subexpr = coerce_to_target_type(pstate,
354 subexpr, exprType(subexpr),
355 INT4OID, -1,
356 COERCION_ASSIGNMENT,
357 COERCE_IMPLICIT_CAST,
358 -1);
359 if (subexpr == NULL)
360 ereport(ERROR,
361 (errcode(ERRCODE_DATATYPE_MISMATCH),
362 errmsg("array subscript must have type integer"),
363 parser_errposition(pstate, exprLocation(ai->lidx))));
364 }
365 else if (!ai->is_slice)
366 {
367 /* Make a constant 1 */
368 subexpr = (Node *) makeConst(INT4OID,
369 -1,
370 InvalidOid,
371 sizeof(int32),
372 Int32GetDatum(1),
373 false,
374 true); /* pass by value */
375 }
376 else
377 {
378 /* Slice with omitted lower bound, put NULL into the list */
379 subexpr = NULL;
380 }
381 lowerIndexpr = lappend(lowerIndexpr, subexpr);
382 }
383 else
384 Assert(ai->lidx == NULL && !ai->is_slice);
385
386 if (ai->uidx)
387 {
388 subexpr = transformExpr(pstate, ai->uidx, pstate->p_expr_kind);
389 /* If it's not int4 already, try to coerce */
390 subexpr = coerce_to_target_type(pstate,
391 subexpr, exprType(subexpr),
392 INT4OID, -1,
393 COERCION_ASSIGNMENT,
394 COERCE_IMPLICIT_CAST,
395 -1);
396 if (subexpr == NULL)
397 ereport(ERROR,
398 (errcode(ERRCODE_DATATYPE_MISMATCH),
399 errmsg("array subscript must have type integer"),
400 parser_errposition(pstate, exprLocation(ai->uidx))));
401 }
402 else
403 {
404 /* Slice with omitted upper bound, put NULL into the list */
405 Assert(isSlice && ai->is_slice);
406 subexpr = NULL;
407 }
408 upperIndexpr = lappend(upperIndexpr, subexpr);
409 }
410
411 /*
412 * If doing an array store, coerce the source value to the right type.
413 * (This should agree with the coercion done by transformAssignedExpr.)
414 */
415 if (assignFrom != NULL)
416 {
417 Oid typesource = exprType(assignFrom);
418 Oid typeneeded = isSlice ? containerType : elementType;
419 Node *newFrom;
420
421 newFrom = coerce_to_target_type(pstate,
422 assignFrom, typesource,
423 typeneeded, containerTypMod,
424 COERCION_ASSIGNMENT,
425 COERCE_IMPLICIT_CAST,
426 -1);
427 if (newFrom == NULL)
428 ereport(ERROR,
429 (errcode(ERRCODE_DATATYPE_MISMATCH),
430 errmsg("array assignment requires type %s"
431 " but expression is of type %s",
432 format_type_be(typeneeded),
433 format_type_be(typesource)),
434 errhint("You will need to rewrite or cast the expression."),
435 parser_errposition(pstate, exprLocation(assignFrom))));
436 assignFrom = newFrom;
437 }
438
439 /*
440 * Ready to build the SubscriptingRef node.
441 */
442 sbsref = (SubscriptingRef *) makeNode(SubscriptingRef);
443 if (assignFrom != NULL)
444 sbsref->refassgnexpr = (Expr *) assignFrom;
445
446 sbsref->refcontainertype = containerType;
447 sbsref->refelemtype = elementType;
448 sbsref->reftypmod = containerTypMod;
449 /* refcollid will be set by parse_collate.c */
450 sbsref->refupperindexpr = upperIndexpr;
451 sbsref->reflowerindexpr = lowerIndexpr;
452 sbsref->refexpr = (Expr *) containerBase;
453 sbsref->refassgnexpr = (Expr *) assignFrom;
454
455 return sbsref;
456}
457
458/*
459 * make_const
460 *
461 * Convert a Value node (as returned by the grammar) to a Const node
462 * of the "natural" type for the constant. Note that this routine is
463 * only used when there is no explicit cast for the constant, so we
464 * have to guess what type is wanted.
465 *
466 * For string literals we produce a constant of type UNKNOWN ---- whose
467 * representation is the same as cstring, but it indicates to later type
468 * resolution that we're not sure yet what type it should be considered.
469 * Explicit "NULL" constants are also typed as UNKNOWN.
470 *
471 * For integers and floats we produce int4, int8, or numeric depending
472 * on the value of the number. XXX We should produce int2 as well,
473 * but additional cleanup is needed before we can do that; there are
474 * too many examples that fail if we try.
475 */
476Const *
477make_const(ParseState *pstate, Value *value, int location)
478{
479 Const *con;
480 Datum val;
481 int64 val64;
482 Oid typeid;
483 int typelen;
484 bool typebyval;
485 ParseCallbackState pcbstate;
486
487 switch (nodeTag(value))
488 {
489 case T_Integer:
490 val = Int32GetDatum(intVal(value));
491
492 typeid = INT4OID;
493 typelen = sizeof(int32);
494 typebyval = true;
495 break;
496
497 case T_Float:
498 /* could be an oversize integer as well as a float ... */
499 if (scanint8(strVal(value), true, &val64))
500 {
501 /*
502 * It might actually fit in int32. Probably only INT_MIN can
503 * occur, but we'll code the test generally just to be sure.
504 */
505 int32 val32 = (int32) val64;
506
507 if (val64 == (int64) val32)
508 {
509 val = Int32GetDatum(val32);
510
511 typeid = INT4OID;
512 typelen = sizeof(int32);
513 typebyval = true;
514 }
515 else
516 {
517 val = Int64GetDatum(val64);
518
519 typeid = INT8OID;
520 typelen = sizeof(int64);
521 typebyval = FLOAT8PASSBYVAL; /* int8 and float8 alike */
522 }
523 }
524 else
525 {
526 /* arrange to report location if numeric_in() fails */
527 setup_parser_errposition_callback(&pcbstate, pstate, location);
528 val = DirectFunctionCall3(numeric_in,
529 CStringGetDatum(strVal(value)),
530 ObjectIdGetDatum(InvalidOid),
531 Int32GetDatum(-1));
532 cancel_parser_errposition_callback(&pcbstate);
533
534 typeid = NUMERICOID;
535 typelen = -1; /* variable len */
536 typebyval = false;
537 }
538 break;
539
540 case T_String:
541
542 /*
543 * We assume here that UNKNOWN's internal representation is the
544 * same as CSTRING
545 */
546 val = CStringGetDatum(strVal(value));
547
548 typeid = UNKNOWNOID; /* will be coerced later */
549 typelen = -2; /* cstring-style varwidth type */
550 typebyval = false;
551 break;
552
553 case T_BitString:
554 /* arrange to report location if bit_in() fails */
555 setup_parser_errposition_callback(&pcbstate, pstate, location);
556 val = DirectFunctionCall3(bit_in,
557 CStringGetDatum(strVal(value)),
558 ObjectIdGetDatum(InvalidOid),
559 Int32GetDatum(-1));
560 cancel_parser_errposition_callback(&pcbstate);
561 typeid = BITOID;
562 typelen = -1;
563 typebyval = false;
564 break;
565
566 case T_Null:
567 /* return a null const */
568 con = makeConst(UNKNOWNOID,
569 -1,
570 InvalidOid,
571 -2,
572 (Datum) 0,
573 true,
574 false);
575 con->location = location;
576 return con;
577
578 default:
579 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(value));
580 return NULL; /* keep compiler quiet */
581 }
582
583 con = makeConst(typeid,
584 -1, /* typmod -1 is OK for all cases */
585 InvalidOid, /* all cases are uncollatable types */
586 typelen,
587 val,
588 false,
589 typebyval);
590 con->location = location;
591
592 return con;
593}
594