PostgreSQL Source Code  git master
primnodes.h
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * primnodes.h
4  * Definitions for "primitive" node types, those that are used in more
5  * than one of the parse/plan/execute stages of the query pipeline.
6  * Currently, these are mostly nodes for executable expressions
7  * and join trees.
8  *
9  *
10  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
11  * Portions Copyright (c) 1994, Regents of the University of California
12  *
13  * src/include/nodes/primnodes.h
14  *
15  *-------------------------------------------------------------------------
16  */
17 #ifndef PRIMNODES_H
18 #define PRIMNODES_H
19 
20 #include "access/attnum.h"
21 #include "nodes/bitmapset.h"
22 #include "nodes/pg_list.h"
23 
24 
25 typedef enum OverridingKind
26 {
31 
32 
33 /* ----------------------------------------------------------------
34  * node definitions
35  * ----------------------------------------------------------------
36  */
37 
38 /*
39  * Alias -
40  * specifies an alias for a range variable; the alias might also
41  * specify renaming of columns within the table.
42  *
43  * Note: colnames is a list of String nodes. In Alias structs
44  * associated with RTEs, there may be entries corresponding to dropped
45  * columns; these are normally empty strings (""). See parsenodes.h for info.
46  */
47 typedef struct Alias
48 {
50  char *aliasname; /* aliased rel name (never qualified) */
51  List *colnames; /* optional list of column aliases */
53 
54 /* What to do at commit time for temporary relations */
55 typedef enum OnCommitAction
56 {
57  ONCOMMIT_NOOP, /* No ON COMMIT clause (do nothing) */
58  ONCOMMIT_PRESERVE_ROWS, /* ON COMMIT PRESERVE ROWS (do nothing) */
59  ONCOMMIT_DELETE_ROWS, /* ON COMMIT DELETE ROWS */
60  ONCOMMIT_DROP, /* ON COMMIT DROP */
62 
63 /*
64  * RangeVar - range variable, used in FROM clauses
65  *
66  * Also used to represent table names in utility statements; there, the alias
67  * field is not used, and inh tells whether to apply the operation
68  * recursively to child tables. In some contexts it is also useful to carry
69  * a TEMP table indication here.
70  */
71 typedef struct RangeVar
72 {
74 
75  /* the catalog (database) name, or NULL */
76  char *catalogname;
77 
78  /* the schema name, or NULL */
79  char *schemaname;
80 
81  /* the relation/sequence name */
82  char *relname;
83 
84  /* expand rel by inheritance? recursively act on children? */
85  bool inh;
86 
87  /* see RELPERSISTENCE_* in pg_class.h */
89 
90  /* table alias & optional column aliases */
92 
93  /* token location, or -1 if unknown */
96 
97 typedef enum TableFuncType
98 {
102 
103 /*
104  * TableFunc - node for a table function, such as XMLTABLE and JSON_TABLE.
105  *
106  * Entries in the ns_names list are either String nodes containing
107  * literal namespace names, or NULL pointers to represent DEFAULT.
108  */
109 typedef struct TableFunc
110 {
112  /* XMLTABLE or JSON_TABLE */
114  /* list of namespace URI expressions */
115  List *ns_uris pg_node_attr(query_jumble_ignore);
116  /* list of namespace names or NULL */
117  List *ns_names pg_node_attr(query_jumble_ignore);
118  /* input document expression */
120  /* row filter expression */
122  /* column names (list of String) */
123  List *colnames pg_node_attr(query_jumble_ignore);
124  /* OID list of column type OIDs */
125  List *coltypes pg_node_attr(query_jumble_ignore);
126  /* integer list of column typmods */
127  List *coltypmods pg_node_attr(query_jumble_ignore);
128  /* OID list of column collation OIDs */
129  List *colcollations pg_node_attr(query_jumble_ignore);
130  /* list of column filter expressions */
132  /* list of column default expressions */
133  List *coldefexprs pg_node_attr(query_jumble_ignore);
134  /* JSON_TABLE: list of column value expressions */
135  List *colvalexprs pg_node_attr(query_jumble_ignore);
136  /* JSON_TABLE: list of PASSING argument expressions */
137  List *passingvalexprs pg_node_attr(query_jumble_ignore);
138  /* nullability flag for each output column */
139  Bitmapset *notnulls pg_node_attr(query_jumble_ignore);
140  /* JSON_TABLE plan */
141  Node *plan pg_node_attr(query_jumble_ignore);
142  /* counts from 0; -1 if none specified */
143  int ordinalitycol pg_node_attr(query_jumble_ignore);
144  /* token location, or -1 if unknown */
147 
148 /*
149  * IntoClause - target information for SELECT INTO, CREATE TABLE AS, and
150  * CREATE MATERIALIZED VIEW
151  *
152  * For CREATE MATERIALIZED VIEW, viewQuery is the parsed-but-not-rewritten
153  * SELECT Query for the view; otherwise it's NULL. This is irrelevant in
154  * the query jumbling as CreateTableAsStmt already includes a reference to
155  * its own Query, so ignore it. (Although it's actually Query*, we declare
156  * it as Node* to avoid a forward reference.)
157  */
158 typedef struct IntoClause
159 {
161 
162  RangeVar *rel; /* target relation name */
163  List *colNames; /* column names to assign, or NIL */
164  char *accessMethod; /* table access method */
165  List *options; /* options from WITH clause */
166  OnCommitAction onCommit; /* what do we do at COMMIT? */
167  char *tableSpaceName; /* table space to use, or NULL */
168  /* materialized view's SELECT query */
169  Node *viewQuery pg_node_attr(query_jumble_ignore);
170  bool skipData; /* true for WITH NO DATA */
172 
173 
174 /* ----------------------------------------------------------------
175  * node types for executable expressions
176  * ----------------------------------------------------------------
177  */
178 
179 /*
180  * Expr - generic superclass for executable-expression nodes
181  *
182  * All node types that are used in executable expression trees should derive
183  * from Expr (that is, have Expr as their first field). Since Expr only
184  * contains NodeTag, this is a formality, but it is an easy form of
185  * documentation. See also the ExprState node types in execnodes.h.
186  */
187 typedef struct Expr
188 {
189  pg_node_attr(abstract)
190 
191  NodeTag type;
193 
194 /*
195  * Var - expression node representing a variable (ie, a table column)
196  *
197  * In the parser and planner, varno and varattno identify the semantic
198  * referent, which is a base-relation column unless the reference is to a join
199  * USING column that isn't semantically equivalent to either join input column
200  * (because it is a FULL join or the input column requires a type coercion).
201  * In those cases varno and varattno refer to the JOIN RTE. (Early in the
202  * planner, we replace such join references by the implied expression; but up
203  * till then we want join reference Vars to keep their original identity for
204  * query-printing purposes.)
205  *
206  * At the end of planning, Var nodes appearing in upper-level plan nodes are
207  * reassigned to point to the outputs of their subplans; for example, in a
208  * join node varno becomes INNER_VAR or OUTER_VAR and varattno becomes the
209  * index of the proper element of that subplan's target list. Similarly,
210  * INDEX_VAR is used to identify Vars that reference an index column rather
211  * than a heap column. (In ForeignScan and CustomScan plan nodes, INDEX_VAR
212  * is abused to signify references to columns of a custom scan tuple type.)
213  *
214  * ROWID_VAR is used in the planner to identify nonce variables that carry
215  * row identity information during UPDATE/DELETE/MERGE. This value should
216  * never be seen outside the planner.
217  *
218  * varnullingrels is the set of RT indexes of outer joins that can force
219  * the Var's value to null (at the point where it appears in the query).
220  * See optimizer/README for discussion of that.
221  *
222  * varlevelsup is greater than zero in Vars that represent outer references.
223  * Note that it affects the meaning of all of varno, varnullingrels, and
224  * varnosyn, all of which refer to the range table of that query level.
225  *
226  * In the parser, varnosyn and varattnosyn are either identical to
227  * varno/varattno, or they specify the column's position in an aliased JOIN
228  * RTE that hides the semantic referent RTE's refname. This is a syntactic
229  * identifier as opposed to the semantic identifier; it tells ruleutils.c
230  * how to print the Var properly. varnosyn/varattnosyn retain their values
231  * throughout planning and execution, so they are particularly helpful to
232  * identify Vars when debugging. Note, however, that a Var that is generated
233  * in the planner and doesn't correspond to any simple relation column may
234  * have varnosyn = varattnosyn = 0.
235  */
236 #define INNER_VAR (-1) /* reference to inner subplan */
237 #define OUTER_VAR (-2) /* reference to outer subplan */
238 #define INDEX_VAR (-3) /* reference to index column */
239 #define ROWID_VAR (-4) /* row identity column during planning */
240 
241 #define IS_SPECIAL_VARNO(varno) ((int) (varno) < 0)
242 
243 /* Symbols for the indexes of the special RTE entries in rules */
244 #define PRS2_OLD_VARNO 1
245 #define PRS2_NEW_VARNO 2
246 
247 typedef struct Var
248 {
250 
251  /*
252  * index of this var's relation in the range table, or
253  * INNER_VAR/OUTER_VAR/etc
254  */
255  int varno;
256 
257  /*
258  * attribute number of this var, or zero for all attrs ("whole-row Var")
259  */
261 
262  /* pg_type OID for the type of this var */
263  Oid vartype pg_node_attr(query_jumble_ignore);
264  /* pg_attribute typmod value */
265  int32 vartypmod pg_node_attr(query_jumble_ignore);
266  /* OID of collation, or InvalidOid if none */
267  Oid varcollid pg_node_attr(query_jumble_ignore);
268 
269  /*
270  * RT indexes of outer joins that can replace the Var's value with null.
271  * We can omit varnullingrels in the query jumble, because it's fully
272  * determined by varno/varlevelsup plus the Var's query location.
273  */
274  Bitmapset *varnullingrels pg_node_attr(query_jumble_ignore);
275 
276  /*
277  * for subquery variables referencing outer relations; 0 in a normal var,
278  * >0 means N levels up
279  */
281 
282  /*
283  * varnosyn/varattnosyn are ignored for equality, because Vars with
284  * different syntactic identifiers are semantically the same as long as
285  * their varno/varattno match.
286  */
287  /* syntactic relation index (0 if unknown) */
288  Index varnosyn pg_node_attr(equal_ignore, query_jumble_ignore);
289  /* syntactic attribute number */
290  AttrNumber varattnosyn pg_node_attr(equal_ignore, query_jumble_ignore);
291 
292  /* token location, or -1 if unknown */
294 } Var;
295 
296 /*
297  * Const
298  *
299  * Note: for varlena data types, we make a rule that a Const node's value
300  * must be in non-extended form (4-byte header, no compression or external
301  * references). This ensures that the Const node is self-contained and makes
302  * it more likely that equal() will see logically identical values as equal.
303  *
304  * Only the constant type OID is relevant for the query jumbling.
305  */
306 typedef struct Const
307 {
308  pg_node_attr(custom_copy_equal, custom_read_write)
309 
310  Expr xpr;
311  /* pg_type OID of the constant's datatype */
313  /* typmod value, if any */
314  int32 consttypmod pg_node_attr(query_jumble_ignore);
315  /* OID of collation, or InvalidOid if none */
316  Oid constcollid pg_node_attr(query_jumble_ignore);
317  /* typlen of the constant's datatype */
318  int constlen pg_node_attr(query_jumble_ignore);
319  /* the constant's value */
320  Datum constvalue pg_node_attr(query_jumble_ignore);
321  /* whether the constant is null (if true, constvalue is undefined) */
322  bool constisnull pg_node_attr(query_jumble_ignore);
323 
324  /*
325  * Whether this datatype is passed by value. If true, then all the
326  * information is stored in the Datum. If false, then the Datum contains
327  * a pointer to the information.
328  */
329  bool constbyval pg_node_attr(query_jumble_ignore);
330 
331  /*
332  * token location, or -1 if unknown. All constants are tracked as
333  * locations in query jumbling, to be marked as parameters.
334  */
335  ParseLoc location pg_node_attr(query_jumble_location);
337 
338 /*
339  * Param
340  *
341  * paramkind specifies the kind of parameter. The possible values
342  * for this field are:
343  *
344  * PARAM_EXTERN: The parameter value is supplied from outside the plan.
345  * Such parameters are numbered from 1 to n.
346  *
347  * PARAM_EXEC: The parameter is an internal executor parameter, used
348  * for passing values into and out of sub-queries or from
349  * nestloop joins to their inner scans.
350  * For historical reasons, such parameters are numbered from 0.
351  * These numbers are independent of PARAM_EXTERN numbers.
352  *
353  * PARAM_SUBLINK: The parameter represents an output column of a SubLink
354  * node's sub-select. The column number is contained in the
355  * `paramid' field. (This type of Param is converted to
356  * PARAM_EXEC during planning.)
357  *
358  * PARAM_MULTIEXPR: Like PARAM_SUBLINK, the parameter represents an
359  * output column of a SubLink node's sub-select, but here, the
360  * SubLink is always a MULTIEXPR SubLink. The high-order 16 bits
361  * of the `paramid' field contain the SubLink's subLinkId, and
362  * the low-order 16 bits contain the column number. (This type
363  * of Param is also converted to PARAM_EXEC during planning.)
364  */
365 typedef enum ParamKind
366 {
372 
373 typedef struct Param
374 {
376  ParamKind paramkind; /* kind of parameter. See above */
377  int paramid; /* numeric ID for parameter */
378  Oid paramtype; /* pg_type OID of parameter's datatype */
379  /* typmod value, if known */
380  int32 paramtypmod pg_node_attr(query_jumble_ignore);
381  /* OID of collation, or InvalidOid if none */
382  Oid paramcollid pg_node_attr(query_jumble_ignore);
383  /* token location, or -1 if unknown */
386 
387 /*
388  * Aggref
389  *
390  * The aggregate's args list is a targetlist, ie, a list of TargetEntry nodes.
391  *
392  * For a normal (non-ordered-set) aggregate, the non-resjunk TargetEntries
393  * represent the aggregate's regular arguments (if any) and resjunk TLEs can
394  * be added at the end to represent ORDER BY expressions that are not also
395  * arguments. As in a top-level Query, the TLEs can be marked with
396  * ressortgroupref indexes to let them be referenced by SortGroupClause
397  * entries in the aggorder and/or aggdistinct lists. This represents ORDER BY
398  * and DISTINCT operations to be applied to the aggregate input rows before
399  * they are passed to the transition function. The grammar only allows a
400  * simple "DISTINCT" specifier for the arguments, but we use the full
401  * query-level representation to allow more code sharing.
402  *
403  * For an ordered-set aggregate, the args list represents the WITHIN GROUP
404  * (aggregated) arguments, all of which will be listed in the aggorder list.
405  * DISTINCT is not supported in this case, so aggdistinct will be NIL.
406  * The direct arguments appear in aggdirectargs (as a list of plain
407  * expressions, not TargetEntry nodes).
408  *
409  * aggtranstype is the data type of the state transition values for this
410  * aggregate (resolved to an actual type, if agg's transtype is polymorphic).
411  * This is determined during planning and is InvalidOid before that.
412  *
413  * aggargtypes is an OID list of the data types of the direct and regular
414  * arguments. Normally it's redundant with the aggdirectargs and args lists,
415  * but in a combining aggregate, it's not because the args list has been
416  * replaced with a single argument representing the partial-aggregate
417  * transition values.
418  *
419  * aggpresorted is set by the query planner for ORDER BY and DISTINCT
420  * aggregates where the chosen plan provides presorted input for this
421  * aggregate during execution.
422  *
423  * aggsplit indicates the expected partial-aggregation mode for the Aggref's
424  * parent plan node. It's always set to AGGSPLIT_SIMPLE in the parser, but
425  * the planner might change it to something else. We use this mainly as
426  * a crosscheck that the Aggrefs match the plan; but note that when aggsplit
427  * indicates a non-final mode, aggtype reflects the transition data type
428  * not the SQL-level output type of the aggregate.
429  *
430  * aggno and aggtransno are -1 in the parse stage, and are set in planning.
431  * Aggregates with the same 'aggno' represent the same aggregate expression,
432  * and can share the result. Aggregates with same 'transno' but different
433  * 'aggno' can share the same transition state, only the final function needs
434  * to be called separately.
435  *
436  * Information related to collations, transition types and internal states
437  * are irrelevant for the query jumbling.
438  */
439 typedef struct Aggref
440 {
442 
443  /* pg_proc Oid of the aggregate */
445 
446  /* type Oid of result of the aggregate */
447  Oid aggtype pg_node_attr(query_jumble_ignore);
448 
449  /* OID of collation of result */
450  Oid aggcollid pg_node_attr(query_jumble_ignore);
451 
452  /* OID of collation that function should use */
453  Oid inputcollid pg_node_attr(query_jumble_ignore);
454 
455  /*
456  * type Oid of aggregate's transition value; ignored for equal since it
457  * might not be set yet
458  */
459  Oid aggtranstype pg_node_attr(equal_ignore, query_jumble_ignore);
460 
461  /* type Oids of direct and aggregated args */
462  List *aggargtypes pg_node_attr(query_jumble_ignore);
463 
464  /* direct arguments, if an ordered-set agg */
466 
467  /* aggregated arguments and sort expressions */
469 
470  /* ORDER BY (list of SortGroupClause) */
472 
473  /* DISTINCT (list of SortGroupClause) */
475 
476  /* FILTER expression, if any */
478 
479  /* true if argument list was really '*' */
480  bool aggstar pg_node_attr(query_jumble_ignore);
481 
482  /*
483  * true if variadic arguments have been combined into an array last
484  * argument
485  */
486  bool aggvariadic pg_node_attr(query_jumble_ignore);
487 
488  /* aggregate kind (see pg_aggregate.h) */
489  char aggkind pg_node_attr(query_jumble_ignore);
490 
491  /* aggregate input already sorted */
492  bool aggpresorted pg_node_attr(equal_ignore, query_jumble_ignore);
493 
494  /* > 0 if agg belongs to outer query */
495  Index agglevelsup pg_node_attr(query_jumble_ignore);
496 
497  /* expected agg-splitting mode of parent Agg */
498  AggSplit aggsplit pg_node_attr(query_jumble_ignore);
499 
500  /* unique ID within the Agg node */
501  int aggno pg_node_attr(query_jumble_ignore);
502 
503  /* unique ID of transition state in the Agg */
504  int aggtransno pg_node_attr(query_jumble_ignore);
505 
506  /* token location, or -1 if unknown */
509 
510 /*
511  * GroupingFunc
512  *
513  * A GroupingFunc is a GROUPING(...) expression, which behaves in many ways
514  * like an aggregate function (e.g. it "belongs" to a specific query level,
515  * which might not be the one immediately containing it), but also differs in
516  * an important respect: it never evaluates its arguments, they merely
517  * designate expressions from the GROUP BY clause of the query level to which
518  * it belongs.
519  *
520  * The spec defines the evaluation of GROUPING() purely by syntactic
521  * replacement, but we make it a real expression for optimization purposes so
522  * that one Agg node can handle multiple grouping sets at once. Evaluating the
523  * result only needs the column positions to check against the grouping set
524  * being projected. However, for EXPLAIN to produce meaningful output, we have
525  * to keep the original expressions around, since expression deparse does not
526  * give us any feasible way to get at the GROUP BY clause.
527  *
528  * Also, we treat two GroupingFunc nodes as equal if they have equal arguments
529  * lists and agglevelsup, without comparing the refs and cols annotations.
530  *
531  * In raw parse output we have only the args list; parse analysis fills in the
532  * refs list, and the planner fills in the cols list.
533  *
534  * All the fields used as information for an internal state are irrelevant
535  * for the query jumbling.
536  */
537 typedef struct GroupingFunc
538 {
540 
541  /* arguments, not evaluated but kept for benefit of EXPLAIN etc. */
542  List *args pg_node_attr(query_jumble_ignore);
543 
544  /* ressortgrouprefs of arguments */
545  List *refs pg_node_attr(equal_ignore);
546 
547  /* actual column positions set by planner */
548  List *cols pg_node_attr(equal_ignore, query_jumble_ignore);
549 
550  /* same as Aggref.agglevelsup */
552 
553  /* token location */
556 
557 /*
558  * WindowFunc
559  *
560  * Collation information is irrelevant for the query jumbling, as is the
561  * internal state information of the node like "winstar" and "winagg".
562  */
563 typedef struct WindowFunc
564 {
566  /* pg_proc Oid of the function */
568  /* type Oid of result of the window function */
569  Oid wintype pg_node_attr(query_jumble_ignore);
570  /* OID of collation of result */
571  Oid wincollid pg_node_attr(query_jumble_ignore);
572  /* OID of collation that function should use */
573  Oid inputcollid pg_node_attr(query_jumble_ignore);
574  /* arguments to the window function */
576  /* FILTER expression, if any */
578  /* List of WindowFuncRunConditions to help short-circuit execution */
579  List *runCondition pg_node_attr(query_jumble_ignore);
580  /* index of associated WindowClause */
582  /* true if argument list was really '*' */
583  bool winstar pg_node_attr(query_jumble_ignore);
584  /* is function a simple aggregate? */
585  bool winagg pg_node_attr(query_jumble_ignore);
586  /* token location, or -1 if unknown */
589 
590 /*
591  * WindowFuncRunCondition
592  *
593  * Represents intermediate OpExprs which will be used by WindowAgg to
594  * short-circuit execution.
595  */
597 {
599 
600  /* PG_OPERATOR OID of the operator */
602  /* OID of collation that operator should use */
603  Oid inputcollid pg_node_attr(query_jumble_ignore);
604 
605  /*
606  * true of WindowFunc belongs on the left of the resulting OpExpr or false
607  * if the WindowFunc is on the right.
608  */
610 
611  /*
612  * The Expr being compared to the WindowFunc to use in the OpExpr in the
613  * WindowAgg's runCondition
614  */
617 
618 /*
619  * MergeSupportFunc
620  *
621  * A MergeSupportFunc is a merge support function expression that can only
622  * appear in the RETURNING list of a MERGE command. It returns information
623  * about the currently executing merge action.
624  *
625  * Currently, the only supported function is MERGE_ACTION(), which returns the
626  * command executed ("INSERT", "UPDATE", or "DELETE").
627  */
628 typedef struct MergeSupportFunc
629 {
631  /* type Oid of result */
633  /* OID of collation, or InvalidOid if none */
635  /* token location, or -1 if unknown */
638 
639 /*
640  * SubscriptingRef: describes a subscripting operation over a container
641  * (array, etc).
642  *
643  * A SubscriptingRef can describe fetching a single element from a container,
644  * fetching a part of a container (e.g. an array slice), storing a single
645  * element into a container, or storing a slice. The "store" cases work with
646  * an initial container value and a source value that is inserted into the
647  * appropriate part of the container; the result of the operation is an
648  * entire new modified container value.
649  *
650  * If reflowerindexpr = NIL, then we are fetching or storing a single container
651  * element at the subscripts given by refupperindexpr. Otherwise we are
652  * fetching or storing a container slice, that is a rectangular subcontainer
653  * with lower and upper bounds given by the index expressions.
654  * reflowerindexpr must be the same length as refupperindexpr when it
655  * is not NIL.
656  *
657  * In the slice case, individual expressions in the subscript lists can be
658  * NULL, meaning "substitute the array's current lower or upper bound".
659  * (Non-array containers may or may not support this.)
660  *
661  * refcontainertype is the actual container type that determines the
662  * subscripting semantics. (This will generally be either the exposed type of
663  * refexpr, or the base type if that is a domain.) refelemtype is the type of
664  * the container's elements; this is saved for the use of the subscripting
665  * functions, but is not used by the core code. refrestype, reftypmod, and
666  * refcollid describe the type of the SubscriptingRef's result. In a store
667  * expression, refrestype will always match refcontainertype; in a fetch,
668  * it could be refelemtype for an element fetch, or refcontainertype for a
669  * slice fetch, or possibly something else as determined by type-specific
670  * subscripting logic. Likewise, reftypmod and refcollid will match the
671  * container's properties in a store, but could be different in a fetch.
672  *
673  * Any internal state data is ignored for the query jumbling.
674  *
675  * Note: for the cases where a container is returned, if refexpr yields a R/W
676  * expanded container, then the implementation is allowed to modify that
677  * object in-place and return the same object.
678  */
679 typedef struct SubscriptingRef
680 {
682  /* type of the container proper */
683  Oid refcontainertype pg_node_attr(query_jumble_ignore);
684  /* the container type's pg_type.typelem */
685  Oid refelemtype pg_node_attr(query_jumble_ignore);
686  /* type of the SubscriptingRef's result */
687  Oid refrestype pg_node_attr(query_jumble_ignore);
688  /* typmod of the result */
689  int32 reftypmod pg_node_attr(query_jumble_ignore);
690  /* collation of result, or InvalidOid if none */
691  Oid refcollid pg_node_attr(query_jumble_ignore);
692  /* expressions that evaluate to upper container indexes */
694 
695  /*
696  * expressions that evaluate to lower container indexes, or NIL for single
697  * container element.
698  */
700  /* the expression that evaluates to a container value */
702  /* expression for the source value, or NULL if fetch */
705 
706 /*
707  * CoercionContext - distinguishes the allowed set of type casts
708  *
709  * NB: ordering of the alternatives is significant; later (larger) values
710  * allow more casts than earlier ones.
711  */
712 typedef enum CoercionContext
713 {
714  COERCION_IMPLICIT, /* coercion in context of expression */
715  COERCION_ASSIGNMENT, /* coercion in context of assignment */
716  COERCION_PLPGSQL, /* if no assignment cast, use CoerceViaIO */
717  COERCION_EXPLICIT, /* explicit cast operation */
719 
720 /*
721  * CoercionForm - how to display a FuncExpr or related node
722  *
723  * "Coercion" is a bit of a misnomer, since this value records other
724  * special syntaxes besides casts, but for now we'll keep this naming.
725  *
726  * NB: equal() ignores CoercionForm fields, therefore this *must* not carry
727  * any semantically significant information. We need that behavior so that
728  * the planner will consider equivalent implicit and explicit casts to be
729  * equivalent. In cases where those actually behave differently, the coercion
730  * function's arguments will be different.
731  */
732 typedef enum CoercionForm
733 {
734  COERCE_EXPLICIT_CALL, /* display as a function call */
735  COERCE_EXPLICIT_CAST, /* display as an explicit cast */
736  COERCE_IMPLICIT_CAST, /* implicit cast, so hide it */
737  COERCE_SQL_SYNTAX, /* display with SQL-mandated special syntax */
739 
740 /*
741  * FuncExpr - expression node for a function call
742  *
743  * Collation information is irrelevant for the query jumbling, only the
744  * arguments and the function OID matter.
745  */
746 typedef struct FuncExpr
747 {
749  /* PG_PROC OID of the function */
751  /* PG_TYPE OID of result value */
752  Oid funcresulttype pg_node_attr(query_jumble_ignore);
753  /* true if function returns set */
754  bool funcretset pg_node_attr(query_jumble_ignore);
755 
756  /*
757  * true if variadic arguments have been combined into an array last
758  * argument
759  */
760  bool funcvariadic pg_node_attr(query_jumble_ignore);
761  /* how to display this function call */
762  CoercionForm funcformat pg_node_attr(query_jumble_ignore);
763  /* OID of collation of result */
764  Oid funccollid pg_node_attr(query_jumble_ignore);
765  /* OID of collation that function should use */
766  Oid inputcollid pg_node_attr(query_jumble_ignore);
767  /* arguments to the function */
769  /* token location, or -1 if unknown */
772 
773 /*
774  * NamedArgExpr - a named argument of a function
775  *
776  * This node type can only appear in the args list of a FuncCall or FuncExpr
777  * node. We support pure positional call notation (no named arguments),
778  * named notation (all arguments are named), and mixed notation (unnamed
779  * arguments followed by named ones).
780  *
781  * Parse analysis sets argnumber to the positional index of the argument,
782  * but doesn't rearrange the argument list.
783  *
784  * The planner will convert argument lists to pure positional notation
785  * during expression preprocessing, so execution never sees a NamedArgExpr.
786  */
787 typedef struct NamedArgExpr
788 {
790  /* the argument expression */
792  /* the name */
793  char *name pg_node_attr(query_jumble_ignore);
794  /* argument's number in positional notation */
796  /* argument name location, or -1 if unknown */
799 
800 /*
801  * OpExpr - expression node for an operator invocation
802  *
803  * Semantically, this is essentially the same as a function call.
804  *
805  * Note that opfuncid is not necessarily filled in immediately on creation
806  * of the node. The planner makes sure it is valid before passing the node
807  * tree to the executor, but during parsing/planning opfuncid can be 0.
808  * Therefore, equal() will accept a zero value as being equal to other values.
809  *
810  * Internal state information and collation data is irrelevant for the query
811  * jumbling.
812  */
813 typedef struct OpExpr
814 {
816 
817  /* PG_OPERATOR OID of the operator */
819 
820  /* PG_PROC OID of underlying function */
821  Oid opfuncid pg_node_attr(equal_ignore_if_zero, query_jumble_ignore);
822 
823  /* PG_TYPE OID of result value */
824  Oid opresulttype pg_node_attr(query_jumble_ignore);
825 
826  /* true if operator returns set */
827  bool opretset pg_node_attr(query_jumble_ignore);
828 
829  /* OID of collation of result */
830  Oid opcollid pg_node_attr(query_jumble_ignore);
831 
832  /* OID of collation that operator should use */
833  Oid inputcollid pg_node_attr(query_jumble_ignore);
834 
835  /* arguments to the operator (1 or 2) */
837 
838  /* token location, or -1 if unknown */
841 
842 /*
843  * DistinctExpr - expression node for "x IS DISTINCT FROM y"
844  *
845  * Except for the nodetag, this is represented identically to an OpExpr
846  * referencing the "=" operator for x and y.
847  * We use "=", not the more obvious "<>", because more datatypes have "="
848  * than "<>". This means the executor must invert the operator result.
849  * Note that the operator function won't be called at all if either input
850  * is NULL, since then the result can be determined directly.
851  */
853 
854 /*
855  * NullIfExpr - a NULLIF expression
856  *
857  * Like DistinctExpr, this is represented the same as an OpExpr referencing
858  * the "=" operator for x and y.
859  */
861 
862 /*
863  * ScalarArrayOpExpr - expression node for "scalar op ANY/ALL (array)"
864  *
865  * The operator must yield boolean. It is applied to the left operand
866  * and each element of the righthand array, and the results are combined
867  * with OR or AND (for ANY or ALL respectively). The node representation
868  * is almost the same as for the underlying operator, but we need a useOr
869  * flag to remember whether it's ANY or ALL, and we don't have to store
870  * the result type (or the collation) because it must be boolean.
871  *
872  * A ScalarArrayOpExpr with a valid hashfuncid is evaluated during execution
873  * by building a hash table containing the Const values from the RHS arg.
874  * This table is probed during expression evaluation. The planner will set
875  * hashfuncid to the hash function which must be used to build and probe the
876  * hash table. The executor determines if it should use hash-based checks or
877  * the more traditional means based on if the hashfuncid is set or not.
878  *
879  * When performing hashed NOT IN, the negfuncid will also be set to the
880  * equality function which the hash table must use to build and probe the hash
881  * table. opno and opfuncid will remain set to the <> operator and its
882  * corresponding function and won't be used during execution. For
883  * non-hashtable based NOT INs, negfuncid will be set to InvalidOid. See
884  * convert_saop_to_hashed_saop().
885  *
886  * Similar to OpExpr, opfuncid, hashfuncid, and negfuncid are not necessarily
887  * filled in right away, so will be ignored for equality if they are not set
888  * yet.
889  *
890  * OID entries of the internal function types are irrelevant for the query
891  * jumbling, but the operator OID and the arguments are.
892  */
893 typedef struct ScalarArrayOpExpr
894 {
896 
897  /* PG_OPERATOR OID of the operator */
899 
900  /* PG_PROC OID of comparison function */
901  Oid opfuncid pg_node_attr(equal_ignore_if_zero, query_jumble_ignore);
902 
903  /* PG_PROC OID of hash func or InvalidOid */
904  Oid hashfuncid pg_node_attr(equal_ignore_if_zero, query_jumble_ignore);
905 
906  /* PG_PROC OID of negator of opfuncid function or InvalidOid. See above */
907  Oid negfuncid pg_node_attr(equal_ignore_if_zero, query_jumble_ignore);
908 
909  /* true for ANY, false for ALL */
910  bool useOr;
911 
912  /* OID of collation that operator should use */
913  Oid inputcollid pg_node_attr(query_jumble_ignore);
914 
915  /* the scalar and array operands */
917 
918  /* token location, or -1 if unknown */
921 
922 /*
923  * BoolExpr - expression node for the basic Boolean operators AND, OR, NOT
924  *
925  * Notice the arguments are given as a List. For NOT, of course the list
926  * must always have exactly one element. For AND and OR, there can be two
927  * or more arguments.
928  */
929 typedef enum BoolExprType
930 {
933 
934 typedef struct BoolExpr
935 {
936  pg_node_attr(custom_read_write)
937 
938  Expr xpr;
940  List *args; /* arguments to this expression */
941  ParseLoc location; /* token location, or -1 if unknown */
943 
944 /*
945  * SubLink
946  *
947  * A SubLink represents a subselect appearing in an expression, and in some
948  * cases also the combining operator(s) just above it. The subLinkType
949  * indicates the form of the expression represented:
950  * EXISTS_SUBLINK EXISTS(SELECT ...)
951  * ALL_SUBLINK (lefthand) op ALL (SELECT ...)
952  * ANY_SUBLINK (lefthand) op ANY (SELECT ...)
953  * ROWCOMPARE_SUBLINK (lefthand) op (SELECT ...)
954  * EXPR_SUBLINK (SELECT with single targetlist item ...)
955  * MULTIEXPR_SUBLINK (SELECT with multiple targetlist items ...)
956  * ARRAY_SUBLINK ARRAY(SELECT with single targetlist item ...)
957  * CTE_SUBLINK WITH query (never actually part of an expression)
958  * For ALL, ANY, and ROWCOMPARE, the lefthand is a list of expressions of the
959  * same length as the subselect's targetlist. ROWCOMPARE will *always* have
960  * a list with more than one entry; if the subselect has just one target
961  * then the parser will create an EXPR_SUBLINK instead (and any operator
962  * above the subselect will be represented separately).
963  * ROWCOMPARE, EXPR, and MULTIEXPR require the subselect to deliver at most
964  * one row (if it returns no rows, the result is NULL).
965  * ALL, ANY, and ROWCOMPARE require the combining operators to deliver boolean
966  * results. ALL and ANY combine the per-row results using AND and OR
967  * semantics respectively.
968  * ARRAY requires just one target column, and creates an array of the target
969  * column's type using any number of rows resulting from the subselect.
970  *
971  * SubLink is classed as an Expr node, but it is not actually executable;
972  * it must be replaced in the expression tree by a SubPlan node during
973  * planning.
974  *
975  * NOTE: in the raw output of gram.y, testexpr contains just the raw form
976  * of the lefthand expression (if any), and operName is the String name of
977  * the combining operator. Also, subselect is a raw parsetree. During parse
978  * analysis, the parser transforms testexpr into a complete boolean expression
979  * that compares the lefthand value(s) to PARAM_SUBLINK nodes representing the
980  * output columns of the subselect. And subselect is transformed to a Query.
981  * This is the representation seen in saved rules and in the rewriter.
982  *
983  * In EXISTS, EXPR, MULTIEXPR, and ARRAY SubLinks, testexpr and operName
984  * are unused and are always null.
985  *
986  * subLinkId is currently used only for MULTIEXPR SubLinks, and is zero in
987  * other SubLinks. This number identifies different multiple-assignment
988  * subqueries within an UPDATE statement's SET list. It is unique only
989  * within a particular targetlist. The output column(s) of the MULTIEXPR
990  * are referenced by PARAM_MULTIEXPR Params appearing elsewhere in the tlist.
991  *
992  * The CTE_SUBLINK case never occurs in actual SubLink nodes, but it is used
993  * in SubPlans generated for WITH subqueries.
994  */
995 typedef enum SubLinkType
996 {
1004  CTE_SUBLINK, /* for SubPlans only */
1006 
1007 
1008 typedef struct SubLink
1009 {
1011  SubLinkType subLinkType; /* see above */
1012  int subLinkId; /* ID (1..n); 0 if not MULTIEXPR */
1013  Node *testexpr; /* outer-query test for ALL/ANY/ROWCOMPARE */
1014  /* originally specified operator name */
1015  List *operName pg_node_attr(query_jumble_ignore);
1016  /* subselect as Query* or raw parsetree */
1018  ParseLoc location; /* token location, or -1 if unknown */
1020 
1021 /*
1022  * SubPlan - executable expression node for a subplan (sub-SELECT)
1023  *
1024  * The planner replaces SubLink nodes in expression trees with SubPlan
1025  * nodes after it has finished planning the subquery. SubPlan references
1026  * a sub-plantree stored in the subplans list of the toplevel PlannedStmt.
1027  * (We avoid a direct link to make it easier to copy expression trees
1028  * without causing multiple processing of the subplan.)
1029  *
1030  * In an ordinary subplan, testexpr points to an executable expression
1031  * (OpExpr, an AND/OR tree of OpExprs, or RowCompareExpr) for the combining
1032  * operator(s); the left-hand arguments are the original lefthand expressions,
1033  * and the right-hand arguments are PARAM_EXEC Param nodes representing the
1034  * outputs of the sub-select. (NOTE: runtime coercion functions may be
1035  * inserted as well.) This is just the same expression tree as testexpr in
1036  * the original SubLink node, but the PARAM_SUBLINK nodes are replaced by
1037  * suitably numbered PARAM_EXEC nodes.
1038  *
1039  * If the sub-select becomes an initplan rather than a subplan, the executable
1040  * expression is part of the outer plan's expression tree (and the SubPlan
1041  * node itself is not, but rather is found in the outer plan's initPlan
1042  * list). In this case testexpr is NULL to avoid duplication.
1043  *
1044  * The planner also derives lists of the values that need to be passed into
1045  * and out of the subplan. Input values are represented as a list "args" of
1046  * expressions to be evaluated in the outer-query context (currently these
1047  * args are always just Vars, but in principle they could be any expression).
1048  * The values are assigned to the global PARAM_EXEC params indexed by parParam
1049  * (the parParam and args lists must have the same ordering). setParam is a
1050  * list of the PARAM_EXEC params that are computed by the sub-select, if it
1051  * is an initplan or MULTIEXPR plan; they are listed in order by sub-select
1052  * output column position. (parParam and setParam are integer Lists, not
1053  * Bitmapsets, because their ordering is significant.)
1054  *
1055  * Also, the planner computes startup and per-call costs for use of the
1056  * SubPlan. Note that these include the cost of the subquery proper,
1057  * evaluation of the testexpr if any, and any hashtable management overhead.
1058  */
1059 typedef struct SubPlan
1060 {
1061  pg_node_attr(no_query_jumble)
1062 
1063  Expr xpr;
1064  /* Fields copied from original SubLink: */
1065  SubLinkType subLinkType; /* see above */
1066  /* The combining operators, transformed to an executable expression: */
1067  Node *testexpr; /* OpExpr or RowCompareExpr expression tree */
1068  List *paramIds; /* IDs of Params embedded in the above */
1069  /* Identification of the Plan tree to use: */
1070  int plan_id; /* Index (from 1) in PlannedStmt.subplans */
1071  /* Identification of the SubPlan for EXPLAIN and debugging purposes: */
1072  char *plan_name; /* A name assigned during planning */
1073  /* Extra data useful for determining subplan's output type: */
1074  Oid firstColType; /* Type of first column of subplan result */
1075  int32 firstColTypmod; /* Typmod of first column of subplan result */
1076  Oid firstColCollation; /* Collation of first column of subplan
1077  * result */
1078  /* Information about execution strategy: */
1079  bool useHashTable; /* true to store subselect output in a hash
1080  * table (implies we are doing "IN") */
1081  bool unknownEqFalse; /* true if it's okay to return FALSE when the
1082  * spec result is UNKNOWN; this allows much
1083  * simpler handling of null values */
1084  bool parallel_safe; /* is the subplan parallel-safe? */
1085  /* Note: parallel_safe does not consider contents of testexpr or args */
1086  /* Information for passing params into and out of the subselect: */
1087  /* setParam and parParam are lists of integers (param IDs) */
1088  List *setParam; /* initplan and MULTIEXPR subqueries have to
1089  * set these Params for parent plan */
1090  List *parParam; /* indices of input Params from parent plan */
1091  List *args; /* exprs to pass as parParam values */
1092  /* Estimated execution costs: */
1093  Cost startup_cost; /* one-time setup cost */
1094  Cost per_call_cost; /* cost for each subplan evaluation */
1096 
1097 /*
1098  * AlternativeSubPlan - expression node for a choice among SubPlans
1099  *
1100  * This is used only transiently during planning: by the time the plan
1101  * reaches the executor, all AlternativeSubPlan nodes have been removed.
1102  *
1103  * The subplans are given as a List so that the node definition need not
1104  * change if there's ever more than two alternatives. For the moment,
1105  * though, there are always exactly two; and the first one is the fast-start
1106  * plan.
1107  */
1108 typedef struct AlternativeSubPlan
1109 {
1110  pg_node_attr(no_query_jumble)
1111 
1112  Expr xpr;
1113  List *subplans; /* SubPlan(s) with equivalent results */
1115 
1116 /* ----------------
1117  * FieldSelect
1118  *
1119  * FieldSelect represents the operation of extracting one field from a tuple
1120  * value. At runtime, the input expression is expected to yield a rowtype
1121  * Datum. The specified field number is extracted and returned as a Datum.
1122  * ----------------
1123  */
1124 
1125 typedef struct FieldSelect
1126 {
1128  Expr *arg; /* input expression */
1129  AttrNumber fieldnum; /* attribute number of field to extract */
1130  /* type of the field (result type of this node) */
1131  Oid resulttype pg_node_attr(query_jumble_ignore);
1132  /* output typmod (usually -1) */
1133  int32 resulttypmod pg_node_attr(query_jumble_ignore);
1134  /* OID of collation of the field */
1135  Oid resultcollid pg_node_attr(query_jumble_ignore);
1137 
1138 /* ----------------
1139  * FieldStore
1140  *
1141  * FieldStore represents the operation of modifying one field in a tuple
1142  * value, yielding a new tuple value (the input is not touched!). Like
1143  * the assign case of SubscriptingRef, this is used to implement UPDATE of a
1144  * portion of a column.
1145  *
1146  * resulttype is always a named composite type (not a domain). To update
1147  * a composite domain value, apply CoerceToDomain to the FieldStore.
1148  *
1149  * A single FieldStore can actually represent updates of several different
1150  * fields. The parser only generates FieldStores with single-element lists,
1151  * but the planner will collapse multiple updates of the same base column
1152  * into one FieldStore.
1153  * ----------------
1154  */
1155 
1156 typedef struct FieldStore
1157 {
1159  Expr *arg; /* input tuple value */
1160  List *newvals; /* new value(s) for field(s) */
1161  /* integer list of field attnums */
1162  List *fieldnums pg_node_attr(query_jumble_ignore);
1163  /* type of result (same as type of arg) */
1164  Oid resulttype pg_node_attr(query_jumble_ignore);
1165  /* Like RowExpr, we deliberately omit a typmod and collation here */
1167 
1168 /* ----------------
1169  * RelabelType
1170  *
1171  * RelabelType represents a "dummy" type coercion between two binary-
1172  * compatible datatypes, such as reinterpreting the result of an OID
1173  * expression as an int4. It is a no-op at runtime; we only need it
1174  * to provide a place to store the correct type to be attributed to
1175  * the expression result during type resolution. (We can't get away
1176  * with just overwriting the type field of the input expression node,
1177  * so we need a separate node to show the coercion's result type.)
1178  * ----------------
1179  */
1180 
1181 typedef struct RelabelType
1182 {
1184  Expr *arg; /* input expression */
1185  Oid resulttype; /* output type of coercion expression */
1186  /* output typmod (usually -1) */
1187  int32 resulttypmod pg_node_attr(query_jumble_ignore);
1188  /* OID of collation, or InvalidOid if none */
1189  Oid resultcollid pg_node_attr(query_jumble_ignore);
1190  /* how to display this node */
1191  CoercionForm relabelformat pg_node_attr(query_jumble_ignore);
1192  ParseLoc location; /* token location, or -1 if unknown */
1194 
1195 /* ----------------
1196  * CoerceViaIO
1197  *
1198  * CoerceViaIO represents a type coercion between two types whose textual
1199  * representations are compatible, implemented by invoking the source type's
1200  * typoutput function then the destination type's typinput function.
1201  * ----------------
1202  */
1203 
1204 typedef struct CoerceViaIO
1205 {
1207  Expr *arg; /* input expression */
1208  Oid resulttype; /* output type of coercion */
1209  /* output typmod is not stored, but is presumed -1 */
1210  /* OID of collation, or InvalidOid if none */
1211  Oid resultcollid pg_node_attr(query_jumble_ignore);
1212  /* how to display this node */
1213  CoercionForm coerceformat pg_node_attr(query_jumble_ignore);
1214  ParseLoc location; /* token location, or -1 if unknown */
1216 
1217 /* ----------------
1218  * ArrayCoerceExpr
1219  *
1220  * ArrayCoerceExpr represents a type coercion from one array type to another,
1221  * which is implemented by applying the per-element coercion expression
1222  * "elemexpr" to each element of the source array. Within elemexpr, the
1223  * source element is represented by a CaseTestExpr node. Note that even if
1224  * elemexpr is a no-op (that is, just CaseTestExpr + RelabelType), the
1225  * coercion still requires some effort: we have to fix the element type OID
1226  * stored in the array header.
1227  * ----------------
1228  */
1229 
1230 typedef struct ArrayCoerceExpr
1231 {
1233  Expr *arg; /* input expression (yields an array) */
1234  Expr *elemexpr; /* expression representing per-element work */
1235  Oid resulttype; /* output type of coercion (an array type) */
1236  /* output typmod (also element typmod) */
1237  int32 resulttypmod pg_node_attr(query_jumble_ignore);
1238  /* OID of collation, or InvalidOid if none */
1239  Oid resultcollid pg_node_attr(query_jumble_ignore);
1240  /* how to display this node */
1241  CoercionForm coerceformat pg_node_attr(query_jumble_ignore);
1242  ParseLoc location; /* token location, or -1 if unknown */
1244 
1245 /* ----------------
1246  * ConvertRowtypeExpr
1247  *
1248  * ConvertRowtypeExpr represents a type coercion from one composite type
1249  * to another, where the source type is guaranteed to contain all the columns
1250  * needed for the destination type plus possibly others; the columns need not
1251  * be in the same positions, but are matched up by name. This is primarily
1252  * used to convert a whole-row value of an inheritance child table into a
1253  * valid whole-row value of its parent table's rowtype. Both resulttype
1254  * and the exposed type of "arg" must be named composite types (not domains).
1255  * ----------------
1256  */
1257 
1258 typedef struct ConvertRowtypeExpr
1259 {
1261  Expr *arg; /* input expression */
1262  Oid resulttype; /* output type (always a composite type) */
1263  /* Like RowExpr, we deliberately omit a typmod and collation here */
1264  /* how to display this node */
1265  CoercionForm convertformat pg_node_attr(query_jumble_ignore);
1266  ParseLoc location; /* token location, or -1 if unknown */
1268 
1269 /*----------
1270  * CollateExpr - COLLATE
1271  *
1272  * The planner replaces CollateExpr with RelabelType during expression
1273  * preprocessing, so execution never sees a CollateExpr.
1274  *----------
1275  */
1276 typedef struct CollateExpr
1277 {
1279  Expr *arg; /* input expression */
1280  Oid collOid; /* collation's OID */
1281  ParseLoc location; /* token location, or -1 if unknown */
1283 
1284 /*----------
1285  * CaseExpr - a CASE expression
1286  *
1287  * We support two distinct forms of CASE expression:
1288  * CASE WHEN boolexpr THEN expr [ WHEN boolexpr THEN expr ... ]
1289  * CASE testexpr WHEN compexpr THEN expr [ WHEN compexpr THEN expr ... ]
1290  * These are distinguishable by the "arg" field being NULL in the first case
1291  * and the testexpr in the second case.
1292  *
1293  * In the raw grammar output for the second form, the condition expressions
1294  * of the WHEN clauses are just the comparison values. Parse analysis
1295  * converts these to valid boolean expressions of the form
1296  * CaseTestExpr '=' compexpr
1297  * where the CaseTestExpr node is a placeholder that emits the correct
1298  * value at runtime. This structure is used so that the testexpr need be
1299  * evaluated only once. Note that after parse analysis, the condition
1300  * expressions always yield boolean.
1301  *
1302  * Note: we can test whether a CaseExpr has been through parse analysis
1303  * yet by checking whether casetype is InvalidOid or not.
1304  *----------
1305  */
1306 typedef struct CaseExpr
1307 {
1309  /* type of expression result */
1310  Oid casetype pg_node_attr(query_jumble_ignore);
1311  /* OID of collation, or InvalidOid if none */
1312  Oid casecollid pg_node_attr(query_jumble_ignore);
1313  Expr *arg; /* implicit equality comparison argument */
1314  List *args; /* the arguments (list of WHEN clauses) */
1315  Expr *defresult; /* the default result (ELSE clause) */
1316  ParseLoc location; /* token location, or -1 if unknown */
1318 
1319 /*
1320  * CaseWhen - one arm of a CASE expression
1321  */
1322 typedef struct CaseWhen
1323 {
1325  Expr *expr; /* condition expression */
1326  Expr *result; /* substitution result */
1327  ParseLoc location; /* token location, or -1 if unknown */
1329 
1330 /*
1331  * Placeholder node for the test value to be processed by a CASE expression.
1332  * This is effectively like a Param, but can be implemented more simply
1333  * since we need only one replacement value at a time.
1334  *
1335  * We also abuse this node type for some other purposes, including:
1336  * * Placeholder for the current array element value in ArrayCoerceExpr;
1337  * see build_coercion_expression().
1338  * * Nested FieldStore/SubscriptingRef assignment expressions in INSERT/UPDATE;
1339  * see transformAssignmentIndirection().
1340  * * Placeholder for intermediate results in some SQL/JSON expression nodes,
1341  * such as JsonConstructorExpr.
1342  *
1343  * The uses in CaseExpr and ArrayCoerceExpr are safe only to the extent that
1344  * there is not any other CaseExpr or ArrayCoerceExpr between the value source
1345  * node and its child CaseTestExpr(s). This is true in the parse analysis
1346  * output, but the planner's function-inlining logic has to be careful not to
1347  * break it.
1348  *
1349  * The nested-assignment-expression case is safe because the only node types
1350  * that can be above such CaseTestExprs are FieldStore and SubscriptingRef.
1351  */
1352 typedef struct CaseTestExpr
1353 {
1355  Oid typeId; /* type for substituted value */
1356  /* typemod for substituted value */
1357  int32 typeMod pg_node_attr(query_jumble_ignore);
1358  /* collation for the substituted value */
1359  Oid collation pg_node_attr(query_jumble_ignore);
1361 
1362 /*
1363  * ArrayExpr - an ARRAY[] expression
1364  *
1365  * Note: if multidims is false, the constituent expressions all yield the
1366  * scalar type identified by element_typeid. If multidims is true, the
1367  * constituent expressions all yield arrays of element_typeid (ie, the same
1368  * type as array_typeid); at runtime we must check for compatible subscripts.
1369  */
1370 typedef struct ArrayExpr
1371 {
1373  /* type of expression result */
1374  Oid array_typeid pg_node_attr(query_jumble_ignore);
1375  /* OID of collation, or InvalidOid if none */
1376  Oid array_collid pg_node_attr(query_jumble_ignore);
1377  /* common type of array elements */
1378  Oid element_typeid pg_node_attr(query_jumble_ignore);
1379  /* the array elements or sub-arrays */
1381  /* true if elements are sub-arrays */
1382  bool multidims pg_node_attr(query_jumble_ignore);
1383  /* token location, or -1 if unknown */
1386 
1387 /*
1388  * RowExpr - a ROW() expression
1389  *
1390  * Note: the list of fields must have a one-for-one correspondence with
1391  * physical fields of the associated rowtype, although it is okay for it
1392  * to be shorter than the rowtype. That is, the N'th list element must
1393  * match up with the N'th physical field. When the N'th physical field
1394  * is a dropped column (attisdropped) then the N'th list element can just
1395  * be a NULL constant. (This case can only occur for named composite types,
1396  * not RECORD types, since those are built from the RowExpr itself rather
1397  * than vice versa.) It is important not to assume that length(args) is
1398  * the same as the number of columns logically present in the rowtype.
1399  *
1400  * colnames provides field names if the ROW() result is of type RECORD.
1401  * Names *must* be provided if row_typeid is RECORDOID; but if it is a
1402  * named composite type, colnames will be ignored in favor of using the
1403  * type's cataloged field names, so colnames should be NIL. Like the
1404  * args list, colnames is defined to be one-for-one with physical fields
1405  * of the rowtype (although dropped columns shouldn't appear in the
1406  * RECORD case, so this fine point is currently moot).
1407  */
1408 typedef struct RowExpr
1409 {
1411  List *args; /* the fields */
1412 
1413  /* RECORDOID or a composite type's ID */
1414  Oid row_typeid pg_node_attr(query_jumble_ignore);
1415 
1416  /*
1417  * row_typeid cannot be a domain over composite, only plain composite. To
1418  * create a composite domain value, apply CoerceToDomain to the RowExpr.
1419  *
1420  * Note: we deliberately do NOT store a typmod. Although a typmod will be
1421  * associated with specific RECORD types at runtime, it will differ for
1422  * different backends, and so cannot safely be stored in stored
1423  * parsetrees. We must assume typmod -1 for a RowExpr node.
1424  *
1425  * We don't need to store a collation either. The result type is
1426  * necessarily composite, and composite types never have a collation.
1427  */
1428 
1429  /* how to display this node */
1430  CoercionForm row_format pg_node_attr(query_jumble_ignore);
1431 
1432  /* list of String, or NIL */
1433  List *colnames pg_node_attr(query_jumble_ignore);
1434 
1435  ParseLoc location; /* token location, or -1 if unknown */
1437 
1438 /*
1439  * RowCompareExpr - row-wise comparison, such as (a, b) <= (1, 2)
1440  *
1441  * We support row comparison for any operator that can be determined to
1442  * act like =, <>, <, <=, >, or >= (we determine this by looking for the
1443  * operator in btree opfamilies). Note that the same operator name might
1444  * map to a different operator for each pair of row elements, since the
1445  * element datatypes can vary.
1446  *
1447  * A RowCompareExpr node is only generated for the < <= > >= cases;
1448  * the = and <> cases are translated to simple AND or OR combinations
1449  * of the pairwise comparisons. However, we include = and <> in the
1450  * RowCompareType enum for the convenience of parser logic.
1451  */
1452 typedef enum RowCompareType
1453 {
1454  /* Values of this enum are chosen to match btree strategy numbers */
1455  ROWCOMPARE_LT = 1, /* BTLessStrategyNumber */
1456  ROWCOMPARE_LE = 2, /* BTLessEqualStrategyNumber */
1457  ROWCOMPARE_EQ = 3, /* BTEqualStrategyNumber */
1458  ROWCOMPARE_GE = 4, /* BTGreaterEqualStrategyNumber */
1459  ROWCOMPARE_GT = 5, /* BTGreaterStrategyNumber */
1460  ROWCOMPARE_NE = 6, /* no such btree strategy */
1462 
1463 typedef struct RowCompareExpr
1464 {
1466 
1467  /* LT LE GE or GT, never EQ or NE */
1469  /* OID list of pairwise comparison ops */
1470  List *opnos pg_node_attr(query_jumble_ignore);
1471  /* OID list of containing operator families */
1472  List *opfamilies pg_node_attr(query_jumble_ignore);
1473  /* OID list of collations for comparisons */
1474  List *inputcollids pg_node_attr(query_jumble_ignore);
1475  /* the left-hand input arguments */
1477  /* the right-hand input arguments */
1480 
1481 /*
1482  * CoalesceExpr - a COALESCE expression
1483  */
1484 typedef struct CoalesceExpr
1485 {
1487  /* type of expression result */
1488  Oid coalescetype pg_node_attr(query_jumble_ignore);
1489  /* OID of collation, or InvalidOid if none */
1490  Oid coalescecollid pg_node_attr(query_jumble_ignore);
1491  /* the arguments */
1493  /* token location, or -1 if unknown */
1496 
1497 /*
1498  * MinMaxExpr - a GREATEST or LEAST function
1499  */
1500 typedef enum MinMaxOp
1501 {
1503  IS_LEAST
1505 
1506 typedef struct MinMaxExpr
1507 {
1509  /* common type of arguments and result */
1510  Oid minmaxtype pg_node_attr(query_jumble_ignore);
1511  /* OID of collation of result */
1512  Oid minmaxcollid pg_node_attr(query_jumble_ignore);
1513  /* OID of collation that function should use */
1514  Oid inputcollid pg_node_attr(query_jumble_ignore);
1515  /* function to execute */
1517  /* the arguments */
1519  /* token location, or -1 if unknown */
1522 
1523 /*
1524  * SQLValueFunction - parameterless functions with special grammar productions
1525  *
1526  * The SQL standard categorizes some of these as <datetime value function>
1527  * and others as <general value specification>. We call 'em SQLValueFunctions
1528  * for lack of a better term. We store type and typmod of the result so that
1529  * some code doesn't need to know each function individually, and because
1530  * we would need to store typmod anyway for some of the datetime functions.
1531  * Note that currently, all variants return non-collating datatypes, so we do
1532  * not need a collation field; also, all these functions are stable.
1533  */
1535 {
1552 
1553 typedef struct SQLValueFunction
1554 {
1556  SQLValueFunctionOp op; /* which function this is */
1557 
1558  /*
1559  * Result type/typmod. Type is fully determined by "op", so no need to
1560  * include this Oid in the query jumbling.
1561  */
1562  Oid type pg_node_attr(query_jumble_ignore);
1564  ParseLoc location; /* token location, or -1 if unknown */
1566 
1567 /*
1568  * XmlExpr - various SQL/XML functions requiring special grammar productions
1569  *
1570  * 'name' carries the "NAME foo" argument (already XML-escaped).
1571  * 'named_args' and 'arg_names' represent an xml_attribute list.
1572  * 'args' carries all other arguments.
1573  *
1574  * Note: result type/typmod/collation are not stored, but can be deduced
1575  * from the XmlExprOp. The type/typmod fields are just used for display
1576  * purposes, and are NOT necessarily the true result type of the node.
1577  */
1578 typedef enum XmlExprOp
1579 {
1580  IS_XMLCONCAT, /* XMLCONCAT(args) */
1581  IS_XMLELEMENT, /* XMLELEMENT(name, xml_attributes, args) */
1582  IS_XMLFOREST, /* XMLFOREST(xml_attributes) */
1583  IS_XMLPARSE, /* XMLPARSE(text, is_doc, preserve_ws) */
1584  IS_XMLPI, /* XMLPI(name [, args]) */
1585  IS_XMLROOT, /* XMLROOT(xml, version, standalone) */
1586  IS_XMLSERIALIZE, /* XMLSERIALIZE(is_document, xmlval, indent) */
1587  IS_DOCUMENT, /* xmlval IS DOCUMENT */
1589 
1590 typedef enum XmlOptionType
1591 {
1595 
1596 typedef struct XmlExpr
1597 {
1599  /* xml function ID */
1601  /* name in xml(NAME foo ...) syntaxes */
1602  char *name pg_node_attr(query_jumble_ignore);
1603  /* non-XML expressions for xml_attributes */
1605  /* parallel list of String values */
1606  List *arg_names pg_node_attr(query_jumble_ignore);
1607  /* list of expressions */
1609  /* DOCUMENT or CONTENT */
1610  XmlOptionType xmloption pg_node_attr(query_jumble_ignore);
1611  /* INDENT option for XMLSERIALIZE */
1612  bool indent;
1613  /* target type/typmod for XMLSERIALIZE */
1614  Oid type pg_node_attr(query_jumble_ignore);
1615  int32 typmod pg_node_attr(query_jumble_ignore);
1616  /* token location, or -1 if unknown */
1619 
1620 /*
1621  * JsonEncoding -
1622  * representation of JSON ENCODING clause
1623  */
1624 typedef enum JsonEncoding
1625 {
1626  JS_ENC_DEFAULT, /* unspecified */
1631 
1632 /*
1633  * JsonFormatType -
1634  * enumeration of JSON formats used in JSON FORMAT clause
1635  */
1636 typedef enum JsonFormatType
1637 {
1638  JS_FORMAT_DEFAULT, /* unspecified */
1639  JS_FORMAT_JSON, /* FORMAT JSON [ENCODING ...] */
1640  JS_FORMAT_JSONB, /* implicit internal format for RETURNING
1641  * jsonb */
1643 
1644 /*
1645  * JsonFormat -
1646  * representation of JSON FORMAT clause
1647  */
1648 typedef struct JsonFormat
1649 {
1651  JsonFormatType format_type; /* format type */
1652  JsonEncoding encoding; /* JSON encoding */
1653  ParseLoc location; /* token location, or -1 if unknown */
1655 
1656 /*
1657  * JsonReturning -
1658  * transformed representation of JSON RETURNING clause
1659  */
1660 typedef struct JsonReturning
1661 {
1663  JsonFormat *format; /* output JSON format */
1664  Oid typid; /* target type Oid */
1665  int32 typmod; /* target type modifier */
1667 
1668 /*
1669  * JsonValueExpr -
1670  * representation of JSON value expression (expr [FORMAT JsonFormat])
1671  *
1672  * The actual value is obtained by evaluating formatted_expr. raw_expr is
1673  * only there for displaying the original user-written expression and is not
1674  * evaluated by ExecInterpExpr() and eval_const_expressions_mutator().
1675  */
1676 typedef struct JsonValueExpr
1677 {
1679  Expr *raw_expr; /* raw expression */
1680  Expr *formatted_expr; /* formatted expression */
1681  JsonFormat *format; /* FORMAT clause, if specified */
1683 
1685 {
1694 
1695 /*
1696  * JsonConstructorExpr -
1697  * wrapper over FuncExpr/Aggref/WindowFunc for SQL/JSON constructors
1698  */
1699 typedef struct JsonConstructorExpr
1700 {
1702  JsonConstructorType type; /* constructor type */
1704  Expr *func; /* underlying json[b]_xxx() function call */
1705  Expr *coercion; /* coercion to RETURNING type */
1706  JsonReturning *returning; /* RETURNING clause */
1707  bool absent_on_null; /* ABSENT ON NULL? */
1708  bool unique; /* WITH UNIQUE KEYS? (JSON_OBJECT[AGG] only) */
1711 
1712 /*
1713  * JsonValueType -
1714  * representation of JSON item type in IS JSON predicate
1715  */
1716 typedef enum JsonValueType
1717 {
1718  JS_TYPE_ANY, /* IS JSON [VALUE] */
1719  JS_TYPE_OBJECT, /* IS JSON OBJECT */
1720  JS_TYPE_ARRAY, /* IS JSON ARRAY */
1721  JS_TYPE_SCALAR, /* IS JSON SCALAR */
1723 
1724 /*
1725  * JsonIsPredicate -
1726  * representation of IS JSON predicate
1727  */
1728 typedef struct JsonIsPredicate
1729 {
1731  Node *expr; /* subject expression */
1732  JsonFormat *format; /* FORMAT clause, if specified */
1733  JsonValueType item_type; /* JSON item type */
1734  bool unique_keys; /* check key uniqueness? */
1735  ParseLoc location; /* token location, or -1 if unknown */
1737 
1738 /* Nodes used in SQL/JSON query functions */
1739 
1740 /*
1741  * JsonWrapper -
1742  * representation of WRAPPER clause for JSON_QUERY()
1743  */
1744 typedef enum JsonWrapper
1745 {
1751 
1752 /*
1753  * JsonBehaviorType -
1754  * enumeration of behavior types used in SQL/JSON ON ERROR/EMPTY clauses
1755  *
1756  * If enum members are reordered, get_json_behavior() from ruleutils.c
1757  * must be updated accordingly.
1758  */
1759 typedef enum JsonBehaviorType
1760 {
1771 
1772 /*
1773  * JsonBehavior
1774  * Specifications for ON ERROR / ON EMPTY behaviors of SQL/JSON
1775  * query functions specified by a JsonExpr
1776  *
1777  * 'expr' is the expression to emit when a given behavior (EMPTY or ERROR)
1778  * occurs on evaluating the SQL/JSON query function. 'coerce' is set to true
1779  * if 'expr' isn't already of the expected target type given by
1780  * JsonExpr.returning.
1781  */
1782 typedef struct JsonBehavior
1783 {
1785 
1788  bool coerce;
1789  ParseLoc location; /* token location, or -1 if unknown */
1791 
1792 /*
1793  * JsonExprOp -
1794  * enumeration of SQL/JSON query function types
1795  */
1796 typedef enum JsonExprOp
1797 {
1798  JSON_EXISTS_OP, /* JSON_EXISTS() */
1799  JSON_QUERY_OP, /* JSON_QUERY() */
1800  JSON_VALUE_OP, /* JSON_VALUE() */
1801  JSON_TABLE_OP, /* JSON_TABLE() */
1803 
1804 /*
1805  * JsonExpr -
1806  * Transformed representation of JSON_VALUE(), JSON_QUERY(), and
1807  * JSON_EXISTS()
1808  */
1809 typedef struct JsonExpr
1810 {
1812 
1814 
1815  char *column_name; /* JSON_TABLE() column name or NULL if this is
1816  * not for a JSON_TABLE() */
1817 
1818  /* jsonb-valued expression to query */
1820 
1821  /* Format of the above expression needed by ruleutils.c */
1823 
1824  /* jsonpath-valued expression containing the query pattern */
1826 
1827  /* Expected type/format of the output. */
1829 
1830  /* Information about the PASSING argument expressions */
1833 
1834  /* User-specified or default ON EMPTY and ON ERROR behaviors */
1837 
1838  /*
1839  * Information about converting the result of jsonpath functions
1840  * JsonPathQuery() and JsonPathValue() to the RETURNING type.
1841  *
1842  * coercion_expr is a cast expression if the parser can find it for the
1843  * source and the target type. If not, either use_io_coercion or
1844  * use_json_coercion is set to determine the coercion method to use at
1845  * runtime; see coerceJsonExprOutput() and ExecInitJsonExpr().
1846  */
1850 
1851  /* WRAPPER specification for JSON_QUERY */
1853 
1854  /* KEEP or OMIT QUOTES for singleton scalars returned by JSON_QUERY() */
1856 
1857  /* JsonExpr's collation, if coercion_expr is NULL. */
1859 
1860  /* Original JsonFuncExpr's location */
1863 
1864 /*
1865  * JsonTablePath
1866  * A JSON path expression to be computed as part of evaluating
1867  * a JSON_TABLE plan node
1868  */
1869 typedef struct JsonTablePath
1870 {
1872 
1874  char *name;
1876 
1877 /*
1878  * JsonTablePlan -
1879  * Abstract class to represent different types of JSON_TABLE "plans".
1880  * A plan is used to generate a "row pattern" value by evaluating a JSON
1881  * path expression against an input JSON document, which is then used for
1882  * populating JSON_TABLE() columns
1883  */
1884 typedef struct JsonTablePlan
1885 {
1886  pg_node_attr(abstract)
1887 
1888  NodeTag type;
1890 
1891 /*
1892  * JSON_TABLE plan to evaluate a JSON path expression and NESTED paths, if
1893  * any.
1894  */
1895 typedef struct JsonTablePathScan
1896 {
1898 
1899  /* JSON path to evaluate */
1901 
1902  /*
1903  * ERROR/EMPTY ON ERROR behavior; only significant in the plan for the
1904  * top-level path.
1905  */
1907 
1908  /* Plan(s) for nested columns, if any. */
1910 
1911  /*
1912  * 0-based index in TableFunc.colvalexprs of the 1st and the last column
1913  * covered by this plan. Both are -1 if all columns are nested and thus
1914  * computed by the child plan(s).
1915  */
1916  int colMin;
1917  int colMax;
1919 
1920 /*
1921  * JsonTableSiblingJoin -
1922  * Plan to join rows of sibling NESTED COLUMNS clauses in the same parent
1923  * COLUMNS clause
1924  */
1925 typedef struct JsonTableSiblingJoin
1926 {
1928 
1932 
1933 /* ----------------
1934  * NullTest
1935  *
1936  * NullTest represents the operation of testing a value for NULLness.
1937  * The appropriate test is performed and returned as a boolean Datum.
1938  *
1939  * When argisrow is false, this simply represents a test for the null value.
1940  *
1941  * When argisrow is true, the input expression must yield a rowtype, and
1942  * the node implements "row IS [NOT] NULL" per the SQL standard. This
1943  * includes checking individual fields for NULLness when the row datum
1944  * itself isn't NULL.
1945  *
1946  * NOTE: the combination of a rowtype input and argisrow==false does NOT
1947  * correspond to the SQL notation "row IS [NOT] NULL"; instead, this case
1948  * represents the SQL notation "row IS [NOT] DISTINCT FROM NULL".
1949  * ----------------
1950  */
1951 
1952 typedef enum NullTestType
1953 {
1956 
1957 typedef struct NullTest
1958 {
1960  Expr *arg; /* input expression */
1961  NullTestType nulltesttype; /* IS NULL, IS NOT NULL */
1962  /* T to perform field-by-field null checks */
1963  bool argisrow pg_node_attr(query_jumble_ignore);
1964  ParseLoc location; /* token location, or -1 if unknown */
1966 
1967 /*
1968  * BooleanTest
1969  *
1970  * BooleanTest represents the operation of determining whether a boolean
1971  * is TRUE, FALSE, or UNKNOWN (ie, NULL). All six meaningful combinations
1972  * are supported. Note that a NULL input does *not* cause a NULL result.
1973  * The appropriate test is performed and returned as a boolean Datum.
1974  */
1975 
1976 typedef enum BoolTestType
1977 {
1980 
1981 typedef struct BooleanTest
1982 {
1984  Expr *arg; /* input expression */
1985  BoolTestType booltesttype; /* test type */
1986  ParseLoc location; /* token location, or -1 if unknown */
1988 
1989 
1990 /*
1991  * MergeAction
1992  *
1993  * Transformed representation of a WHEN clause in a MERGE statement
1994  */
1995 
1996 typedef enum MergeMatchKind
1997 {
2002 
2003 #define NUM_MERGE_MATCH_KINDS (MERGE_WHEN_NOT_MATCHED_BY_TARGET + 1)
2004 
2005 typedef struct MergeAction
2006 {
2008  MergeMatchKind matchKind; /* MATCHED/NOT MATCHED BY SOURCE/TARGET */
2009  CmdType commandType; /* INSERT/UPDATE/DELETE/DO NOTHING */
2010  /* OVERRIDING clause */
2011  OverridingKind override pg_node_attr(query_jumble_ignore);
2012  Node *qual; /* transformed WHEN conditions */
2013  List *targetList; /* the target list (of TargetEntry) */
2014  /* target attribute numbers of an UPDATE */
2015  List *updateColnos pg_node_attr(query_jumble_ignore);
2017 
2018 /*
2019  * CoerceToDomain
2020  *
2021  * CoerceToDomain represents the operation of coercing a value to a domain
2022  * type. At runtime (and not before) the precise set of constraints to be
2023  * checked will be determined. If the value passes, it is returned as the
2024  * result; if not, an error is raised. Note that this is equivalent to
2025  * RelabelType in the scenario where no constraints are applied.
2026  */
2027 typedef struct CoerceToDomain
2028 {
2030  Expr *arg; /* input expression */
2031  Oid resulttype; /* domain type ID (result type) */
2032  /* output typmod (currently always -1) */
2033  int32 resulttypmod pg_node_attr(query_jumble_ignore);
2034  /* OID of collation, or InvalidOid if none */
2035  Oid resultcollid pg_node_attr(query_jumble_ignore);
2036  /* how to display this node */
2037  CoercionForm coercionformat pg_node_attr(query_jumble_ignore);
2038  ParseLoc location; /* token location, or -1 if unknown */
2040 
2041 /*
2042  * Placeholder node for the value to be processed by a domain's check
2043  * constraint. This is effectively like a Param, but can be implemented more
2044  * simply since we need only one replacement value at a time.
2045  *
2046  * Note: the typeId/typeMod/collation will be set from the domain's base type,
2047  * not the domain itself. This is because we shouldn't consider the value
2048  * to be a member of the domain if we haven't yet checked its constraints.
2049  */
2050 typedef struct CoerceToDomainValue
2051 {
2053  /* type for substituted value */
2055  /* typemod for substituted value */
2056  int32 typeMod pg_node_attr(query_jumble_ignore);
2057  /* collation for the substituted value */
2058  Oid collation pg_node_attr(query_jumble_ignore);
2059  /* token location, or -1 if unknown */
2062 
2063 /*
2064  * Placeholder node for a DEFAULT marker in an INSERT or UPDATE command.
2065  *
2066  * This is not an executable expression: it must be replaced by the actual
2067  * column default expression during rewriting. But it is convenient to
2068  * treat it as an expression node during parsing and rewriting.
2069  */
2070 typedef struct SetToDefault
2071 {
2073  /* type for substituted value */
2075  /* typemod for substituted value */
2076  int32 typeMod pg_node_attr(query_jumble_ignore);
2077  /* collation for the substituted value */
2078  Oid collation pg_node_attr(query_jumble_ignore);
2079  /* token location, or -1 if unknown */
2082 
2083 /*
2084  * Node representing [WHERE] CURRENT OF cursor_name
2085  *
2086  * CURRENT OF is a bit like a Var, in that it carries the rangetable index
2087  * of the target relation being constrained; this aids placing the expression
2088  * correctly during planning. We can assume however that its "levelsup" is
2089  * always zero, due to the syntactic constraints on where it can appear.
2090  * Also, cvarno will always be a true RT index, never INNER_VAR etc.
2091  *
2092  * The referenced cursor can be represented either as a hardwired string
2093  * or as a reference to a run-time parameter of type REFCURSOR. The latter
2094  * case is for the convenience of plpgsql.
2095  */
2096 typedef struct CurrentOfExpr
2097 {
2099  Index cvarno; /* RT index of target relation */
2100  char *cursor_name; /* name of referenced cursor, or NULL */
2101  int cursor_param; /* refcursor parameter number, or 0 */
2103 
2104 /*
2105  * NextValueExpr - get next value from sequence
2106  *
2107  * This has the same effect as calling the nextval() function, but it does not
2108  * check permissions on the sequence. This is used for identity columns,
2109  * where the sequence is an implicit dependency without its own permissions.
2110  */
2111 typedef struct NextValueExpr
2112 {
2117 
2118 /*
2119  * InferenceElem - an element of a unique index inference specification
2120  *
2121  * This mostly matches the structure of IndexElems, but having a dedicated
2122  * primnode allows for a clean separation between the use of index parameters
2123  * by utility commands, and this node.
2124  */
2125 typedef struct InferenceElem
2126 {
2128  Node *expr; /* expression to infer from, or NULL */
2129  Oid infercollid; /* OID of collation, or InvalidOid */
2130  Oid inferopclass; /* OID of att opclass, or InvalidOid */
2132 
2133 /*--------------------
2134  * TargetEntry -
2135  * a target entry (used in query target lists)
2136  *
2137  * Strictly speaking, a TargetEntry isn't an expression node (since it can't
2138  * be evaluated by ExecEvalExpr). But we treat it as one anyway, since in
2139  * very many places it's convenient to process a whole query targetlist as a
2140  * single expression tree.
2141  *
2142  * In a SELECT's targetlist, resno should always be equal to the item's
2143  * ordinal position (counting from 1). However, in an INSERT or UPDATE
2144  * targetlist, resno represents the attribute number of the destination
2145  * column for the item; so there may be missing or out-of-order resnos.
2146  * It is even legal to have duplicated resnos; consider
2147  * UPDATE table SET arraycol[1] = ..., arraycol[2] = ..., ...
2148  * In an INSERT, the rewriter and planner will normalize the tlist by
2149  * reordering it into physical column order and filling in default values
2150  * for any columns not assigned values by the original query. In an UPDATE,
2151  * after the rewriter merges multiple assignments for the same column, the
2152  * planner extracts the target-column numbers into a separate "update_colnos"
2153  * list, and then renumbers the tlist elements serially. Thus, tlist resnos
2154  * match ordinal position in all tlists seen by the executor; but it is wrong
2155  * to assume that before planning has happened.
2156  *
2157  * resname is required to represent the correct column name in non-resjunk
2158  * entries of top-level SELECT targetlists, since it will be used as the
2159  * column title sent to the frontend. In most other contexts it is only
2160  * a debugging aid, and may be wrong or even NULL. (In particular, it may
2161  * be wrong in a tlist from a stored rule, if the referenced column has been
2162  * renamed by ALTER TABLE since the rule was made. Also, the planner tends
2163  * to store NULL rather than look up a valid name for tlist entries in
2164  * non-toplevel plan nodes.) In resjunk entries, resname should be either
2165  * a specific system-generated name (such as "ctid") or NULL; anything else
2166  * risks confusing ExecGetJunkAttribute!
2167  *
2168  * ressortgroupref is used in the representation of ORDER BY, GROUP BY, and
2169  * DISTINCT items. Targetlist entries with ressortgroupref=0 are not
2170  * sort/group items. If ressortgroupref>0, then this item is an ORDER BY,
2171  * GROUP BY, and/or DISTINCT target value. No two entries in a targetlist
2172  * may have the same nonzero ressortgroupref --- but there is no particular
2173  * meaning to the nonzero values, except as tags. (For example, one must
2174  * not assume that lower ressortgroupref means a more significant sort key.)
2175  * The order of the associated SortGroupClause lists determine the semantics.
2176  *
2177  * resorigtbl/resorigcol identify the source of the column, if it is a
2178  * simple reference to a column of a base table (or view). If it is not
2179  * a simple reference, these fields are zeroes.
2180  *
2181  * If resjunk is true then the column is a working column (such as a sort key)
2182  * that should be removed from the final output of the query. Resjunk columns
2183  * must have resnos that cannot duplicate any regular column's resno. Also
2184  * note that there are places that assume resjunk columns come after non-junk
2185  * columns.
2186  *--------------------
2187  */
2188 typedef struct TargetEntry
2189 {
2191  /* expression to evaluate */
2193  /* attribute number (see notes above) */
2195  /* name of the column (could be NULL) */
2196  char *resname pg_node_attr(query_jumble_ignore);
2197  /* nonzero if referenced by a sort/group clause */
2199  /* OID of column's source table */
2200  Oid resorigtbl pg_node_attr(query_jumble_ignore);
2201  /* column's number in source table */
2202  AttrNumber resorigcol pg_node_attr(query_jumble_ignore);
2203  /* set to true to eliminate the attribute from final target list */
2204  bool resjunk pg_node_attr(query_jumble_ignore);
2206 
2207 
2208 /* ----------------------------------------------------------------
2209  * node types for join trees
2210  *
2211  * The leaves of a join tree structure are RangeTblRef nodes. Above
2212  * these, JoinExpr nodes can appear to denote a specific kind of join
2213  * or qualified join. Also, FromExpr nodes can appear to denote an
2214  * ordinary cross-product join ("FROM foo, bar, baz WHERE ...").
2215  * FromExpr is like a JoinExpr of jointype JOIN_INNER, except that it
2216  * may have any number of child nodes, not just two.
2217  *
2218  * NOTE: the top level of a Query's jointree is always a FromExpr.
2219  * Even if the jointree contains no rels, there will be a FromExpr.
2220  *
2221  * NOTE: the qualification expressions present in JoinExpr nodes are
2222  * *in addition to* the query's main WHERE clause, which appears as the
2223  * qual of the top-level FromExpr. The reason for associating quals with
2224  * specific nodes in the jointree is that the position of a qual is critical
2225  * when outer joins are present. (If we enforce a qual too soon or too late,
2226  * that may cause the outer join to produce the wrong set of NULL-extended
2227  * rows.) If all joins are inner joins then all the qual positions are
2228  * semantically interchangeable.
2229  *
2230  * NOTE: in the raw output of gram.y, a join tree contains RangeVar,
2231  * RangeSubselect, and RangeFunction nodes, which are all replaced by
2232  * RangeTblRef nodes during the parse analysis phase. Also, the top-level
2233  * FromExpr is added during parse analysis; the grammar regards FROM and
2234  * WHERE as separate.
2235  * ----------------------------------------------------------------
2236  */
2237 
2238 /*
2239  * RangeTblRef - reference to an entry in the query's rangetable
2240  *
2241  * We could use direct pointers to the RT entries and skip having these
2242  * nodes, but multiple pointers to the same node in a querytree cause
2243  * lots of headaches, so it seems better to store an index into the RT.
2244  */
2245 typedef struct RangeTblRef
2246 {
2248  int rtindex;
2250 
2251 /*----------
2252  * JoinExpr - for SQL JOIN expressions
2253  *
2254  * isNatural, usingClause, and quals are interdependent. The user can write
2255  * only one of NATURAL, USING(), or ON() (this is enforced by the grammar).
2256  * If he writes NATURAL then parse analysis generates the equivalent USING()
2257  * list, and from that fills in "quals" with the right equality comparisons.
2258  * If he writes USING() then "quals" is filled with equality comparisons.
2259  * If he writes ON() then only "quals" is set. Note that NATURAL/USING
2260  * are not equivalent to ON() since they also affect the output column list.
2261  *
2262  * alias is an Alias node representing the AS alias-clause attached to the
2263  * join expression, or NULL if no clause. NB: presence or absence of the
2264  * alias has a critical impact on semantics, because a join with an alias
2265  * restricts visibility of the tables/columns inside it.
2266  *
2267  * join_using_alias is an Alias node representing the join correlation
2268  * name that SQL:2016 and later allow to be attached to JOIN/USING.
2269  * Its column alias list includes only the common column names from USING,
2270  * and it does not restrict visibility of the join's input tables.
2271  *
2272  * During parse analysis, an RTE is created for the Join, and its index
2273  * is filled into rtindex. This RTE is present mainly so that Vars can
2274  * be created that refer to the outputs of the join. The planner sometimes
2275  * generates JoinExprs internally; these can have rtindex = 0 if there are
2276  * no join alias variables referencing such joins.
2277  *----------
2278  */
2279 typedef struct JoinExpr
2280 {
2282  JoinType jointype; /* type of join */
2283  bool isNatural; /* Natural join? Will need to shape table */
2284  Node *larg; /* left subtree */
2285  Node *rarg; /* right subtree */
2286  /* USING clause, if any (list of String) */
2287  List *usingClause pg_node_attr(query_jumble_ignore);
2288  /* alias attached to USING clause, if any */
2289  Alias *join_using_alias pg_node_attr(query_jumble_ignore);
2290  /* qualifiers on join, if any */
2292  /* user-written alias clause, if any */
2293  Alias *alias pg_node_attr(query_jumble_ignore);
2294  /* RT index assigned for join, or 0 */
2295  int rtindex;
2297 
2298 /*----------
2299  * FromExpr - represents a FROM ... WHERE ... construct
2300  *
2301  * This is both more flexible than a JoinExpr (it can have any number of
2302  * children, including zero) and less so --- we don't need to deal with
2303  * aliases and so on. The output column set is implicitly just the union
2304  * of the outputs of the children.
2305  *----------
2306  */
2307 typedef struct FromExpr
2308 {
2310  List *fromlist; /* List of join subtrees */
2311  Node *quals; /* qualifiers on join, if any */
2313 
2314 /*----------
2315  * OnConflictExpr - represents an ON CONFLICT DO ... expression
2316  *
2317  * The optimizer requires a list of inference elements, and optionally a WHERE
2318  * clause to infer a unique index. The unique index (or, occasionally,
2319  * indexes) inferred are used to arbitrate whether or not the alternative ON
2320  * CONFLICT path is taken.
2321  *----------
2322  */
2323 typedef struct OnConflictExpr
2324 {
2326  OnConflictAction action; /* DO NOTHING or UPDATE? */
2327 
2328  /* Arbiter */
2329  List *arbiterElems; /* unique index arbiter list (of
2330  * InferenceElem's) */
2331  Node *arbiterWhere; /* unique index arbiter WHERE clause */
2332  Oid constraint; /* pg_constraint OID for arbiter */
2333 
2334  /* ON CONFLICT UPDATE */
2335  List *onConflictSet; /* List of ON CONFLICT SET TargetEntrys */
2336  Node *onConflictWhere; /* qualifiers to restrict UPDATE to */
2337  int exclRelIndex; /* RT index of 'excluded' relation */
2338  List *exclRelTlist; /* tlist of the EXCLUDED pseudo relation */
2340 
2341 #endif /* PRIMNODES_H */
int16 AttrNumber
Definition: attnum.h:21
signed int int32
Definition: c.h:494
unsigned int Index
Definition: c.h:614
double Cost
Definition: nodes.h:251
OnConflictAction
Definition: nodes.h:416
CmdType
Definition: nodes.h:263
NodeTag
Definition: nodes.h:27
AggSplit
Definition: nodes.h:374
int ParseLoc
Definition: nodes.h:240
JoinType
Definition: nodes.h:288
#define plan(x)
Definition: pg_regress.c:162
uintptr_t Datum
Definition: postgres.h:64
unsigned int Oid
Definition: postgres_ext.h:31
BoolTestType
Definition: primnodes.h:1977
@ IS_NOT_TRUE
Definition: primnodes.h:1978
@ IS_NOT_FALSE
Definition: primnodes.h:1978
@ IS_NOT_UNKNOWN
Definition: primnodes.h:1978
@ IS_TRUE
Definition: primnodes.h:1978
@ IS_UNKNOWN
Definition: primnodes.h:1978
@ IS_FALSE
Definition: primnodes.h:1978
struct ArrayExpr ArrayExpr
struct FieldSelect FieldSelect
struct CoalesceExpr CoalesceExpr
struct Aggref Aggref
SubLinkType
Definition: primnodes.h:996
@ ARRAY_SUBLINK
Definition: primnodes.h:1003
@ ANY_SUBLINK
Definition: primnodes.h:999
@ MULTIEXPR_SUBLINK
Definition: primnodes.h:1002
@ CTE_SUBLINK
Definition: primnodes.h:1004
@ EXPR_SUBLINK
Definition: primnodes.h:1001
@ ROWCOMPARE_SUBLINK
Definition: primnodes.h:1000
@ ALL_SUBLINK
Definition: primnodes.h:998
@ EXISTS_SUBLINK
Definition: primnodes.h:997
struct AlternativeSubPlan AlternativeSubPlan
JsonFormatType
Definition: primnodes.h:1637
@ JS_FORMAT_JSONB
Definition: primnodes.h:1640
@ JS_FORMAT_DEFAULT
Definition: primnodes.h:1638
@ JS_FORMAT_JSON
Definition: primnodes.h:1639
struct WindowFuncRunCondition WindowFuncRunCondition
struct InferenceElem InferenceElem
struct ArrayCoerceExpr ArrayCoerceExpr
struct TargetEntry TargetEntry
MinMaxOp
Definition: primnodes.h:1501
@ IS_LEAST
Definition: primnodes.h:1503
@ IS_GREATEST
Definition: primnodes.h:1502
TableFuncType
Definition: primnodes.h:98
@ TFT_XMLTABLE
Definition: primnodes.h:99
@ TFT_JSON_TABLE
Definition: primnodes.h:100
struct CaseWhen CaseWhen
BoolExprType
Definition: primnodes.h:930
@ AND_EXPR
Definition: primnodes.h:931
@ OR_EXPR
Definition: primnodes.h:931
@ NOT_EXPR
Definition: primnodes.h:931
struct SetToDefault SetToDefault
JsonEncoding
Definition: primnodes.h:1625
@ JS_ENC_DEFAULT
Definition: primnodes.h:1626
@ JS_ENC_UTF32
Definition: primnodes.h:1629
@ JS_ENC_UTF8
Definition: primnodes.h:1627
@ JS_ENC_UTF16
Definition: primnodes.h:1628
struct JsonReturning JsonReturning
struct CaseExpr CaseExpr
struct JsonBehavior JsonBehavior
struct WindowFunc WindowFunc
XmlOptionType
Definition: primnodes.h:1591
@ XMLOPTION_CONTENT
Definition: primnodes.h:1593
@ XMLOPTION_DOCUMENT
Definition: primnodes.h:1592
SQLValueFunctionOp
Definition: primnodes.h:1535
@ SVFOP_CURRENT_CATALOG
Definition: primnodes.h:1549
@ SVFOP_LOCALTIME_N
Definition: primnodes.h:1542
@ SVFOP_CURRENT_TIMESTAMP
Definition: primnodes.h:1539
@ SVFOP_LOCALTIME
Definition: primnodes.h:1541
@ SVFOP_CURRENT_TIMESTAMP_N
Definition: primnodes.h:1540
@ SVFOP_CURRENT_ROLE
Definition: primnodes.h:1545
@ SVFOP_USER
Definition: primnodes.h:1547
@ SVFOP_CURRENT_SCHEMA
Definition: primnodes.h:1550
@ SVFOP_LOCALTIMESTAMP_N
Definition: primnodes.h:1544
@ SVFOP_CURRENT_DATE
Definition: primnodes.h:1536
@ SVFOP_CURRENT_TIME_N
Definition: primnodes.h:1538
@ SVFOP_CURRENT_TIME
Definition: primnodes.h:1537
@ SVFOP_LOCALTIMESTAMP
Definition: primnodes.h:1543
@ SVFOP_CURRENT_USER
Definition: primnodes.h:1546
@ SVFOP_SESSION_USER
Definition: primnodes.h:1548
ParamKind
Definition: primnodes.h:366
@ PARAM_MULTIEXPR
Definition: primnodes.h:370
@ PARAM_EXTERN
Definition: primnodes.h:367
@ PARAM_SUBLINK
Definition: primnodes.h:369
@ PARAM_EXEC
Definition: primnodes.h:368
struct CoerceToDomainValue CoerceToDomainValue
struct Var Var
JsonWrapper
Definition: primnodes.h:1745
@ JSW_UNCONDITIONAL
Definition: primnodes.h:1749
@ JSW_CONDITIONAL
Definition: primnodes.h:1748
@ JSW_UNSPEC
Definition: primnodes.h:1746
@ JSW_NONE
Definition: primnodes.h:1747
struct IntoClause IntoClause
struct MinMaxExpr MinMaxExpr
OpExpr DistinctExpr
Definition: primnodes.h:852
struct NamedArgExpr NamedArgExpr
XmlExprOp
Definition: primnodes.h:1579
@ IS_DOCUMENT
Definition: primnodes.h:1587
@ IS_XMLFOREST
Definition: primnodes.h:1582
@ IS_XMLCONCAT
Definition: primnodes.h:1580
@ IS_XMLPI
Definition: primnodes.h:1584
@ IS_XMLPARSE
Definition: primnodes.h:1583
@ IS_XMLSERIALIZE
Definition: primnodes.h:1586
@ IS_XMLROOT
Definition: primnodes.h:1585
@ IS_XMLELEMENT
Definition: primnodes.h:1581
struct JsonIsPredicate JsonIsPredicate
struct JoinExpr JoinExpr
struct CoerceToDomain CoerceToDomain
struct SubLink SubLink
struct NextValueExpr NextValueExpr
struct JsonExpr JsonExpr
struct BoolExpr BoolExpr
struct OpExpr OpExpr
RowCompareType
Definition: primnodes.h:1453
@ ROWCOMPARE_GT
Definition: primnodes.h:1459
@ ROWCOMPARE_LT
Definition: primnodes.h:1455
@ ROWCOMPARE_NE
Definition: primnodes.h:1460
@ ROWCOMPARE_LE
Definition: primnodes.h:1456
@ ROWCOMPARE_EQ
Definition: primnodes.h:1457
@ ROWCOMPARE_GE
Definition: primnodes.h:1458
JsonBehaviorType
Definition: primnodes.h:1760
@ JSON_BEHAVIOR_ERROR
Definition: primnodes.h:1762
@ JSON_BEHAVIOR_TRUE
Definition: primnodes.h:1764
@ JSON_BEHAVIOR_DEFAULT
Definition: primnodes.h:1769
@ JSON_BEHAVIOR_EMPTY
Definition: primnodes.h:1763
@ JSON_BEHAVIOR_FALSE
Definition: primnodes.h:1765
@ JSON_BEHAVIOR_NULL
Definition: primnodes.h:1761
@ JSON_BEHAVIOR_EMPTY_OBJECT
Definition: primnodes.h:1768
@ JSON_BEHAVIOR_UNKNOWN
Definition: primnodes.h:1766
@ JSON_BEHAVIOR_EMPTY_ARRAY
Definition: primnodes.h:1767
struct OnConflictExpr OnConflictExpr
struct FuncExpr FuncExpr
OnCommitAction
Definition: primnodes.h:56
@ ONCOMMIT_DELETE_ROWS
Definition: primnodes.h:59
@ ONCOMMIT_NOOP
Definition: primnodes.h:57
@ ONCOMMIT_PRESERVE_ROWS
Definition: primnodes.h:58
@ ONCOMMIT_DROP
Definition: primnodes.h:60
struct GroupingFunc GroupingFunc
struct XmlExpr XmlExpr
struct SubPlan SubPlan
struct CollateExpr CollateExpr
struct ConvertRowtypeExpr ConvertRowtypeExpr
struct MergeAction MergeAction
struct RowExpr RowExpr
struct RangeTblRef RangeTblRef
JsonExprOp
Definition: primnodes.h:1797
@ JSON_QUERY_OP
Definition: primnodes.h:1799
@ JSON_TABLE_OP
Definition: primnodes.h:1801
@ JSON_EXISTS_OP
Definition: primnodes.h:1798
@ JSON_VALUE_OP
Definition: primnodes.h:1800
struct BooleanTest BooleanTest
CoercionForm
Definition: primnodes.h:733
@ COERCE_SQL_SYNTAX
Definition: primnodes.h:737
@ COERCE_IMPLICIT_CAST
Definition: primnodes.h:736
@ COERCE_EXPLICIT_CAST
Definition: primnodes.h:735
@ COERCE_EXPLICIT_CALL
Definition: primnodes.h:734
struct CaseTestExpr CaseTestExpr
OverridingKind
Definition: primnodes.h:26
@ OVERRIDING_NOT_SET
Definition: primnodes.h:27
@ OVERRIDING_SYSTEM_VALUE
Definition: primnodes.h:29
@ OVERRIDING_USER_VALUE
Definition: primnodes.h:28
struct SQLValueFunction SQLValueFunction
NullTestType
Definition: primnodes.h:1953
@ IS_NULL
Definition: primnodes.h:1954
@ IS_NOT_NULL
Definition: primnodes.h:1954
struct JsonConstructorExpr JsonConstructorExpr
struct CurrentOfExpr CurrentOfExpr
JsonValueType
Definition: primnodes.h:1717
@ JS_TYPE_ANY
Definition: primnodes.h:1718
@ JS_TYPE_ARRAY
Definition: primnodes.h:1720
@ JS_TYPE_OBJECT
Definition: primnodes.h:1719
@ JS_TYPE_SCALAR
Definition: primnodes.h:1721
struct NullTest NullTest
MergeMatchKind
Definition: primnodes.h:1997
@ MERGE_WHEN_NOT_MATCHED_BY_TARGET
Definition: primnodes.h:2000
@ MERGE_WHEN_NOT_MATCHED_BY_SOURCE
Definition: primnodes.h:1999
@ MERGE_WHEN_MATCHED
Definition: primnodes.h:1998
struct RowCompareExpr RowCompareExpr
struct JsonTablePath JsonTablePath
struct TableFunc TableFunc
struct JsonTablePathScan JsonTablePathScan
struct JsonTableSiblingJoin JsonTableSiblingJoin
struct ScalarArrayOpExpr ScalarArrayOpExpr
struct JsonFormat JsonFormat
struct Param Param
struct Alias Alias
CoercionContext
Definition: primnodes.h:713
@ COERCION_PLPGSQL
Definition: primnodes.h:716
@ COERCION_ASSIGNMENT
Definition: primnodes.h:715
@ COERCION_EXPLICIT
Definition: primnodes.h:717
@ COERCION_IMPLICIT
Definition: primnodes.h:714
struct RelabelType RelabelType
struct CoerceViaIO CoerceViaIO
struct RangeVar RangeVar
JsonConstructorType
Definition: primnodes.h:1685
@ JSCTOR_JSON_SERIALIZE
Definition: primnodes.h:1692
@ JSCTOR_JSON_ARRAYAGG
Definition: primnodes.h:1689
@ JSCTOR_JSON_PARSE
Definition: primnodes.h:1690
@ JSCTOR_JSON_OBJECT
Definition: primnodes.h:1686
@ JSCTOR_JSON_SCALAR
Definition: primnodes.h:1691
@ JSCTOR_JSON_ARRAY
Definition: primnodes.h:1687
@ JSCTOR_JSON_OBJECTAGG
Definition: primnodes.h:1688
OpExpr NullIfExpr
Definition: primnodes.h:860
struct Const Const
struct SubscriptingRef SubscriptingRef
struct JsonValueExpr JsonValueExpr
struct MergeSupportFunc MergeSupportFunc
struct FromExpr FromExpr
struct FieldStore FieldStore
int aggtransno pg_node_attr(query_jumble_ignore)
Index agglevelsup pg_node_attr(query_jumble_ignore)
char aggkind pg_node_attr(query_jumble_ignore)
Oid inputcollid pg_node_attr(query_jumble_ignore)
Oid aggfnoid
Definition: primnodes.h:444
Expr xpr
Definition: primnodes.h:441
List * aggdistinct
Definition: primnodes.h:474
AggSplit aggsplit pg_node_attr(query_jumble_ignore)
List * aggdirectargs
Definition: primnodes.h:465
bool aggstar pg_node_attr(query_jumble_ignore)
Oid aggtranstype pg_node_attr(equal_ignore, query_jumble_ignore)
Oid aggcollid pg_node_attr(query_jumble_ignore)
List * args
Definition: primnodes.h:468
Expr * aggfilter
Definition: primnodes.h:477
int aggno pg_node_attr(query_jumble_ignore)
Oid aggtype pg_node_attr(query_jumble_ignore)
bool aggvariadic pg_node_attr(query_jumble_ignore)
List *aggargtypes pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:507
List * aggorder
Definition: primnodes.h:471
bool aggpresorted pg_node_attr(equal_ignore, query_jumble_ignore)
char * aliasname
Definition: primnodes.h:50
NodeTag type
Definition: primnodes.h:49
List * colnames
Definition: primnodes.h:51
pg_node_attr(no_query_jumble) Expr xpr
Oid resultcollid pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:1242
CoercionForm coerceformat pg_node_attr(query_jumble_ignore)
int32 resulttypmod pg_node_attr(query_jumble_ignore)
Oid element_typeid pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:1384
Oid array_collid pg_node_attr(query_jumble_ignore)
List * elements
Definition: primnodes.h:1380
Expr xpr
Definition: primnodes.h:1372
bool multidims pg_node_attr(query_jumble_ignore)
Oid array_typeid pg_node_attr(query_jumble_ignore)
pg_node_attr(custom_read_write) Expr xpr
BoolExprType boolop
Definition: primnodes.h:939
List * args
Definition: primnodes.h:940
ParseLoc location
Definition: primnodes.h:941
ParseLoc location
Definition: primnodes.h:1986
BoolTestType booltesttype
Definition: primnodes.h:1985
Expr * arg
Definition: primnodes.h:1984
Expr * arg
Definition: primnodes.h:1313
Oid casecollid pg_node_attr(query_jumble_ignore)
Expr xpr
Definition: primnodes.h:1308
ParseLoc location
Definition: primnodes.h:1316
Oid casetype pg_node_attr(query_jumble_ignore)
Expr * defresult
Definition: primnodes.h:1315
List * args
Definition: primnodes.h:1314
int32 typeMod pg_node_attr(query_jumble_ignore)
Oid collation pg_node_attr(query_jumble_ignore)
Expr * result
Definition: primnodes.h:1326
Expr * expr
Definition: primnodes.h:1325
Expr xpr
Definition: primnodes.h:1324
ParseLoc location
Definition: primnodes.h:1327
Oid coalescetype pg_node_attr(query_jumble_ignore)
List * args
Definition: primnodes.h:1492
Oid coalescecollid pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:1494
Oid collation pg_node_attr(query_jumble_ignore)
int32 typeMod pg_node_attr(query_jumble_ignore)
int32 resulttypmod pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:2038
CoercionForm coercionformat pg_node_attr(query_jumble_ignore)
Oid resultcollid pg_node_attr(query_jumble_ignore)
Expr * arg
Definition: primnodes.h:1207
CoercionForm coerceformat pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:1214
Oid resulttype
Definition: primnodes.h:1208
Oid resultcollid pg_node_attr(query_jumble_ignore)
Expr * arg
Definition: primnodes.h:1279
ParseLoc location
Definition: primnodes.h:1281
ParseLoc location pg_node_attr(query_jumble_location)
Oid consttype
Definition: primnodes.h:312
Datum constvalue pg_node_attr(query_jumble_ignore)
bool constbyval pg_node_attr(query_jumble_ignore)
pg_node_attr(custom_copy_equal, custom_read_write) Expr xpr
bool constisnull pg_node_attr(query_jumble_ignore)
int constlen pg_node_attr(query_jumble_ignore)
int32 consttypmod pg_node_attr(query_jumble_ignore)
Oid constcollid pg_node_attr(query_jumble_ignore)
CoercionForm convertformat pg_node_attr(query_jumble_ignore)
char * cursor_name
Definition: primnodes.h:2100
pg_node_attr(abstract) NodeTag type
int32 resulttypmod pg_node_attr(query_jumble_ignore)
AttrNumber fieldnum
Definition: primnodes.h:1129
Oid resulttype pg_node_attr(query_jumble_ignore)
Expr * arg
Definition: primnodes.h:1128
Oid resultcollid pg_node_attr(query_jumble_ignore)
Oid resulttype pg_node_attr(query_jumble_ignore)
List *fieldnums pg_node_attr(query_jumble_ignore)
List * newvals
Definition: primnodes.h:1160
Expr * arg
Definition: primnodes.h:1159
Node * quals
Definition: primnodes.h:2311
NodeTag type
Definition: primnodes.h:2309
List * fromlist
Definition: primnodes.h:2310
bool funcvariadic pg_node_attr(query_jumble_ignore)
Oid inputcollid pg_node_attr(query_jumble_ignore)
Oid funccollid pg_node_attr(query_jumble_ignore)
Expr xpr
Definition: primnodes.h:748
bool funcretset pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:770
Oid funcid
Definition: primnodes.h:750
List * args
Definition: primnodes.h:768
CoercionForm funcformat pg_node_attr(query_jumble_ignore)
Oid funcresulttype pg_node_attr(query_jumble_ignore)
List *args pg_node_attr(query_jumble_ignore)
List *refs pg_node_attr(equal_ignore)
Index agglevelsup
Definition: primnodes.h:551
List *cols pg_node_attr(equal_ignore, query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:554
Node *viewQuery pg_node_attr(query_jumble_ignore)
List * colNames
Definition: primnodes.h:163
char * tableSpaceName
Definition: primnodes.h:167
bool skipData
Definition: primnodes.h:170
OnCommitAction onCommit
Definition: primnodes.h:166
NodeTag type
Definition: primnodes.h:160
List * options
Definition: primnodes.h:165
char * accessMethod
Definition: primnodes.h:164
RangeVar * rel
Definition: primnodes.h:162
Node * quals
Definition: primnodes.h:2291
List *usingClause pg_node_attr(query_jumble_ignore)
Alias *join_using_alias pg_node_attr(query_jumble_ignore)
Alias *alias pg_node_attr(query_jumble_ignore)
JoinType jointype
Definition: primnodes.h:2282
int rtindex
Definition: primnodes.h:2295
Node * larg
Definition: primnodes.h:2284
bool isNatural
Definition: primnodes.h:2283
NodeTag type
Definition: primnodes.h:2281
Node * rarg
Definition: primnodes.h:2285
Node * expr
Definition: primnodes.h:1787
ParseLoc location
Definition: primnodes.h:1789
JsonBehaviorType btype
Definition: primnodes.h:1786
NodeTag type
Definition: primnodes.h:1784
JsonReturning * returning
Definition: primnodes.h:1706
JsonConstructorType type
Definition: primnodes.h:1702
char * column_name
Definition: primnodes.h:1815
Node * formatted_expr
Definition: primnodes.h:1819
ParseLoc location
Definition: primnodes.h:1861
List * passing_values
Definition: primnodes.h:1832
JsonBehavior * on_empty
Definition: primnodes.h:1835
JsonFormat * format
Definition: primnodes.h:1822
Expr xpr
Definition: primnodes.h:1811
List * passing_names
Definition: primnodes.h:1831
Node * path_spec
Definition: primnodes.h:1825
bool use_io_coercion
Definition: primnodes.h:1848
Oid collation
Definition: primnodes.h:1858
JsonReturning * returning
Definition: primnodes.h:1828
bool use_json_coercion
Definition: primnodes.h:1849
JsonWrapper wrapper
Definition: primnodes.h:1852
JsonExprOp op
Definition: primnodes.h:1813
JsonBehavior * on_error
Definition: primnodes.h:1836
bool omit_quotes
Definition: primnodes.h:1855
Node * coercion_expr
Definition: primnodes.h:1847
ParseLoc location
Definition: primnodes.h:1653
NodeTag type
Definition: primnodes.h:1650
JsonEncoding encoding
Definition: primnodes.h:1652
JsonFormatType format_type
Definition: primnodes.h:1651
JsonFormat * format
Definition: primnodes.h:1732
JsonValueType item_type
Definition: primnodes.h:1733
ParseLoc location
Definition: primnodes.h:1735
JsonFormat * format
Definition: primnodes.h:1663
NodeTag type
Definition: primnodes.h:1662
JsonTablePath * path
Definition: primnodes.h:1900
JsonTablePlan * child
Definition: primnodes.h:1909
JsonTablePlan plan
Definition: primnodes.h:1897
NodeTag type
Definition: primnodes.h:1871
Const * value
Definition: primnodes.h:1873
pg_node_attr(abstract) NodeTag type
JsonTablePlan * rplan
Definition: primnodes.h:1930
JsonTablePlan * lplan
Definition: primnodes.h:1929
JsonTablePlan plan
Definition: primnodes.h:1927
Expr * formatted_expr
Definition: primnodes.h:1680
JsonFormat * format
Definition: primnodes.h:1681
NodeTag type
Definition: primnodes.h:1678
Expr * raw_expr
Definition: primnodes.h:1679
Definition: pg_list.h:54
List *updateColnos pg_node_attr(query_jumble_ignore)
OverridingKind override pg_node_attr(query_jumble_ignore)
NodeTag type
Definition: primnodes.h:2007
Node * qual
Definition: primnodes.h:2012
CmdType commandType
Definition: primnodes.h:2009
List * targetList
Definition: primnodes.h:2013
MergeMatchKind matchKind
Definition: primnodes.h:2008
ParseLoc location
Definition: primnodes.h:636
List * args
Definition: primnodes.h:1518
Oid minmaxcollid pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:1520
Oid inputcollid pg_node_attr(query_jumble_ignore)
Oid minmaxtype pg_node_attr(query_jumble_ignore)
MinMaxOp op
Definition: primnodes.h:1516
Expr * arg
Definition: primnodes.h:791
char *name pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:797
Definition: nodes.h:129
NullTestType nulltesttype
Definition: primnodes.h:1961
Expr xpr
Definition: primnodes.h:1959
bool argisrow pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:1964
Expr * arg
Definition: primnodes.h:1960
List * arbiterElems
Definition: primnodes.h:2329
OnConflictAction action
Definition: primnodes.h:2326
List * onConflictSet
Definition: primnodes.h:2335
List * exclRelTlist
Definition: primnodes.h:2338
NodeTag type
Definition: primnodes.h:2325
Node * onConflictWhere
Definition: primnodes.h:2336
Node * arbiterWhere
Definition: primnodes.h:2331
Oid opfuncid pg_node_attr(equal_ignore_if_zero, query_jumble_ignore)
Oid opcollid pg_node_attr(query_jumble_ignore)
Oid opresulttype pg_node_attr(query_jumble_ignore)
Oid inputcollid pg_node_attr(query_jumble_ignore)
bool opretset pg_node_attr(query_jumble_ignore)
Oid opno
Definition: primnodes.h:818
List * args
Definition: primnodes.h:836
ParseLoc location
Definition: primnodes.h:839
Expr xpr
Definition: primnodes.h:815
ParseLoc location
Definition: primnodes.h:384
Expr xpr
Definition: primnodes.h:375
int paramid
Definition: primnodes.h:377
Oid paramtype
Definition: primnodes.h:378
ParamKind paramkind
Definition: primnodes.h:376
int32 paramtypmod pg_node_attr(query_jumble_ignore)
Oid paramcollid pg_node_attr(query_jumble_ignore)
NodeTag type
Definition: primnodes.h:2247
char * relname
Definition: primnodes.h:82
bool inh
Definition: primnodes.h:85
Alias * alias
Definition: primnodes.h:91
char relpersistence
Definition: primnodes.h:88
char * catalogname
Definition: primnodes.h:76
ParseLoc location
Definition: primnodes.h:94
char * schemaname
Definition: primnodes.h:79
NodeTag type
Definition: primnodes.h:73
int32 resulttypmod pg_node_attr(query_jumble_ignore)
Oid resulttype
Definition: primnodes.h:1185
Oid resultcollid pg_node_attr(query_jumble_ignore)
CoercionForm relabelformat pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:1192
Expr * arg
Definition: primnodes.h:1184
List *inputcollids pg_node_attr(query_jumble_ignore)
RowCompareType rctype
Definition: primnodes.h:1468
List *opfamilies pg_node_attr(query_jumble_ignore)
List *opnos pg_node_attr(query_jumble_ignore)
Expr xpr
Definition: primnodes.h:1410
CoercionForm row_format pg_node_attr(query_jumble_ignore)
List * args
Definition: primnodes.h:1411
ParseLoc location
Definition: primnodes.h:1435
List *colnames pg_node_attr(query_jumble_ignore)
Oid row_typeid pg_node_attr(query_jumble_ignore)
Oid type pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:1564
SQLValueFunctionOp op
Definition: primnodes.h:1556
Oid hashfuncid pg_node_attr(equal_ignore_if_zero, query_jumble_ignore)
Oid negfuncid pg_node_attr(equal_ignore_if_zero, query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:919
Oid inputcollid pg_node_attr(query_jumble_ignore)
Oid opfuncid pg_node_attr(equal_ignore_if_zero, query_jumble_ignore)
int32 typeMod pg_node_attr(query_jumble_ignore)
Oid collation pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:2080
int plan_id
Definition: primnodes.h:1070
char * plan_name
Definition: primnodes.h:1072
List * args
Definition: primnodes.h:1091
List * paramIds
Definition: primnodes.h:1068
bool useHashTable
Definition: primnodes.h:1079
Node * testexpr
Definition: primnodes.h:1067
int32 firstColTypmod
Definition: primnodes.h:1075
pg_node_attr(no_query_jumble) Expr xpr
List * parParam
Definition: primnodes.h:1090
bool parallel_safe
Definition: primnodes.h:1084
List * setParam
Definition: primnodes.h:1088
bool unknownEqFalse
Definition: primnodes.h:1081
Cost startup_cost
Definition: primnodes.h:1093
Oid firstColCollation
Definition: primnodes.h:1076
Cost per_call_cost
Definition: primnodes.h:1094
SubLinkType subLinkType
Definition: primnodes.h:1065
Oid firstColType
Definition: primnodes.h:1074
Oid refelemtype pg_node_attr(query_jumble_ignore)
Oid refcollid pg_node_attr(query_jumble_ignore)
Oid refrestype pg_node_attr(query_jumble_ignore)
Oid refcontainertype pg_node_attr(query_jumble_ignore)
int32 reftypmod pg_node_attr(query_jumble_ignore)
Expr * refassgnexpr
Definition: primnodes.h:703
List * refupperindexpr
Definition: primnodes.h:693
Expr * refexpr
Definition: primnodes.h:701
List * reflowerindexpr
Definition: primnodes.h:699
List *colnames pg_node_attr(query_jumble_ignore)
List *colvalexprs pg_node_attr(query_jumble_ignore)
ParseLoc location
Definition: primnodes.h:145
List *coltypes pg_node_attr(query_jumble_ignore)
Node *plan pg_node_attr(query_jumble_ignore)
Bitmapset *notnulls pg_node_attr(query_jumble_ignore)
List *ns_names pg_node_attr(query_jumble_ignore)
List *coldefexprs pg_node_attr(query_jumble_ignore)
Node * docexpr
Definition: primnodes.h:119
List *colcollations pg_node_attr(query_jumble_ignore)
int ordinalitycol pg_node_attr(query_jumble_ignore)
NodeTag type
Definition: primnodes.h:111
List *passingvalexprs pg_node_attr(query_jumble_ignore)
List *coltypmods pg_node_attr(query_jumble_ignore)
Node * rowexpr
Definition: primnodes.h:121
List * colexprs
Definition: primnodes.h:131
TableFuncType functype
Definition: primnodes.h:113
List *ns_uris pg_node_attr(query_jumble_ignore)
char *resname pg_node_attr(query_jumble_ignore)
Expr * expr
Definition: primnodes.h:2192
AttrNumber resorigcol pg_node_attr(query_jumble_ignore)
bool resjunk pg_node_attr(query_jumble_ignore)
Oid resorigtbl pg_node_attr(query_jumble_ignore)
AttrNumber resno
Definition: primnodes.h:2194
Index ressortgroupref
Definition: primnodes.h:2198
Definition: primnodes.h:248
ParseLoc location
Definition: primnodes.h:293
AttrNumber varattno
Definition: primnodes.h:260
int32 vartypmod pg_node_attr(query_jumble_ignore)
Oid varcollid pg_node_attr(query_jumble_ignore)
Expr xpr
Definition: primnodes.h:249
int varno
Definition: primnodes.h:255
AttrNumber varattnosyn pg_node_attr(equal_ignore, query_jumble_ignore)
Index varlevelsup
Definition: primnodes.h:280
Bitmapset *varnullingrels pg_node_attr(query_jumble_ignore)
Oid vartype pg_node_attr(query_jumble_ignore)
Index varnosyn pg_node_attr(equal_ignore, query_jumble_ignore)
Oid inputcollid pg_node_attr(query_jumble_ignore)
Expr xpr
Definition: primnodes.h:565
List * args
Definition: primnodes.h:575
Index winref
Definition: primnodes.h:581
bool winagg pg_node_attr(query_jumble_ignore)
Oid inputcollid pg_node_attr(query_jumble_ignore)
Expr * aggfilter
Definition: primnodes.h:577
ParseLoc location
Definition: primnodes.h:587
Oid wincollid pg_node_attr(query_jumble_ignore)
Oid wintype pg_node_attr(query_jumble_ignore)
bool winstar pg_node_attr(query_jumble_ignore)
Oid winfnoid
Definition: primnodes.h:567
List *runCondition pg_node_attr(query_jumble_ignore)
List *arg_names pg_node_attr(query_jumble_ignore)
int32 typmod pg_node_attr(query_jumble_ignore)
List * args
Definition: primnodes.h:1608
Expr xpr
Definition: primnodes.h:1598
ParseLoc location
Definition: primnodes.h:1617
bool indent
Definition: primnodes.h:1612
XmlOptionType xmloption pg_node_attr(query_jumble_ignore)
char *name pg_node_attr(query_jumble_ignore)
List * named_args
Definition: primnodes.h:1604
XmlExprOp op
Definition: primnodes.h:1600
Oid type pg_node_attr(query_jumble_ignore)
const char * type
const char * name
int xmloption
Definition: xml.c:110