Debian Codegraph @

src/include/nodes/parsenodes.h

raw
1 /*-------------------------------------------------------------------------
2 *
3 * parsenodes.h
4 * definitions for parse tree nodes
5 *
6 * Many of the node types used in parsetrees include a "location" field.
7 * This is a byte (not character) offset in the original source text, to be
8 * used for positioning an error cursor when there is an error related to
9 * the node. Access to the original source text is needed to make use of
10 * the location. At the topmost (statement) level, we also provide a
11 * statement length, likewise measured in bytes, for convenience in
12 * identifying statement boundaries in multi-statement source strings.
13 *
14 *
15 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
16 * Portions Copyright (c) 1994, Regents of the University of California
17 *
18 * src/include/nodes/parsenodes.h
19 *
20 *-------------------------------------------------------------------------
21 */
22 #ifndef PARSENODES_H
23 #define PARSENODES_H
24
25 #include "common/relpath.h"
26 #include "nodes/bitmapset.h"
27 #include "nodes/lockoptions.h"
28 #include "nodes/primnodes.h"
29 #include "nodes/value.h"
30 #include "partitioning/partdefs.h"
31
32
33 /* Possible sources of a Query */
34 typedef enum QuerySource
35 {
36 QSRC_ORIGINAL, /* original parsetree (explicit query) */
37 QSRC_PARSER, /* added by parse analysis (now unused) */
38 QSRC_INSTEAD_RULE, /* added by unconditional INSTEAD rule */
39 QSRC_QUAL_INSTEAD_RULE, /* added by conditional INSTEAD rule */
40 QSRC_NON_INSTEAD_RULE, /* added by non-INSTEAD rule */
41 } QuerySource;
42
43 /* Sort ordering options for ORDER BY and CREATE INDEX */
44 typedef enum SortByDir
45 {
46 SORTBY_DEFAULT,
47 SORTBY_ASC,
48 SORTBY_DESC,
49 SORTBY_USING, /* not allowed in CREATE INDEX ... */
50 } SortByDir;
51
52 typedef enum SortByNulls
53 {
54 SORTBY_NULLS_DEFAULT,
55 SORTBY_NULLS_FIRST,
56 SORTBY_NULLS_LAST,
57 } SortByNulls;
58
59 /* Options for [ ALL | DISTINCT ] */
60 typedef enum SetQuantifier
61 {
62 SET_QUANTIFIER_DEFAULT,
63 SET_QUANTIFIER_ALL,
64 SET_QUANTIFIER_DISTINCT,
65 } SetQuantifier;
66
67 /*
68 * Grantable rights are encoded so that we can OR them together in a bitmask.
69 * The present representation of AclItem limits us to 32 distinct rights,
70 * even though AclMode is defined as uint64. See utils/acl.h.
71 *
72 * Caution: changing these codes breaks stored ACLs, hence forces initdb.
73 */
74 typedef uint64 AclMode; /* a bitmask of privilege bits */
75
76 #define ACL_INSERT (1<<0) /* for relations */
77 #define ACL_SELECT (1<<1)
78 #define ACL_UPDATE (1<<2)
79 #define ACL_DELETE (1<<3)
80 #define ACL_TRUNCATE (1<<4)
81 #define ACL_REFERENCES (1<<5)
82 #define ACL_TRIGGER (1<<6)
83 #define ACL_EXECUTE (1<<7) /* for functions */
84 #define ACL_USAGE (1<<8) /* for various object types */
85 #define ACL_CREATE (1<<9) /* for namespaces and databases */
86 #define ACL_CREATE_TEMP (1<<10) /* for databases */
87 #define ACL_CONNECT (1<<11) /* for databases */
88 #define ACL_SET (1<<12) /* for configuration parameters */
89 #define ACL_ALTER_SYSTEM (1<<13) /* for configuration parameters */
90 #define ACL_MAINTAIN (1<<14) /* for relations */
91 #define N_ACL_RIGHTS 15 /* 1 plus the last 1<<x */
92 #define ACL_NO_RIGHTS 0
93 /* Currently, SELECT ... FOR [KEY] UPDATE/SHARE requires UPDATE privileges */
94 #define ACL_SELECT_FOR_UPDATE ACL_UPDATE
95
96
97 /*****************************************************************************
98 * Query Tree
99 *****************************************************************************/
100
101 /*
102 * Query -
103 * Parse analysis turns all statements into a Query tree
104 * for further processing by the rewriter and planner.
105 *
106 * Utility statements (i.e. non-optimizable statements) have the
107 * utilityStmt field set, and the rest of the Query is mostly dummy.
108 *
109 * Planning converts a Query tree into a Plan tree headed by a PlannedStmt
110 * node --- the Query structure is not used by the executor.
111 *
112 * All the fields ignored for the query jumbling are not semantically
113 * significant (such as alias names), as is ignored anything that can
114 * be deduced from child nodes (else we'd just be double-hashing that
115 * piece of information).
116 */
117 typedef struct Query
118 {
119 NodeTag type;
120
121 CmdType commandType; /* select|insert|update|delete|merge|utility */
122
123 /* where did I come from? */
124 QuerySource querySource pg_node_attr(query_jumble_ignore);
125
126 /*
127 * query identifier (can be set by plugins); ignored for equal, as it
128 * might not be set; also not stored. This is the result of the query
129 * jumble, hence ignored.
130 *
131 * We store this as a signed value as this is the form it's displayed to
132 * users in places such as EXPLAIN and pg_stat_statements. Primarily this
133 * is done due to lack of an SQL type to represent the full range of
134 * uint64.
135 */
136 int64 queryId pg_node_attr(equal_ignore, query_jumble_ignore, read_write_ignore, read_as(0));
137
138 /* do I set the command result tag? */
139 bool canSetTag pg_node_attr(query_jumble_ignore);
140
141 Node *utilityStmt; /* non-null if commandType == CMD_UTILITY */
142
143 /*
144 * rtable index of target relation for INSERT/UPDATE/DELETE/MERGE; 0 for
145 * SELECT. This is ignored in the query jumble as unrelated to the
146 * compilation of the query ID.
147 */
148 int resultRelation pg_node_attr(query_jumble_ignore);
149
150 /* has aggregates in tlist or havingQual */
151 bool hasAggs pg_node_attr(query_jumble_ignore);
152 /* has window functions in tlist */
153 bool hasWindowFuncs pg_node_attr(query_jumble_ignore);
154 /* has set-returning functions in tlist */
155 bool hasTargetSRFs pg_node_attr(query_jumble_ignore);
156 /* has subquery SubLink */
157 bool hasSubLinks pg_node_attr(query_jumble_ignore);
158 /* distinctClause is from DISTINCT ON */
159 bool hasDistinctOn pg_node_attr(query_jumble_ignore);
160 /* WITH RECURSIVE was specified */
161 bool hasRecursive pg_node_attr(query_jumble_ignore);
162 /* has INSERT/UPDATE/DELETE/MERGE in WITH */
163 bool hasModifyingCTE pg_node_attr(query_jumble_ignore);
164 /* FOR [KEY] UPDATE/SHARE was specified */
165 bool hasForUpdate pg_node_attr(query_jumble_ignore);
166 /* rewriter has applied some RLS policy */
167 bool hasRowSecurity pg_node_attr(query_jumble_ignore);
168 /* parser has added an RTE_GROUP RTE */
169 bool hasGroupRTE pg_node_attr(query_jumble_ignore);
170 /* is a RETURN statement */
171 bool isReturn pg_node_attr(query_jumble_ignore);
172
173 List *cteList; /* WITH list (of CommonTableExpr's) */
174
175 List *rtable; /* list of range table entries */
176
177 /*
178 * list of RTEPermissionInfo nodes for the rtable entries having
179 * perminfoindex > 0
180 */
181 List *rteperminfos pg_node_attr(query_jumble_ignore);
182 FromExpr *jointree; /* table join tree (FROM and WHERE clauses);
183 * also USING clause for MERGE */
184
185 List *mergeActionList; /* list of actions for MERGE (only) */
186
187 /*
188 * rtable index of target relation for MERGE to pull data. Initially, this
189 * is the same as resultRelation, but after query rewriting, if the target
190 * relation is a trigger-updatable view, this is the index of the expanded
191 * view subquery, whereas resultRelation is the index of the target view.
192 */
193 int mergeTargetRelation pg_node_attr(query_jumble_ignore);
194
195 /* join condition between source and target for MERGE */
196 Node *mergeJoinCondition;
197
198 List *targetList; /* target list (of TargetEntry) */
199
200 /* OVERRIDING clause */
201 OverridingKind override pg_node_attr(query_jumble_ignore);
202
203 OnConflictExpr *onConflict; /* ON CONFLICT DO [NOTHING | UPDATE] */
204
205 /*
206 * The following three fields describe the contents of the RETURNING list
207 * for INSERT/UPDATE/DELETE/MERGE. returningOldAlias and returningNewAlias
208 * are the alias names for OLD and NEW, which may be user-supplied values,
209 * the defaults "old" and "new", or NULL (if the default "old"/"new" is
210 * already in use as the alias for some other relation).
211 */
212 char *returningOldAlias pg_node_attr(query_jumble_ignore);
213 char *returningNewAlias pg_node_attr(query_jumble_ignore);
214 List *returningList; /* return-values list (of TargetEntry) */
215
216 List *groupClause; /* a list of SortGroupClause's */
217 bool groupDistinct; /* is the group by clause distinct? */
218
219 List *groupingSets; /* a list of GroupingSet's if present */
220
221 Node *havingQual; /* qualifications applied to groups */
222
223 List *windowClause; /* a list of WindowClause's */
224
225 List *distinctClause; /* a list of SortGroupClause's */
226
227 List *sortClause; /* a list of SortGroupClause's */
228
229 Node *limitOffset; /* # of result tuples to skip (int8 expr) */
230 Node *limitCount; /* # of result tuples to return (int8 expr) */
231 LimitOption limitOption; /* limit type */
232
233 List *rowMarks; /* a list of RowMarkClause's */
234
235 Node *setOperations; /* set-operation tree if this is top level of
236 * a UNION/INTERSECT/EXCEPT query */
237
238 /*
239 * A list of pg_constraint OIDs that the query depends on to be
240 * semantically valid
241 */
242 List *constraintDeps pg_node_attr(query_jumble_ignore);
243
244 /* a list of WithCheckOption's (added during rewrite) */
245 List *withCheckOptions pg_node_attr(query_jumble_ignore);
246
247 /*
248 * The following two fields identify the portion of the source text string
249 * containing this query. They are typically only populated in top-level
250 * Queries, not in sub-queries. When not set, they might both be zero, or
251 * both be -1 meaning "unknown".
252 */
253 /* start location, or -1 if unknown */
254 ParseLoc stmt_location;
255 /* length in bytes; 0 means "rest of string" */
256 ParseLoc stmt_len pg_node_attr(query_jumble_ignore);
257 } Query;
258
259
260 /****************************************************************************
261 * Supporting data structures for Parse Trees
262 *
263 * Most of these node types appear in raw parsetrees output by the grammar,
264 * and get transformed to something else by the analyzer. A few of them
265 * are used as-is in transformed querytrees.
266 ****************************************************************************/
267
268 /*
269 * TypeName - specifies a type in definitions
270 *
271 * For TypeName structures generated internally, it is often easier to
272 * specify the type by OID than by name. If "names" is NIL then the
273 * actual type OID is given by typeOid, otherwise typeOid is unused.
274 * Similarly, if "typmods" is NIL then the actual typmod is expected to
275 * be prespecified in typemod, otherwise typemod is unused.
276 *
277 * If pct_type is true, then names is actually a field name and we look up
278 * the type of that field. Otherwise (the normal case), names is a type
279 * name possibly qualified with schema and database name.
280 */
281 typedef struct TypeName
282 {
283 NodeTag type;
284 List *names; /* qualified name (list of String nodes) */
285 Oid typeOid; /* type identified by OID */
286 bool setof; /* is a set? */
287 bool pct_type; /* %TYPE specified? */
288 List *typmods; /* type modifier expression(s) */
289 int32 typemod; /* prespecified type modifier */
290 List *arrayBounds; /* array bounds */
291 ParseLoc location; /* token location, or -1 if unknown */
292 } TypeName;
293
294 /*
295 * ColumnRef - specifies a reference to a column, or possibly a whole tuple
296 *
297 * The "fields" list must be nonempty. It can contain String nodes
298 * (representing names) and A_Star nodes (representing occurrence of a '*').
299 * Currently, A_Star must appear only as the last list element --- the grammar
300 * is responsible for enforcing this!
301 *
302 * Note: any container subscripting or selection of fields from composite columns
303 * is represented by an A_Indirection node above the ColumnRef. However,
304 * for simplicity in the normal case, initial field selection from a table
305 * name is represented within ColumnRef and not by adding A_Indirection.
306 */
307 typedef struct ColumnRef
308 {
309 NodeTag type;
310 List *fields; /* field names (String nodes) or A_Star */
311 ParseLoc location; /* token location, or -1 if unknown */
312 } ColumnRef;
313
314 /*
315 * ParamRef - specifies a $n parameter reference
316 */
317 typedef struct ParamRef
318 {
319 NodeTag type;
320 int number; /* the number of the parameter */
321 ParseLoc location; /* token location, or -1 if unknown */
322 } ParamRef;
323
324 /*
325 * A_Expr - infix, prefix, and postfix expressions
326 */
327 typedef enum A_Expr_Kind
328 {
329 AEXPR_OP, /* normal operator */
330 AEXPR_OP_ANY, /* scalar op ANY (array) */
331 AEXPR_OP_ALL, /* scalar op ALL (array) */
332 AEXPR_DISTINCT, /* IS DISTINCT FROM - name must be "=" */
333 AEXPR_NOT_DISTINCT, /* IS NOT DISTINCT FROM - name must be "=" */
334 AEXPR_NULLIF, /* NULLIF - name must be "=" */
335 AEXPR_IN, /* [NOT] IN - name must be "=" or "<>" */
336 AEXPR_LIKE, /* [NOT] LIKE - name must be "~~" or "!~~" */
337 AEXPR_ILIKE, /* [NOT] ILIKE - name must be "~~*" or "!~~*" */
338 AEXPR_SIMILAR, /* [NOT] SIMILAR - name must be "~" or "!~" */
339 AEXPR_BETWEEN, /* name must be "BETWEEN" */
340 AEXPR_NOT_BETWEEN, /* name must be "NOT BETWEEN" */
341 AEXPR_BETWEEN_SYM, /* name must be "BETWEEN SYMMETRIC" */
342 AEXPR_NOT_BETWEEN_SYM, /* name must be "NOT BETWEEN SYMMETRIC" */
343 } A_Expr_Kind;
344
345 typedef struct A_Expr
346 {
347 pg_node_attr(custom_read_write)
348
349 NodeTag type;
350 A_Expr_Kind kind; /* see above */
351 List *name; /* possibly-qualified name of operator */
352 Node *lexpr; /* left argument, or NULL if none */
353 Node *rexpr; /* right argument, or NULL if none */
354
355 /*
356 * If rexpr is a list of some kind, we separately track its starting and
357 * ending location; it's not the same as the starting and ending location
358 * of the token itself.
359 */
360 ParseLoc rexpr_list_start;
361 ParseLoc rexpr_list_end;
362 ParseLoc location; /* token location, or -1 if unknown */
363 } A_Expr;
364
365 /*
366 * A_Const - a literal constant
367 *
368 * Value nodes are inline for performance. You can treat 'val' as a node,
369 * as in IsA(&val, Integer). 'val' is not valid if isnull is true.
370 */
371 union ValUnion
372 {
373 Node node;
374 Integer ival;
375 Float fval;
376 Boolean boolval;
377 String sval;
378 BitString bsval;
379 };
380
381 typedef struct A_Const
382 {
383 pg_node_attr(custom_copy_equal, custom_read_write, custom_query_jumble)
384
385 NodeTag type;
386 union ValUnion val;
387 bool isnull; /* SQL NULL constant */
388 ParseLoc location; /* token location, or -1 if unknown */
389 } A_Const;
390
391 /*
392 * TypeCast - a CAST expression
393 */
394 typedef struct TypeCast
395 {
396 NodeTag type;
397 Node *arg; /* the expression being casted */
398 TypeName *typeName; /* the target type */
399 ParseLoc location; /* token location, or -1 if unknown */
400 } TypeCast;
401
402 /*
403 * CollateClause - a COLLATE expression
404 */
405 typedef struct CollateClause
406 {
407 NodeTag type;
408 Node *arg; /* input expression */
409 List *collname; /* possibly-qualified collation name */
410 ParseLoc location; /* token location, or -1 if unknown */
411 } CollateClause;
412
413 /*
414 * RoleSpec - a role name or one of a few special values.
415 */
416 typedef enum RoleSpecType
417 {
418 ROLESPEC_CSTRING, /* role name is stored as a C string */
419 ROLESPEC_CURRENT_ROLE, /* role spec is CURRENT_ROLE */
420 ROLESPEC_CURRENT_USER, /* role spec is CURRENT_USER */
421 ROLESPEC_SESSION_USER, /* role spec is SESSION_USER */
422 ROLESPEC_PUBLIC, /* role name is "public" */
423 } RoleSpecType;
424
425 typedef struct RoleSpec
426 {
427 NodeTag type;
428 RoleSpecType roletype; /* Type of this rolespec */
429 char *rolename; /* filled only for ROLESPEC_CSTRING */
430 ParseLoc location; /* token location, or -1 if unknown */
431 } RoleSpec;
432
433 /*
434 * FuncCall - a function or aggregate invocation
435 *
436 * agg_order (if not NIL) indicates we saw 'foo(... ORDER BY ...)', or if
437 * agg_within_group is true, it was 'foo(...) WITHIN GROUP (ORDER BY ...)'.
438 * agg_star indicates we saw a 'foo(*)' construct, while agg_distinct
439 * indicates we saw 'foo(DISTINCT ...)'. In any of these cases, the
440 * construct *must* be an aggregate call. Otherwise, it might be either an
441 * aggregate or some other kind of function. However, if FILTER or OVER is
442 * present it had better be an aggregate or window function.
443 *
444 * Normally, you'd initialize this via makeFuncCall() and then only change the
445 * parts of the struct its defaults don't match afterwards, as needed.
446 */
447 typedef struct FuncCall
448 {
449 NodeTag type;
450 List *funcname; /* qualified name of function */
451 List *args; /* the arguments (list of exprs) */
452 List *agg_order; /* ORDER BY (list of SortBy) */
453 Node *agg_filter; /* FILTER clause, if any */
454 struct WindowDef *over; /* OVER clause, if any */
455 bool agg_within_group; /* ORDER BY appeared in WITHIN GROUP */
456 bool agg_star; /* argument was really '*' */
457 bool agg_distinct; /* arguments were labeled DISTINCT */
458 bool func_variadic; /* last argument was labeled VARIADIC */
459 CoercionForm funcformat; /* how to display this node */
460 ParseLoc location; /* token location, or -1 if unknown */
461 } FuncCall;
462
463 /*
464 * A_Star - '*' representing all columns of a table or compound field
465 *
466 * This can appear within ColumnRef.fields, A_Indirection.indirection, and
467 * ResTarget.indirection lists.
468 */
469 typedef struct A_Star
470 {
471 NodeTag type;
472 } A_Star;
473
474 /*
475 * A_Indices - array subscript or slice bounds ([idx] or [lidx:uidx])
476 *
477 * In slice case, either or both of lidx and uidx can be NULL (omitted).
478 * In non-slice case, uidx holds the single subscript and lidx is always NULL.
479 */
480 typedef struct A_Indices
481 {
482 NodeTag type;
483 bool is_slice; /* true if slice (i.e., colon present) */
484 Node *lidx; /* slice lower bound, if any */
485 Node *uidx; /* subscript, or slice upper bound if any */
486 } A_Indices;
487
488 /*
489 * A_Indirection - select a field and/or array element from an expression
490 *
491 * The indirection list can contain A_Indices nodes (representing
492 * subscripting), String nodes (representing field selection --- the
493 * string value is the name of the field to select), and A_Star nodes
494 * (representing selection of all fields of a composite type).
495 * For example, a complex selection operation like
496 * (foo).field1[42][7].field2
497 * would be represented with a single A_Indirection node having a 4-element
498 * indirection list.
499 *
500 * Currently, A_Star must appear only as the last list element --- the grammar
501 * is responsible for enforcing this!
502 */
503 typedef struct A_Indirection
504 {
505 NodeTag type;
506 Node *arg; /* the thing being selected from */
507 List *indirection; /* subscripts and/or field names and/or * */
508 } A_Indirection;
509
510 /*
511 * A_ArrayExpr - an ARRAY[] construct
512 */
513 typedef struct A_ArrayExpr
514 {
515 NodeTag type;
516 List *elements; /* array element expressions */
517 ParseLoc list_start; /* start of the element list */
518 ParseLoc list_end; /* end of the elements list */
519 ParseLoc location; /* token location, or -1 if unknown */
520 } A_ArrayExpr;
521
522 /*
523 * ResTarget -
524 * result target (used in target list of pre-transformed parse trees)
525 *
526 * In a SELECT target list, 'name' is the column label from an
527 * 'AS ColumnLabel' clause, or NULL if there was none, and 'val' is the
528 * value expression itself. The 'indirection' field is not used.
529 *
530 * INSERT uses ResTarget in its target-column-names list. Here, 'name' is
531 * the name of the destination column, 'indirection' stores any subscripts
532 * attached to the destination, and 'val' is not used.
533 *
534 * In an UPDATE target list, 'name' is the name of the destination column,
535 * 'indirection' stores any subscripts attached to the destination, and
536 * 'val' is the expression to assign.
537 *
538 * See A_Indirection for more info about what can appear in 'indirection'.
539 */
540 typedef struct ResTarget
541 {
542 NodeTag type;
543 char *name; /* column name or NULL */
544 List *indirection; /* subscripts, field names, and '*', or NIL */
545 Node *val; /* the value expression to compute or assign */
546 ParseLoc location; /* token location, or -1 if unknown */
547 } ResTarget;
548
549 /*
550 * MultiAssignRef - element of a row source expression for UPDATE
551 *
552 * In an UPDATE target list, when we have SET (a,b,c) = row-valued-expression,
553 * we generate separate ResTarget items for each of a,b,c. Their "val" trees
554 * are MultiAssignRef nodes numbered 1..n, linking to a common copy of the
555 * row-valued-expression (which parse analysis will process only once, when
556 * handling the MultiAssignRef with colno=1).
557 */
558 typedef struct MultiAssignRef
559 {
560 NodeTag type;
561 Node *source; /* the row-valued expression */
562 int colno; /* column number for this target (1..n) */
563 int ncolumns; /* number of targets in the construct */
564 } MultiAssignRef;
565
566 /*
567 * SortBy - for ORDER BY clause
568 */
569 typedef struct SortBy
570 {
571 NodeTag type;
572 Node *node; /* expression to sort on */
573 SortByDir sortby_dir; /* ASC/DESC/USING/default */
574 SortByNulls sortby_nulls; /* NULLS FIRST/LAST */
575 List *useOp; /* name of op to use, if SORTBY_USING */
576 ParseLoc location; /* operator location, or -1 if none/unknown */
577 } SortBy;
578
579 /*
580 * WindowDef - raw representation of WINDOW and OVER clauses
581 *
582 * For entries in a WINDOW list, "name" is the window name being defined.
583 * For OVER clauses, we use "name" for the "OVER window" syntax, or "refname"
584 * for the "OVER (window)" syntax, which is subtly different --- the latter
585 * implies overriding the window frame clause.
586 */
587 typedef struct WindowDef
588 {
589 NodeTag type;
590 char *name; /* window's own name */
591 char *refname; /* referenced window name, if any */
592 List *partitionClause; /* PARTITION BY expression list */
593 List *orderClause; /* ORDER BY (list of SortBy) */
594 int frameOptions; /* frame_clause options, see below */
595 Node *startOffset; /* expression for starting bound, if any */
596 Node *endOffset; /* expression for ending bound, if any */
597 ParseLoc location; /* parse location, or -1 if none/unknown */
598 } WindowDef;
599
600 /*
601 * frameOptions is an OR of these bits. The NONDEFAULT and BETWEEN bits are
602 * used so that ruleutils.c can tell which properties were specified and
603 * which were defaulted; the correct behavioral bits must be set either way.
604 * The START_foo and END_foo options must come in pairs of adjacent bits for
605 * the convenience of gram.y, even though some of them are useless/invalid.
606 */
607 #define FRAMEOPTION_NONDEFAULT 0x00001 /* any specified? */
608 #define FRAMEOPTION_RANGE 0x00002 /* RANGE behavior */
609 #define FRAMEOPTION_ROWS 0x00004 /* ROWS behavior */
610 #define FRAMEOPTION_GROUPS 0x00008 /* GROUPS behavior */
611 #define FRAMEOPTION_BETWEEN 0x00010 /* BETWEEN given? */
612 #define FRAMEOPTION_START_UNBOUNDED_PRECEDING 0x00020 /* start is U. P. */
613 #define FRAMEOPTION_END_UNBOUNDED_PRECEDING 0x00040 /* (disallowed) */
614 #define FRAMEOPTION_START_UNBOUNDED_FOLLOWING 0x00080 /* (disallowed) */
615 #define FRAMEOPTION_END_UNBOUNDED_FOLLOWING 0x00100 /* end is U. F. */
616 #define FRAMEOPTION_START_CURRENT_ROW 0x00200 /* start is C. R. */
617 #define FRAMEOPTION_END_CURRENT_ROW 0x00400 /* end is C. R. */
618 #define FRAMEOPTION_START_OFFSET_PRECEDING 0x00800 /* start is O. P. */
619 #define FRAMEOPTION_END_OFFSET_PRECEDING 0x01000 /* end is O. P. */
620 #define FRAMEOPTION_START_OFFSET_FOLLOWING 0x02000 /* start is O. F. */
621 #define FRAMEOPTION_END_OFFSET_FOLLOWING 0x04000 /* end is O. F. */
622 #define FRAMEOPTION_EXCLUDE_CURRENT_ROW 0x08000 /* omit C.R. */
623 #define FRAMEOPTION_EXCLUDE_GROUP 0x10000 /* omit C.R. & peers */
624 #define FRAMEOPTION_EXCLUDE_TIES 0x20000 /* omit C.R.'s peers */
625
626 #define FRAMEOPTION_START_OFFSET \
627 (FRAMEOPTION_START_OFFSET_PRECEDING | FRAMEOPTION_START_OFFSET_FOLLOWING)
628 #define FRAMEOPTION_END_OFFSET \
629 (FRAMEOPTION_END_OFFSET_PRECEDING | FRAMEOPTION_END_OFFSET_FOLLOWING)
630 #define FRAMEOPTION_EXCLUSION \
631 (FRAMEOPTION_EXCLUDE_CURRENT_ROW | FRAMEOPTION_EXCLUDE_GROUP | \
632 FRAMEOPTION_EXCLUDE_TIES)
633
634 #define FRAMEOPTION_DEFAULTS \
635 (FRAMEOPTION_RANGE | FRAMEOPTION_START_UNBOUNDED_PRECEDING | \
636 FRAMEOPTION_END_CURRENT_ROW)
637
638 /*
639 * RangeSubselect - subquery appearing in a FROM clause
640 */
641 typedef struct RangeSubselect
642 {
643 NodeTag type;
644 bool lateral; /* does it have LATERAL prefix? */
645 Node *subquery; /* the untransformed sub-select clause */
646 Alias *alias; /* table alias & optional column aliases */
647 } RangeSubselect;
648
649 /*
650 * RangeFunction - function call appearing in a FROM clause
651 *
652 * functions is a List because we use this to represent the construct
653 * ROWS FROM(func1(...), func2(...), ...). Each element of this list is a
654 * two-element sublist, the first element being the untransformed function
655 * call tree, and the second element being a possibly-empty list of ColumnDef
656 * nodes representing any columndef list attached to that function within the
657 * ROWS FROM() syntax.
658 *
659 * alias and coldeflist represent any alias and/or columndef list attached
660 * at the top level. (We disallow coldeflist appearing both here and
661 * per-function, but that's checked in parse analysis, not by the grammar.)
662 */
663 typedef struct RangeFunction
664 {
665 NodeTag type;
666 bool lateral; /* does it have LATERAL prefix? */
667 bool ordinality; /* does it have WITH ORDINALITY suffix? */
668 bool is_rowsfrom; /* is result of ROWS FROM() syntax? */
669 List *functions; /* per-function information, see above */
670 Alias *alias; /* table alias & optional column aliases */
671 List *coldeflist; /* list of ColumnDef nodes to describe result
672 * of function returning RECORD */
673 } RangeFunction;
674
675 /*
676 * RangeTableFunc - raw form of "table functions" such as XMLTABLE
677 *
678 * Note: JSON_TABLE is also a "table function", but it uses JsonTable node,
679 * not RangeTableFunc.
680 */
681 typedef struct RangeTableFunc
682 {
683 NodeTag type;
684 bool lateral; /* does it have LATERAL prefix? */
685 Node *docexpr; /* document expression */
686 Node *rowexpr; /* row generator expression */
687 List *namespaces; /* list of namespaces as ResTarget */
688 List *columns; /* list of RangeTableFuncCol */
689 Alias *alias; /* table alias & optional column aliases */
690 ParseLoc location; /* token location, or -1 if unknown */
691 } RangeTableFunc;
692
693 /*
694 * RangeTableFuncCol - one column in a RangeTableFunc->columns
695 *
696 * If for_ordinality is true (FOR ORDINALITY), then the column is an int4
697 * column and the rest of the fields are ignored.
698 */
699 typedef struct RangeTableFuncCol
700 {
701 NodeTag type;
702 char *colname; /* name of generated column */
703 TypeName *typeName; /* type of generated column */
704 bool for_ordinality; /* does it have FOR ORDINALITY? */
705 bool is_not_null; /* does it have NOT NULL? */
706 Node *colexpr; /* column filter expression */
707 Node *coldefexpr; /* column default value expression */
708 ParseLoc location; /* token location, or -1 if unknown */
709 } RangeTableFuncCol;
710
711 /*
712 * RangeTableSample - TABLESAMPLE appearing in a raw FROM clause
713 *
714 * This node, appearing only in raw parse trees, represents
715 * <relation> TABLESAMPLE <method> (<params>) REPEATABLE (<num>)
716 * Currently, the <relation> can only be a RangeVar, but we might in future
717 * allow RangeSubselect and other options. Note that the RangeTableSample
718 * is wrapped around the node representing the <relation>, rather than being
719 * a subfield of it.
720 */
721 typedef struct RangeTableSample
722 {
723 NodeTag type;
724 Node *relation; /* relation to be sampled */
725 List *method; /* sampling method name (possibly qualified) */
726 List *args; /* argument(s) for sampling method */
727 Node *repeatable; /* REPEATABLE expression, or NULL if none */
728 ParseLoc location; /* method name location, or -1 if unknown */
729 } RangeTableSample;
730
731 /*
732 * ColumnDef - column definition (used in various creates)
733 *
734 * If the column has a default value, we may have the value expression
735 * in either "raw" form (an untransformed parse tree) or "cooked" form
736 * (a post-parse-analysis, executable expression tree), depending on
737 * how this ColumnDef node was created (by parsing, or by inheritance
738 * from an existing relation). We should never have both in the same node!
739 *
740 * Similarly, we may have a COLLATE specification in either raw form
741 * (represented as a CollateClause with arg==NULL) or cooked form
742 * (the collation's OID).
743 *
744 * The constraints list may contain a CONSTR_DEFAULT item in a raw
745 * parsetree produced by gram.y, but transformCreateStmt will remove
746 * the item and set raw_default instead. CONSTR_DEFAULT items
747 * should not appear in any subsequent processing.
748 */
749 typedef struct ColumnDef
750 {
751 NodeTag type;
752 char *colname; /* name of column */
753 TypeName *typeName; /* type of column */
754 char *compression; /* compression method for column */
755 int16 inhcount; /* number of times column is inherited */
756 bool is_local; /* column has local (non-inherited) def'n */
757 bool is_not_null; /* NOT NULL constraint specified? */
758 bool is_from_type; /* column definition came from table type */
759 char storage; /* attstorage setting, or 0 for default */
760 char *storage_name; /* attstorage setting name or NULL for default */
761 Node *raw_default; /* default value (untransformed parse tree) */
762 Node *cooked_default; /* default value (transformed expr tree) */
763 char identity; /* attidentity setting */
764 RangeVar *identitySequence; /* to store identity sequence name for
765 * ALTER TABLE ... ADD COLUMN */
766 char generated; /* attgenerated setting */
767 CollateClause *collClause; /* untransformed COLLATE spec, if any */
768 Oid collOid; /* collation OID (InvalidOid if not set) */
769 List *constraints; /* other constraints on column */
770 List *fdwoptions; /* per-column FDW options */
771 ParseLoc location; /* parse location, or -1 if none/unknown */
772 } ColumnDef;
773
774 /*
775 * TableLikeClause - CREATE TABLE ( ... LIKE ... ) clause
776 */
777 typedef struct TableLikeClause
778 {
779 NodeTag type;
780 RangeVar *relation;
781 bits32 options; /* OR of TableLikeOption flags */
782 Oid relationOid; /* If table has been looked up, its OID */
783 } TableLikeClause;
784
785 typedef enum TableLikeOption
786 {
787 CREATE_TABLE_LIKE_COMMENTS = 1 << 0,
788 CREATE_TABLE_LIKE_COMPRESSION = 1 << 1,
789 CREATE_TABLE_LIKE_CONSTRAINTS = 1 << 2,
790 CREATE_TABLE_LIKE_DEFAULTS = 1 << 3,
791 CREATE_TABLE_LIKE_GENERATED = 1 << 4,
792 CREATE_TABLE_LIKE_IDENTITY = 1 << 5,
793 CREATE_TABLE_LIKE_INDEXES = 1 << 6,
794 CREATE_TABLE_LIKE_STATISTICS = 1 << 7,
795 CREATE_TABLE_LIKE_STORAGE = 1 << 8,
796 CREATE_TABLE_LIKE_ALL = PG_INT32_MAX
797 } TableLikeOption;
798
799 /*
800 * IndexElem - index parameters (used in CREATE INDEX, and in ON CONFLICT)
801 *
802 * For a plain index attribute, 'name' is the name of the table column to
803 * index, and 'expr' is NULL. For an index expression, 'name' is NULL and
804 * 'expr' is the expression tree.
805 */
806 typedef struct IndexElem
807 {
808 NodeTag type;
809 char *name; /* name of attribute to index, or NULL */
810 Node *expr; /* expression to index, or NULL */
811 char *indexcolname; /* name for index column; NULL = default */
812 List *collation; /* name of collation; NIL = default */
813 List *opclass; /* name of desired opclass; NIL = default */
814 List *opclassopts; /* opclass-specific options, or NIL */
815 SortByDir ordering; /* ASC/DESC/default */
816 SortByNulls nulls_ordering; /* FIRST/LAST/default */
817 } IndexElem;
818
819 /*
820 * DefElem - a generic "name = value" option definition
821 *
822 * In some contexts the name can be qualified. Also, certain SQL commands
823 * allow a SET/ADD/DROP action to be attached to option settings, so it's
824 * convenient to carry a field for that too. (Note: currently, it is our
825 * practice that the grammar allows namespace and action only in statements
826 * where they are relevant; C code can just ignore those fields in other
827 * statements.)
828 */
829 typedef enum DefElemAction
830 {
831 DEFELEM_UNSPEC, /* no action given */
832 DEFELEM_SET,
833 DEFELEM_ADD,
834 DEFELEM_DROP,
835 } DefElemAction;
836
837 typedef struct DefElem
838 {
839 NodeTag type;
840 char *defnamespace; /* NULL if unqualified name */
841 char *defname;
842 Node *arg; /* typically Integer, Float, String, or
843 * TypeName */
844 DefElemAction defaction; /* unspecified action, or SET/ADD/DROP */
845 ParseLoc location; /* token location, or -1 if unknown */
846 } DefElem;
847
848 /*
849 * LockingClause - raw representation of FOR [NO KEY] UPDATE/[KEY] SHARE
850 * options
851 *
852 * Note: lockedRels == NIL means "all relations in query". Otherwise it
853 * is a list of RangeVar nodes. (We use RangeVar mainly because it carries
854 * a location field --- currently, parse analysis insists on unqualified
855 * names in LockingClause.)
856 */
857 typedef struct LockingClause
858 {
859 NodeTag type;
860 List *lockedRels; /* FOR [KEY] UPDATE/SHARE relations */
861 LockClauseStrength strength;
862 LockWaitPolicy waitPolicy; /* NOWAIT and SKIP LOCKED */
863 } LockingClause;
864
865 /*
866 * XMLSERIALIZE (in raw parse tree only)
867 */
868 typedef struct XmlSerialize
869 {
870 NodeTag type;
871 XmlOptionType xmloption; /* DOCUMENT or CONTENT */
872 Node *expr;
873 TypeName *typeName;
874 bool indent; /* [NO] INDENT */
875 ParseLoc location; /* token location, or -1 if unknown */
876 } XmlSerialize;
877
878 /* Partitioning related definitions */
879
880 /*
881 * PartitionElem - parse-time representation of a single partition key
882 *
883 * expr can be either a raw expression tree or a parse-analyzed expression.
884 * We don't store these on-disk, though.
885 */
886 typedef struct PartitionElem
887 {
888 NodeTag type;
889 char *name; /* name of column to partition on, or NULL */
890 Node *expr; /* expression to partition on, or NULL */
891 List *collation; /* name of collation; NIL = default */
892 List *opclass; /* name of desired opclass; NIL = default */
893 ParseLoc location; /* token location, or -1 if unknown */
894 } PartitionElem;
895
896 typedef enum PartitionStrategy
897 {
898 PARTITION_STRATEGY_LIST = 'l',
899 PARTITION_STRATEGY_RANGE = 'r',
900 PARTITION_STRATEGY_HASH = 'h',
901 } PartitionStrategy;
902
903 /*
904 * PartitionSpec - parse-time representation of a partition key specification
905 *
906 * This represents the key space we will be partitioning on.
907 */
908 typedef struct PartitionSpec
909 {
910 NodeTag type;
911 PartitionStrategy strategy;
912 List *partParams; /* List of PartitionElems */
913 ParseLoc location; /* token location, or -1 if unknown */
914 } PartitionSpec;
915
916 /*
917 * PartitionBoundSpec - a partition bound specification
918 *
919 * This represents the portion of the partition key space assigned to a
920 * particular partition. These are stored on disk in pg_class.relpartbound.
921 */
922 struct PartitionBoundSpec
923 {
924 NodeTag type;
925
926 char strategy; /* see PARTITION_STRATEGY codes above */
927 bool is_default; /* is it a default partition bound? */
928
929 /* Partitioning info for HASH strategy: */
930 int modulus;
931 int remainder;
932
933 /* Partitioning info for LIST strategy: */
934 List *listdatums; /* List of Consts (or A_Consts in raw tree) */
935
936 /* Partitioning info for RANGE strategy: */
937 List *lowerdatums; /* List of PartitionRangeDatums */
938 List *upperdatums; /* List of PartitionRangeDatums */
939
940 ParseLoc location; /* token location, or -1 if unknown */
941 };
942
943 /*
944 * PartitionRangeDatum - one of the values in a range partition bound
945 *
946 * This can be MINVALUE, MAXVALUE or a specific bounded value.
947 */
948 typedef enum PartitionRangeDatumKind
949 {
950 PARTITION_RANGE_DATUM_MINVALUE = -1, /* less than any other value */
951 PARTITION_RANGE_DATUM_VALUE = 0, /* a specific (bounded) value */
952 PARTITION_RANGE_DATUM_MAXVALUE = 1, /* greater than any other value */
953 } PartitionRangeDatumKind;
954
955 typedef struct PartitionRangeDatum
956 {
957 NodeTag type;
958
959 PartitionRangeDatumKind kind;
960 Node *value; /* Const (or A_Const in raw tree), if kind is
961 * PARTITION_RANGE_DATUM_VALUE, else NULL */
962
963 ParseLoc location; /* token location, or -1 if unknown */
964 } PartitionRangeDatum;
965
966 /*
967 * PartitionCmd - info for ALTER TABLE/INDEX ATTACH/DETACH PARTITION commands
968 */
969 typedef struct PartitionCmd
970 {
971 NodeTag type;
972 RangeVar *name; /* name of partition to attach/detach */
973 PartitionBoundSpec *bound; /* FOR VALUES, if attaching */
974 bool concurrent;
975 } PartitionCmd;
976
977 /****************************************************************************
978 * Nodes for a Query tree
979 ****************************************************************************/
980
981 /*--------------------
982 * RangeTblEntry -
983 * A range table is a List of RangeTblEntry nodes.
984 *
985 * A range table entry may represent a plain relation, a sub-select in
986 * FROM, or the result of a JOIN clause. (Only explicit JOIN syntax
987 * produces an RTE, not the implicit join resulting from multiple FROM
988 * items. This is because we only need the RTE to deal with SQL features
989 * like outer joins and join-output-column aliasing.) Other special
990 * RTE types also exist, as indicated by RTEKind.
991 *
992 * Note that we consider RTE_RELATION to cover anything that has a pg_class
993 * entry. relkind distinguishes the sub-cases.
994 *
995 * alias is an Alias node representing the AS alias-clause attached to the
996 * FROM expression, or NULL if no clause.
997 *
998 * eref is the table reference name and column reference names (either
999 * real or aliases). Note that system columns (OID etc) are not included
1000 * in the column list.
1001 * eref->aliasname is required to be present, and should generally be used
1002 * to identify the RTE for error messages etc.
1003 *
1004 * In RELATION RTEs, the colnames in both alias and eref are indexed by
1005 * physical attribute number; this means there must be colname entries for
1006 * dropped columns. When building an RTE we insert empty strings ("") for
1007 * dropped columns. Note however that a stored rule may have nonempty
1008 * colnames for columns dropped since the rule was created (and for that
1009 * matter the colnames might be out of date due to column renamings).
1010 * The same comments apply to FUNCTION RTEs when a function's return type
1011 * is a named composite type.
1012 *
1013 * In JOIN RTEs, the colnames in both alias and eref are one-to-one with
1014 * joinaliasvars entries. A JOIN RTE will omit columns of its inputs when
1015 * those columns are known to be dropped at parse time. Again, however,
1016 * a stored rule might contain entries for columns dropped since the rule
1017 * was created. (This is only possible for columns not actually referenced
1018 * in the rule.) When loading a stored rule, we replace the joinaliasvars
1019 * items for any such columns with null pointers. (We can't simply delete
1020 * them from the joinaliasvars list, because that would affect the attnums
1021 * of Vars referencing the rest of the list.)
1022 *
1023 * inFromCl marks those range variables that are listed in the FROM clause.
1024 * It's false for RTEs that are added to a query behind the scenes, such
1025 * as the NEW and OLD variables for a rule, or the subqueries of a UNION.
1026 * This flag is not used during parsing (except in transformLockingClause,
1027 * q.v.); the parser now uses a separate "namespace" data structure to
1028 * control visibility. But it is needed by ruleutils.c to determine
1029 * whether RTEs should be shown in decompiled queries.
1030 *
1031 * securityQuals is a list of security barrier quals (boolean expressions),
1032 * to be tested in the listed order before returning a row from the
1033 * relation. It is always NIL in parser output. Entries are added by the
1034 * rewriter to implement security-barrier views and/or row-level security.
1035 * Note that the planner turns each boolean expression into an implicitly
1036 * AND'ed sublist, as is its usual habit with qualification expressions.
1037 *--------------------
1038 */
1039 typedef enum RTEKind
1040 {
1041 RTE_RELATION, /* ordinary relation reference */
1042 RTE_SUBQUERY, /* subquery in FROM */
1043 RTE_JOIN, /* join */
1044 RTE_FUNCTION, /* function in FROM */
1045 RTE_TABLEFUNC, /* TableFunc(.., column list) */
1046 RTE_VALUES, /* VALUES (<exprlist>), (<exprlist>), ... */
1047 RTE_CTE, /* common table expr (WITH list element) */
1048 RTE_NAMEDTUPLESTORE, /* tuplestore, e.g. for AFTER triggers */
1049 RTE_RESULT, /* RTE represents an empty FROM clause; such
1050 * RTEs are added by the planner, they're not
1051 * present during parsing or rewriting */
1052 RTE_GROUP, /* the grouping step */
1053 } RTEKind;
1054
1055 typedef struct RangeTblEntry
1056 {
1057 pg_node_attr(custom_read_write)
1058
1059 NodeTag type;
1060
1061 /*
1062 * Fields valid in all RTEs:
1063 *
1064 * put alias + eref first to make dump more legible
1065 */
1066 /* user-written alias clause, if any */
1067 Alias *alias pg_node_attr(query_jumble_ignore);
1068
1069 /*
1070 * Expanded reference names. This uses a custom query jumble function so
1071 * that the table name is included in the computation, but not its list of
1072 * columns.
1073 */
1074 Alias *eref pg_node_attr(custom_query_jumble);
1075
1076 RTEKind rtekind; /* see above */
1077
1078 /*
1079 * Fields valid for a plain relation RTE (else zero):
1080 *
1081 * inh is true for relation references that should be expanded to include
1082 * inheritance children, if the rel has any. In the parser, this will
1083 * only be true for RTE_RELATION entries. The planner also uses this
1084 * field to mark RTE_SUBQUERY entries that contain UNION ALL queries that
1085 * it has flattened into pulled-up subqueries (creating a structure much
1086 * like the effects of inheritance).
1087 *
1088 * rellockmode is really LOCKMODE, but it's declared int to avoid having
1089 * to include lock-related headers here. It must be RowExclusiveLock if
1090 * the RTE is an INSERT/UPDATE/DELETE/MERGE target, else RowShareLock if
1091 * the RTE is a SELECT FOR UPDATE/FOR SHARE target, else AccessShareLock.
1092 *
1093 * Note: in some cases, rule expansion may result in RTEs that are marked
1094 * with RowExclusiveLock even though they are not the target of the
1095 * current query; this happens if a DO ALSO rule simply scans the original
1096 * target table. We leave such RTEs with their original lockmode so as to
1097 * avoid getting an additional, lesser lock.
1098 *
1099 * perminfoindex is 1-based index of the RTEPermissionInfo belonging to
1100 * this RTE in the containing struct's list of same; 0 if permissions need
1101 * not be checked for this RTE.
1102 *
1103 * As a special case, relid, relkind, rellockmode, and perminfoindex can
1104 * also be set (nonzero) in an RTE_SUBQUERY RTE. This occurs when we
1105 * convert an RTE_RELATION RTE naming a view into an RTE_SUBQUERY
1106 * containing the view's query. We still need to perform run-time locking
1107 * and permission checks on the view, even though it's not directly used
1108 * in the query anymore, and the most expedient way to do that is to
1109 * retain these fields from the old state of the RTE.
1110 *
1111 * As a special case, RTE_NAMEDTUPLESTORE can also set relid to indicate
1112 * that the tuple format of the tuplestore is the same as the referenced
1113 * relation. This allows plans referencing AFTER trigger transition
1114 * tables to be invalidated if the underlying table is altered.
1115 */
1116 /* OID of the relation */
1117 Oid relid pg_node_attr(query_jumble_ignore);
1118 /* inheritance requested? */
1119 bool inh;
1120 /* relation kind (see pg_class.relkind) */
1121 char relkind pg_node_attr(query_jumble_ignore);
1122 /* lock level that query requires on the rel */
1123 int rellockmode pg_node_attr(query_jumble_ignore);
1124 /* index of RTEPermissionInfo entry, or 0 */
1125 Index perminfoindex pg_node_attr(query_jumble_ignore);
1126 /* sampling info, or NULL */
1127 struct TableSampleClause *tablesample;
1128
1129 /*
1130 * Fields valid for a subquery RTE (else NULL):
1131 */
1132 /* the sub-query */
1133 Query *subquery;
1134 /* is from security_barrier view? */
1135 bool security_barrier pg_node_attr(query_jumble_ignore);
1136
1137 /*
1138 * Fields valid for a join RTE (else NULL/zero):
1139 *
1140 * joinaliasvars is a list of (usually) Vars corresponding to the columns
1141 * of the join result. An alias Var referencing column K of the join
1142 * result can be replaced by the K'th element of joinaliasvars --- but to
1143 * simplify the task of reverse-listing aliases correctly, we do not do
1144 * that until planning time. In detail: an element of joinaliasvars can
1145 * be a Var of one of the join's input relations, or such a Var with an
1146 * implicit coercion to the join's output column type, or a COALESCE
1147 * expression containing the two input column Vars (possibly coerced).
1148 * Elements beyond the first joinmergedcols entries are always just Vars,
1149 * and are never referenced from elsewhere in the query (that is, join
1150 * alias Vars are generated only for merged columns). We keep these
1151 * entries only because they're needed in expandRTE() and similar code.
1152 *
1153 * Vars appearing within joinaliasvars are marked with varnullingrels sets
1154 * that describe the nulling effects of this join and lower ones. This is
1155 * essential for FULL JOIN cases, because the COALESCE expression only
1156 * describes the semantics correctly if its inputs have been nulled by the
1157 * join. For other cases, it allows expandRTE() to generate a valid
1158 * representation of the join's output without consulting additional
1159 * parser state.
1160 *
1161 * Within a Query loaded from a stored rule, it is possible for non-merged
1162 * joinaliasvars items to be null pointers, which are placeholders for
1163 * (necessarily unreferenced) columns dropped since the rule was made.
1164 * Also, once planning begins, joinaliasvars items can be almost anything,
1165 * as a result of subquery-flattening substitutions.
1166 *
1167 * joinleftcols is an integer list of physical column numbers of the left
1168 * join input rel that are included in the join; likewise joinrighttcols
1169 * for the right join input rel. (Which rels those are can be determined
1170 * from the associated JoinExpr.) If the join is USING/NATURAL, then the
1171 * first joinmergedcols entries in each list identify the merged columns.
1172 * The merged columns come first in the join output, then remaining
1173 * columns of the left input, then remaining columns of the right.
1174 *
1175 * Note that input columns could have been dropped after creation of a
1176 * stored rule, if they are not referenced in the query (in particular,
1177 * merged columns could not be dropped); this is not accounted for in
1178 * joinleftcols/joinrighttcols.
1179 */
1180 JoinType jointype;
1181 /* number of merged (JOIN USING) columns */
1182 int joinmergedcols pg_node_attr(query_jumble_ignore);
1183 /* list of alias-var expansions */
1184 List *joinaliasvars pg_node_attr(query_jumble_ignore);
1185 /* left-side input column numbers */
1186 List *joinleftcols pg_node_attr(query_jumble_ignore);
1187 /* right-side input column numbers */
1188 List *joinrightcols pg_node_attr(query_jumble_ignore);
1189
1190 /*
1191 * join_using_alias is an alias clause attached directly to JOIN/USING. It
1192 * is different from the alias field (below) in that it does not hide the
1193 * range variables of the tables being joined.
1194 */
1195 Alias *join_using_alias pg_node_attr(query_jumble_ignore);
1196
1197 /*
1198 * Fields valid for a function RTE (else NIL/zero):
1199 *
1200 * When funcordinality is true, the eref->colnames list includes an alias
1201 * for the ordinality column. The ordinality column is otherwise
1202 * implicit, and must be accounted for "by hand" in places such as
1203 * expandRTE().
1204 */
1205 /* list of RangeTblFunction nodes */
1206 List *functions;
1207 /* is this called WITH ORDINALITY? */
1208 bool funcordinality;
1209
1210 /*
1211 * Fields valid for a TableFunc RTE (else NULL):
1212 */
1213 TableFunc *tablefunc;
1214
1215 /*
1216 * Fields valid for a values RTE (else NIL):
1217 */
1218 /* list of expression lists */
1219 List *values_lists;
1220
1221 /*
1222 * Fields valid for a CTE RTE (else NULL/zero):
1223 */
1224 /* name of the WITH list item */
1225 char *ctename;
1226 /* number of query levels up */
1227 Index ctelevelsup;
1228 /* is this a recursive self-reference? */
1229 bool self_reference pg_node_attr(query_jumble_ignore);
1230
1231 /*
1232 * Fields valid for CTE, VALUES, ENR, and TableFunc RTEs (else NIL):
1233 *
1234 * We need these for CTE RTEs so that the types of self-referential
1235 * columns are well-defined. For VALUES RTEs, storing these explicitly
1236 * saves having to re-determine the info by scanning the values_lists. For
1237 * ENRs, we store the types explicitly here (we could get the information
1238 * from the catalogs if 'relid' was supplied, but we'd still need these
1239 * for TupleDesc-based ENRs, so we might as well always store the type
1240 * info here). For TableFuncs, these fields are redundant with data in
1241 * the TableFunc node, but keeping them here allows some code sharing with
1242 * the other cases.
1243 *
1244 * For ENRs only, we have to consider the possibility of dropped columns.
1245 * A dropped column is included in these lists, but it will have zeroes in
1246 * all three lists (as well as an empty-string entry in eref). Testing
1247 * for zero coltype is the standard way to detect a dropped column.
1248 */
1249 /* OID list of column type OIDs */
1250 List *coltypes pg_node_attr(query_jumble_ignore);
1251 /* integer list of column typmods */
1252 List *coltypmods pg_node_attr(query_jumble_ignore);
1253 /* OID list of column collation OIDs */
1254 List *colcollations pg_node_attr(query_jumble_ignore);
1255
1256 /*
1257 * Fields valid for ENR RTEs (else NULL/zero):
1258 */
1259 /* name of ephemeral named relation */
1260 char *enrname;
1261 /* estimated or actual from caller */
1262 Cardinality enrtuples pg_node_attr(query_jumble_ignore);
1263
1264 /*
1265 * Fields valid for a GROUP RTE (else NIL):
1266 */
1267 /* list of grouping expressions */
1268 List *groupexprs;
1269
1270 /*
1271 * Fields valid in all RTEs:
1272 */
1273 /* was LATERAL specified? */
1274 bool lateral pg_node_attr(query_jumble_ignore);
1275 /* present in FROM clause? */
1276 bool inFromCl pg_node_attr(query_jumble_ignore);
1277 /* security barrier quals to apply, if any */
1278 List *securityQuals pg_node_attr(query_jumble_ignore);
1279 } RangeTblEntry;
1280
1281 /*
1282 * RTEPermissionInfo
1283 * Per-relation information for permission checking. Added to the Query
1284 * node by the parser when adding the corresponding RTE to the query
1285 * range table and subsequently editorialized on by the rewriter if
1286 * needed after rule expansion.
1287 *
1288 * Only the relations directly mentioned in the query are checked for
1289 * access permissions by the core executor, so only their RTEPermissionInfos
1290 * are present in the Query. However, extensions may want to check inheritance
1291 * children too, depending on the value of rte->inh, so it's copied in 'inh'
1292 * for their perusal.
1293 *
1294 * requiredPerms and checkAsUser specify run-time access permissions checks
1295 * to be performed at query startup. The user must have *all* of the
1296 * permissions that are OR'd together in requiredPerms (never 0!). If
1297 * checkAsUser is not zero, then do the permissions checks using the access
1298 * rights of that user, not the current effective user ID. (This allows rules
1299 * to act as setuid gateways.)
1300 *
1301 * For SELECT/INSERT/UPDATE permissions, if the user doesn't have table-wide
1302 * permissions then it is sufficient to have the permissions on all columns
1303 * identified in selectedCols (for SELECT) and/or insertedCols and/or
1304 * updatedCols (INSERT with ON CONFLICT DO UPDATE may have all 3).
1305 * selectedCols, insertedCols and updatedCols are bitmapsets, which cannot have
1306 * negative integer members, so we subtract FirstLowInvalidHeapAttributeNumber
1307 * from column numbers before storing them in these fields. A whole-row Var
1308 * reference is represented by setting the bit for InvalidAttrNumber.
1309 *
1310 * updatedCols is also used in some other places, for example, to determine
1311 * which triggers to fire and in FDWs to know which changed columns they need
1312 * to ship off.
1313 */
1314 typedef struct RTEPermissionInfo
1315 {
1316 NodeTag type;
1317
1318 Oid relid; /* relation OID */
1319 bool inh; /* separately check inheritance children? */
1320 AclMode requiredPerms; /* bitmask of required access permissions */
1321 Oid checkAsUser; /* if valid, check access as this role */
1322 Bitmapset *selectedCols; /* columns needing SELECT permission */
1323 Bitmapset *insertedCols; /* columns needing INSERT permission */
1324 Bitmapset *updatedCols; /* columns needing UPDATE permission */
1325 } RTEPermissionInfo;
1326
1327 /*
1328 * RangeTblFunction -
1329 * RangeTblEntry subsidiary data for one function in a FUNCTION RTE.
1330 *
1331 * If the function had a column definition list (required for an
1332 * otherwise-unspecified RECORD result), funccolnames lists the names given
1333 * in the definition list, funccoltypes lists their declared column types,
1334 * funccoltypmods lists their typmods, funccolcollations their collations.
1335 * Otherwise, those fields are NIL.
1336 *
1337 * Notice we don't attempt to store info about the results of functions
1338 * returning named composite types, because those can change from time to
1339 * time. We do however remember how many columns we thought the type had
1340 * (including dropped columns!), so that we can successfully ignore any
1341 * columns added after the query was parsed.
1342 *
1343 * The query jumbling only needs to track the function expression.
1344 */
1345 typedef struct RangeTblFunction
1346 {
1347 NodeTag type;
1348
1349 Node *funcexpr; /* expression tree for func call */
1350 /* number of columns it contributes to RTE */
1351 int funccolcount pg_node_attr(query_jumble_ignore);
1352 /* These fields record the contents of a column definition list, if any: */
1353 /* column names (list of String) */
1354 List *funccolnames pg_node_attr(query_jumble_ignore);
1355 /* OID list of column type OIDs */
1356 List *funccoltypes pg_node_attr(query_jumble_ignore);
1357 /* integer list of column typmods */
1358 List *funccoltypmods pg_node_attr(query_jumble_ignore);
1359 /* OID list of column collation OIDs */
1360 List *funccolcollations pg_node_attr(query_jumble_ignore);
1361
1362 /* This is set during planning for use by the executor: */
1363 /* PARAM_EXEC Param IDs affecting this func */
1364 Bitmapset *funcparams pg_node_attr(query_jumble_ignore);
1365 } RangeTblFunction;
1366
1367 /*
1368 * TableSampleClause - TABLESAMPLE appearing in a transformed FROM clause
1369 *
1370 * Unlike RangeTableSample, this is a subnode of the relevant RangeTblEntry.
1371 */
1372 typedef struct TableSampleClause
1373 {
1374 NodeTag type;
1375 Oid tsmhandler; /* OID of the tablesample handler function */
1376 List *args; /* tablesample argument expression(s) */
1377 Expr *repeatable; /* REPEATABLE expression, or NULL if none */
1378 } TableSampleClause;
1379
1380 /*
1381 * WithCheckOption -
1382 * representation of WITH CHECK OPTION checks to be applied to new tuples
1383 * when inserting/updating an auto-updatable view, or RLS WITH CHECK
1384 * policies to be applied when inserting/updating a relation with RLS.
1385 */
1386 typedef enum WCOKind
1387 {
1388 WCO_VIEW_CHECK, /* WCO on an auto-updatable view */
1389 WCO_RLS_INSERT_CHECK, /* RLS INSERT WITH CHECK policy */
1390 WCO_RLS_UPDATE_CHECK, /* RLS UPDATE WITH CHECK policy */
1391 WCO_RLS_CONFLICT_CHECK, /* RLS ON CONFLICT DO UPDATE USING policy */
1392 WCO_RLS_MERGE_UPDATE_CHECK, /* RLS MERGE UPDATE USING policy */
1393 WCO_RLS_MERGE_DELETE_CHECK, /* RLS MERGE DELETE USING policy */
1394 } WCOKind;
1395
1396 typedef struct WithCheckOption
1397 {
1398 NodeTag type;
1399 WCOKind kind; /* kind of WCO */
1400 char *relname; /* name of relation that specified the WCO */
1401 char *polname; /* name of RLS policy being checked */
1402 Node *qual; /* constraint qual to check */
1403 bool cascaded; /* true for a cascaded WCO on a view */
1404 } WithCheckOption;
1405
1406 /*
1407 * SortGroupClause -
1408 * representation of ORDER BY, GROUP BY, PARTITION BY,
1409 * DISTINCT, DISTINCT ON items
1410 *
1411 * You might think that ORDER BY is only interested in defining ordering,
1412 * and GROUP/DISTINCT are only interested in defining equality. However,
1413 * one way to implement grouping is to sort and then apply a "uniq"-like
1414 * filter. So it's also interesting to keep track of possible sort operators
1415 * for GROUP/DISTINCT, and in particular to try to sort for the grouping
1416 * in a way that will also yield a requested ORDER BY ordering. So we need
1417 * to be able to compare ORDER BY and GROUP/DISTINCT lists, which motivates
1418 * the decision to give them the same representation.
1419 *
1420 * tleSortGroupRef must match ressortgroupref of exactly one entry of the
1421 * query's targetlist; that is the expression to be sorted or grouped by.
1422 * eqop is the OID of the equality operator.
1423 * sortop is the OID of the ordering operator (a "<" or ">" operator),
1424 * or InvalidOid if not available.
1425 * nulls_first means about what you'd expect. If sortop is InvalidOid
1426 * then nulls_first is meaningless and should be set to false.
1427 * hashable is true if eqop is hashable (note this condition also depends
1428 * on the datatype of the input expression).
1429 *
1430 * In an ORDER BY item, all fields must be valid. (The eqop isn't essential
1431 * here, but it's cheap to get it along with the sortop, and requiring it
1432 * to be valid eases comparisons to grouping items.) Note that this isn't
1433 * actually enough information to determine an ordering: if the sortop is
1434 * collation-sensitive, a collation OID is needed too. We don't store the
1435 * collation in SortGroupClause because it's not available at the time the
1436 * parser builds the SortGroupClause; instead, consult the exposed collation
1437 * of the referenced targetlist expression to find out what it is.
1438 *
1439 * In a grouping item, eqop must be valid. If the eqop is a btree equality
1440 * operator, then sortop should be set to a compatible ordering operator.
1441 * We prefer to set eqop/sortop/nulls_first to match any ORDER BY item that
1442 * the query presents for the same tlist item. If there is none, we just
1443 * use the default ordering op for the datatype.
1444 *
1445 * If the tlist item's type has a hash opclass but no btree opclass, then
1446 * we will set eqop to the hash equality operator, sortop to InvalidOid,
1447 * and nulls_first to false. A grouping item of this kind can only be
1448 * implemented by hashing, and of course it'll never match an ORDER BY item.
1449 *
1450 * The hashable flag is provided since we generally have the requisite
1451 * information readily available when the SortGroupClause is constructed,
1452 * and it's relatively expensive to get it again later. Note there is no
1453 * need for a "sortable" flag since OidIsValid(sortop) serves the purpose.
1454 *
1455 * A query might have both ORDER BY and DISTINCT (or DISTINCT ON) clauses.
1456 * In SELECT DISTINCT, the distinctClause list is as long or longer than the
1457 * sortClause list, while in SELECT DISTINCT ON it's typically shorter.
1458 * The two lists must match up to the end of the shorter one --- the parser
1459 * rearranges the distinctClause if necessary to make this true. (This
1460 * restriction ensures that only one sort step is needed to both satisfy the
1461 * ORDER BY and set up for the Unique step. This is semantically necessary
1462 * for DISTINCT ON, and presents no real drawback for DISTINCT.)
1463 */
1464 typedef struct SortGroupClause
1465 {
1466 NodeTag type;
1467 Index tleSortGroupRef; /* reference into targetlist */
1468 Oid eqop; /* the equality operator ('=' op) */
1469 Oid sortop; /* the ordering operator ('<' op), or 0 */
1470 bool reverse_sort; /* is sortop a "greater than" operator? */
1471 bool nulls_first; /* do NULLs come before normal values? */
1472 /* can eqop be implemented by hashing? */
1473 bool hashable pg_node_attr(query_jumble_ignore);
1474 } SortGroupClause;
1475
1476 /*
1477 * GroupingSet -
1478 * representation of CUBE, ROLLUP and GROUPING SETS clauses
1479 *
1480 * In a Query with grouping sets, the groupClause contains a flat list of
1481 * SortGroupClause nodes for each distinct expression used. The actual
1482 * structure of the GROUP BY clause is given by the groupingSets tree.
1483 *
1484 * In the raw parser output, GroupingSet nodes (of all types except SIMPLE
1485 * which is not used) are potentially mixed in with the expressions in the
1486 * groupClause of the SelectStmt. (An expression can't contain a GroupingSet,
1487 * but a list may mix GroupingSet and expression nodes.) At this stage, the
1488 * content of each node is a list of expressions, some of which may be RowExprs
1489 * which represent sublists rather than actual row constructors, and nested
1490 * GroupingSet nodes where legal in the grammar. The structure directly
1491 * reflects the query syntax.
1492 *
1493 * In parse analysis, the transformed expressions are used to build the tlist
1494 * and groupClause list (of SortGroupClause nodes), and the groupingSets tree
1495 * is eventually reduced to a fixed format:
1496 *
1497 * EMPTY nodes represent (), and obviously have no content
1498 *
1499 * SIMPLE nodes represent a list of one or more expressions to be treated as an
1500 * atom by the enclosing structure; the content is an integer list of
1501 * ressortgroupref values (see SortGroupClause)
1502 *
1503 * CUBE and ROLLUP nodes contain a list of one or more SIMPLE nodes.
1504 *
1505 * SETS nodes contain a list of EMPTY, SIMPLE, CUBE or ROLLUP nodes, but after
1506 * parse analysis they cannot contain more SETS nodes; enough of the syntactic
1507 * transforms of the spec have been applied that we no longer have arbitrarily
1508 * deep nesting (though we still preserve the use of cube/rollup).
1509 *
1510 * Note that if the groupingSets tree contains no SIMPLE nodes (only EMPTY
1511 * nodes at the leaves), then the groupClause will be empty, but this is still
1512 * an aggregation query (similar to using aggs or HAVING without GROUP BY).
1513 *
1514 * As an example, the following clause:
1515 *
1516 * GROUP BY GROUPING SETS ((a,b), CUBE(c,(d,e)))
1517 *
1518 * looks like this after raw parsing:
1519 *
1520 * SETS( RowExpr(a,b) , CUBE( c, RowExpr(d,e) ) )
1521 *
1522 * and parse analysis converts it to:
1523 *
1524 * SETS( SIMPLE(1,2), CUBE( SIMPLE(3), SIMPLE(4,5) ) )
1525 */
1526 typedef enum GroupingSetKind
1527 {
1528 GROUPING_SET_EMPTY,
1529 GROUPING_SET_SIMPLE,
1530 GROUPING_SET_ROLLUP,
1531 GROUPING_SET_CUBE,
1532 GROUPING_SET_SETS,
1533 } GroupingSetKind;
1534
1535 typedef struct GroupingSet
1536 {
1537 NodeTag type;
1538 GroupingSetKind kind pg_node_attr(query_jumble_ignore);
1539 List *content;
1540 ParseLoc location;
1541 } GroupingSet;
1542
1543 /*
1544 * WindowClause -
1545 * transformed representation of WINDOW and OVER clauses
1546 *
1547 * A parsed Query's windowClause list contains these structs. "name" is set
1548 * if the clause originally came from WINDOW, and is NULL if it originally
1549 * was an OVER clause (but note that we collapse out duplicate OVERs).
1550 * partitionClause and orderClause are lists of SortGroupClause structs.
1551 * partitionClause is sanitized by the query planner to remove any columns or
1552 * expressions belonging to redundant PathKeys.
1553 * If we have RANGE with offset PRECEDING/FOLLOWING, the semantics of that are
1554 * specified by startInRangeFunc/inRangeColl/inRangeAsc/inRangeNullsFirst
1555 * for the start offset, or endInRangeFunc/inRange* for the end offset.
1556 * winref is an ID number referenced by WindowFunc nodes; it must be unique
1557 * among the members of a Query's windowClause list.
1558 * When refname isn't null, the partitionClause is always copied from there;
1559 * the orderClause might or might not be copied (see copiedOrder); the framing
1560 * options are never copied, per spec.
1561 *
1562 * The information relevant for the query jumbling is the partition clause
1563 * type and its bounds.
1564 */
1565 typedef struct WindowClause
1566 {
1567 NodeTag type;
1568 /* window name (NULL in an OVER clause) */
1569 char *name pg_node_attr(query_jumble_ignore);
1570 /* referenced window name, if any */
1571 char *refname pg_node_attr(query_jumble_ignore);
1572 List *partitionClause; /* PARTITION BY list */
1573 /* ORDER BY list */
1574 List *orderClause;
1575 int frameOptions; /* frame_clause options, see WindowDef */
1576 Node *startOffset; /* expression for starting bound, if any */
1577 Node *endOffset; /* expression for ending bound, if any */
1578 /* in_range function for startOffset */
1579 Oid startInRangeFunc pg_node_attr(query_jumble_ignore);
1580 /* in_range function for endOffset */
1581 Oid endInRangeFunc pg_node_attr(query_jumble_ignore);
1582 /* collation for in_range tests */
1583 Oid inRangeColl pg_node_attr(query_jumble_ignore);
1584 /* use ASC sort order for in_range tests? */
1585 bool inRangeAsc pg_node_attr(query_jumble_ignore);
1586 /* nulls sort first for in_range tests? */
1587 bool inRangeNullsFirst pg_node_attr(query_jumble_ignore);
1588 Index winref; /* ID referenced by window functions */
1589 /* did we copy orderClause from refname? */
1590 bool copiedOrder pg_node_attr(query_jumble_ignore);
1591 } WindowClause;
1592
1593 /*
1594 * RowMarkClause -
1595 * parser output representation of FOR [KEY] UPDATE/SHARE clauses
1596 *
1597 * Query.rowMarks contains a separate RowMarkClause node for each relation
1598 * identified as a FOR [KEY] UPDATE/SHARE target. If one of these clauses
1599 * is applied to a subquery, we generate RowMarkClauses for all normal and
1600 * subquery rels in the subquery, but they are marked pushedDown = true to
1601 * distinguish them from clauses that were explicitly written at this query
1602 * level. Also, Query.hasForUpdate tells whether there were explicit FOR
1603 * UPDATE/SHARE/KEY SHARE clauses in the current query level.
1604 */
1605 typedef struct RowMarkClause
1606 {
1607 NodeTag type;
1608 Index rti; /* range table index of target relation */
1609 LockClauseStrength strength;
1610 LockWaitPolicy waitPolicy; /* NOWAIT and SKIP LOCKED */
1611 bool pushedDown; /* pushed down from higher query level? */
1612 } RowMarkClause;
1613
1614 /*
1615 * WithClause -
1616 * representation of WITH clause
1617 *
1618 * Note: WithClause does not propagate into the Query representation;
1619 * but CommonTableExpr does.
1620 */
1621 typedef struct WithClause
1622 {
1623 NodeTag type;
1624 List *ctes; /* list of CommonTableExprs */
1625 bool recursive; /* true = WITH RECURSIVE */
1626 ParseLoc location; /* token location, or -1 if unknown */
1627 } WithClause;
1628
1629 /*
1630 * InferClause -
1631 * ON CONFLICT unique index inference clause
1632 *
1633 * Note: InferClause does not propagate into the Query representation.
1634 */
1635 typedef struct InferClause
1636 {
1637 NodeTag type;
1638 List *indexElems; /* IndexElems to infer unique index */
1639 Node *whereClause; /* qualification (partial-index predicate) */
1640 char *conname; /* Constraint name, or NULL if unnamed */
1641 ParseLoc location; /* token location, or -1 if unknown */
1642 } InferClause;
1643
1644 /*
1645 * OnConflictClause -
1646 * representation of ON CONFLICT clause
1647 *
1648 * Note: OnConflictClause does not propagate into the Query representation.
1649 */
1650 typedef struct OnConflictClause
1651 {
1652 NodeTag type;
1653 OnConflictAction action; /* DO NOTHING or UPDATE? */
1654 InferClause *infer; /* Optional index inference clause */
1655 List *targetList; /* the target list (of ResTarget) */
1656 Node *whereClause; /* qualifications */
1657 ParseLoc location; /* token location, or -1 if unknown */
1658 } OnConflictClause;
1659
1660 /*
1661 * CommonTableExpr -
1662 * representation of WITH list element
1663 */
1664
1665 typedef enum CTEMaterialize
1666 {
1667 CTEMaterializeDefault, /* no option specified */
1668 CTEMaterializeAlways, /* MATERIALIZED */
1669 CTEMaterializeNever, /* NOT MATERIALIZED */
1670 } CTEMaterialize;
1671
1672 typedef struct CTESearchClause
1673 {
1674 NodeTag type;
1675 List *search_col_list;
1676 bool search_breadth_first;
1677 char *search_seq_column;
1678 ParseLoc location;
1679 } CTESearchClause;
1680
1681 typedef struct CTECycleClause
1682 {
1683 NodeTag type;
1684 List *cycle_col_list;
1685 char *cycle_mark_column;
1686 Node *cycle_mark_value;
1687 Node *cycle_mark_default;
1688 char *cycle_path_column;
1689 ParseLoc location;
1690 /* These fields are set during parse analysis: */
1691 Oid cycle_mark_type; /* common type of _value and _default */
1692 int cycle_mark_typmod;
1693 Oid cycle_mark_collation;
1694 Oid cycle_mark_neop; /* <> operator for type */
1695 } CTECycleClause;
1696
1697 typedef struct CommonTableExpr
1698 {
1699 NodeTag type;
1700
1701 /*
1702 * Query name (never qualified). The string name is included in the query
1703 * jumbling because RTE_CTE RTEs need it.
1704 */
1705 char *ctename;
1706 /* optional list of column names */
1707 List *aliascolnames pg_node_attr(query_jumble_ignore);
1708 CTEMaterialize ctematerialized; /* is this an optimization fence? */
1709 /* SelectStmt/InsertStmt/etc before parse analysis, Query afterwards: */
1710 Node *ctequery; /* the CTE's subquery */
1711 CTESearchClause *search_clause pg_node_attr(query_jumble_ignore);
1712 CTECycleClause *cycle_clause pg_node_attr(query_jumble_ignore);
1713 ParseLoc location; /* token location, or -1 if unknown */
1714 /* These fields are set during parse analysis: */
1715 /* is this CTE actually recursive? */
1716 bool cterecursive pg_node_attr(query_jumble_ignore);
1717
1718 /*
1719 * Number of RTEs referencing this CTE (excluding internal
1720 * self-references), irrelevant for query jumbling.
1721 */
1722 int cterefcount pg_node_attr(query_jumble_ignore);
1723 /* list of output column names */
1724 List *ctecolnames pg_node_attr(query_jumble_ignore);
1725 /* OID list of output column type OIDs */
1726 List *ctecoltypes pg_node_attr(query_jumble_ignore);
1727 /* integer list of output column typmods */
1728 List *ctecoltypmods pg_node_attr(query_jumble_ignore);
1729 /* OID list of column collation OIDs */
1730 List *ctecolcollations pg_node_attr(query_jumble_ignore);
1731 } CommonTableExpr;
1732
1733 /* Convenience macro to get the output tlist of a CTE's query */
1734 #define GetCTETargetList(cte) \
1735 (AssertMacro(IsA((cte)->ctequery, Query)), \
1736 ((Query *) (cte)->ctequery)->commandType == CMD_SELECT ? \
1737 ((Query *) (cte)->ctequery)->targetList : \
1738 ((Query *) (cte)->ctequery)->returningList)
1739
1740 /*
1741 * MergeWhenClause -
1742 * raw parser representation of a WHEN clause in a MERGE statement
1743 *
1744 * This is transformed into MergeAction by parse analysis
1745 */
1746 typedef struct MergeWhenClause
1747 {
1748 NodeTag type;
1749 MergeMatchKind matchKind; /* MATCHED/NOT MATCHED BY SOURCE/TARGET */
1750 CmdType commandType; /* INSERT/UPDATE/DELETE/DO NOTHING */
1751 OverridingKind override; /* OVERRIDING clause */
1752 Node *condition; /* WHEN conditions (raw parser) */
1753 List *targetList; /* INSERT/UPDATE targetlist */
1754 /* the following members are only used in INSERT actions */
1755 List *values; /* VALUES to INSERT, or NULL */
1756 } MergeWhenClause;
1757
1758 /*
1759 * ReturningOptionKind -
1760 * Possible kinds of option in RETURNING WITH(...) list
1761 *
1762 * Currently, this is used only for specifying OLD/NEW aliases.
1763 */
1764 typedef enum ReturningOptionKind
1765 {
1766 RETURNING_OPTION_OLD, /* specify alias for OLD in RETURNING */
1767 RETURNING_OPTION_NEW, /* specify alias for NEW in RETURNING */
1768 } ReturningOptionKind;
1769
1770 /*
1771 * ReturningOption -
1772 * An individual option in the RETURNING WITH(...) list
1773 */
1774 typedef struct ReturningOption
1775 {
1776 NodeTag type;
1777 ReturningOptionKind option; /* specified option */
1778 char *value; /* option's value */
1779 ParseLoc location; /* token location, or -1 if unknown */
1780 } ReturningOption;
1781
1782 /*
1783 * ReturningClause -
1784 * List of RETURNING expressions, together with any WITH(...) options
1785 */
1786 typedef struct ReturningClause
1787 {
1788 NodeTag type;
1789 List *options; /* list of ReturningOption elements */
1790 List *exprs; /* list of expressions to return */
1791 } ReturningClause;
1792
1793 /*
1794 * TriggerTransition -
1795 * representation of transition row or table naming clause
1796 *
1797 * Only transition tables are initially supported in the syntax, and only for
1798 * AFTER triggers, but other permutations are accepted by the parser so we can
1799 * give a meaningful message from C code.
1800 */
1801 typedef struct TriggerTransition
1802 {
1803 NodeTag type;
1804 char *name;
1805 bool isNew;
1806 bool isTable;
1807 } TriggerTransition;
1808
1809 /* Nodes for SQL/JSON support */
1810
1811 /*
1812 * JsonOutput -
1813 * representation of JSON output clause (RETURNING type [FORMAT format])
1814 */
1815 typedef struct JsonOutput
1816 {
1817 NodeTag type;
1818 TypeName *typeName; /* RETURNING type name, if specified */
1819 JsonReturning *returning; /* RETURNING FORMAT clause and type Oids */
1820 } JsonOutput;
1821
1822 /*
1823 * JsonArgument -
1824 * representation of argument from JSON PASSING clause
1825 */
1826 typedef struct JsonArgument
1827 {
1828 NodeTag type;
1829 JsonValueExpr *val; /* argument value expression */
1830 char *name; /* argument name */
1831 } JsonArgument;
1832
1833 /*
1834 * JsonQuotes -
1835 * representation of [KEEP|OMIT] QUOTES clause for JSON_QUERY()
1836 */
1837 typedef enum JsonQuotes
1838 {
1839 JS_QUOTES_UNSPEC, /* unspecified */
1840 JS_QUOTES_KEEP, /* KEEP QUOTES */
1841 JS_QUOTES_OMIT, /* OMIT QUOTES */
1842 } JsonQuotes;
1843
1844 /*
1845 * JsonFuncExpr -
1846 * untransformed representation of function expressions for
1847 * SQL/JSON query functions
1848 */
1849 typedef struct JsonFuncExpr
1850 {
1851 NodeTag type;
1852 JsonExprOp op; /* expression type */
1853 char *column_name; /* JSON_TABLE() column name or NULL if this is
1854 * not for a JSON_TABLE() */
1855 JsonValueExpr *context_item; /* context item expression */
1856 Node *pathspec; /* JSON path specification expression */
1857 List *passing; /* list of PASSING clause arguments, if any */
1858 JsonOutput *output; /* output clause, if specified */
1859 JsonBehavior *on_empty; /* ON EMPTY behavior */
1860 JsonBehavior *on_error; /* ON ERROR behavior */
1861 JsonWrapper wrapper; /* array wrapper behavior (JSON_QUERY only) */
1862 JsonQuotes quotes; /* omit or keep quotes? (JSON_QUERY only) */
1863 ParseLoc location; /* token location, or -1 if unknown */
1864 } JsonFuncExpr;
1865
1866 /*
1867 * JsonTablePathSpec
1868 * untransformed specification of JSON path expression with an optional
1869 * name
1870 */
1871 typedef struct JsonTablePathSpec
1872 {
1873 NodeTag type;
1874
1875 Node *string;
1876 char *name;
1877 ParseLoc name_location;
1878 ParseLoc location; /* location of 'string' */
1879 } JsonTablePathSpec;
1880
1881 /*
1882 * JsonTable -
1883 * untransformed representation of JSON_TABLE
1884 */
1885 typedef struct JsonTable
1886 {
1887 NodeTag type;
1888 JsonValueExpr *context_item; /* context item expression */
1889 JsonTablePathSpec *pathspec; /* JSON path specification */
1890 List *passing; /* list of PASSING clause arguments, if any */
1891 List *columns; /* list of JsonTableColumn */
1892 JsonBehavior *on_error; /* ON ERROR behavior */
1893 Alias *alias; /* table alias in FROM clause */
1894 bool lateral; /* does it have LATERAL prefix? */
1895 ParseLoc location; /* token location, or -1 if unknown */
1896 } JsonTable;
1897
1898 /*
1899 * JsonTableColumnType -
1900 * enumeration of JSON_TABLE column types
1901 */
1902 typedef enum JsonTableColumnType
1903 {
1904 JTC_FOR_ORDINALITY,
1905 JTC_REGULAR,
1906 JTC_EXISTS,
1907 JTC_FORMATTED,
1908 JTC_NESTED,
1909 } JsonTableColumnType;
1910
1911 /*
1912 * JsonTableColumn -
1913 * untransformed representation of JSON_TABLE column
1914 */
1915 typedef struct JsonTableColumn
1916 {
1917 NodeTag type;
1918 JsonTableColumnType coltype; /* column type */
1919 char *name; /* column name */
1920 TypeName *typeName; /* column type name */
1921 JsonTablePathSpec *pathspec; /* JSON path specification */
1922 JsonFormat *format; /* JSON format clause, if specified */
1923 JsonWrapper wrapper; /* WRAPPER behavior for formatted columns */
1924 JsonQuotes quotes; /* omit or keep quotes on scalar strings? */
1925 List *columns; /* nested columns */
1926 JsonBehavior *on_empty; /* ON EMPTY behavior */
1927 JsonBehavior *on_error; /* ON ERROR behavior */
1928 ParseLoc location; /* token location, or -1 if unknown */
1929 } JsonTableColumn;
1930
1931 /*
1932 * JsonKeyValue -
1933 * untransformed representation of JSON object key-value pair for
1934 * JSON_OBJECT() and JSON_OBJECTAGG()
1935 */
1936 typedef struct JsonKeyValue
1937 {
1938 NodeTag type;
1939 Expr *key; /* key expression */
1940 JsonValueExpr *value; /* JSON value expression */
1941 } JsonKeyValue;
1942
1943 /*
1944 * JsonParseExpr -
1945 * untransformed representation of JSON()
1946 */
1947 typedef struct JsonParseExpr
1948 {
1949 NodeTag type;
1950 JsonValueExpr *expr; /* string expression */
1951 JsonOutput *output; /* RETURNING clause, if specified */
1952 bool unique_keys; /* WITH UNIQUE KEYS? */
1953 ParseLoc location; /* token location, or -1 if unknown */
1954 } JsonParseExpr;
1955
1956 /*
1957 * JsonScalarExpr -
1958 * untransformed representation of JSON_SCALAR()
1959 */
1960 typedef struct JsonScalarExpr
1961 {
1962 NodeTag type;
1963 Expr *expr; /* scalar expression */
1964 JsonOutput *output; /* RETURNING clause, if specified */
1965 ParseLoc location; /* token location, or -1 if unknown */
1966 } JsonScalarExpr;
1967
1968 /*
1969 * JsonSerializeExpr -
1970 * untransformed representation of JSON_SERIALIZE() function
1971 */
1972 typedef struct JsonSerializeExpr
1973 {
1974 NodeTag type;
1975 JsonValueExpr *expr; /* json value expression */
1976 JsonOutput *output; /* RETURNING clause, if specified */
1977 ParseLoc location; /* token location, or -1 if unknown */
1978 } JsonSerializeExpr;
1979
1980 /*
1981 * JsonObjectConstructor -
1982 * untransformed representation of JSON_OBJECT() constructor
1983 */
1984 typedef struct JsonObjectConstructor
1985 {
1986 NodeTag type;
1987 List *exprs; /* list of JsonKeyValue pairs */
1988 JsonOutput *output; /* RETURNING clause, if specified */
1989 bool absent_on_null; /* skip NULL values? */
1990 bool unique; /* check key uniqueness? */
1991 ParseLoc location; /* token location, or -1 if unknown */
1992 } JsonObjectConstructor;
1993
1994 /*
1995 * JsonArrayConstructor -
1996 * untransformed representation of JSON_ARRAY(element,...) constructor
1997 */
1998 typedef struct JsonArrayConstructor
1999 {
2000 NodeTag type;
2001 List *exprs; /* list of JsonValueExpr elements */
2002 JsonOutput *output; /* RETURNING clause, if specified */
2003 bool absent_on_null; /* skip NULL elements? */
2004 ParseLoc location; /* token location, or -1 if unknown */
2005 } JsonArrayConstructor;
2006
2007 /*
2008 * JsonArrayQueryConstructor -
2009 * untransformed representation of JSON_ARRAY(subquery) constructor
2010 */
2011 typedef struct JsonArrayQueryConstructor
2012 {
2013 NodeTag type;
2014 Node *query; /* subquery */
2015 JsonOutput *output; /* RETURNING clause, if specified */
2016 JsonFormat *format; /* FORMAT clause for subquery, if specified */
2017 bool absent_on_null; /* skip NULL elements? */
2018 ParseLoc location; /* token location, or -1 if unknown */
2019 } JsonArrayQueryConstructor;
2020
2021 /*
2022 * JsonAggConstructor -
2023 * common fields of untransformed representation of
2024 * JSON_ARRAYAGG() and JSON_OBJECTAGG()
2025 */
2026 typedef struct JsonAggConstructor
2027 {
2028 NodeTag type;
2029 JsonOutput *output; /* RETURNING clause, if any */
2030 Node *agg_filter; /* FILTER clause, if any */
2031 List *agg_order; /* ORDER BY clause, if any */
2032 struct WindowDef *over; /* OVER clause, if any */
2033 ParseLoc location; /* token location, or -1 if unknown */
2034 } JsonAggConstructor;
2035
2036 /*
2037 * JsonObjectAgg -
2038 * untransformed representation of JSON_OBJECTAGG()
2039 */
2040 typedef struct JsonObjectAgg
2041 {
2042 NodeTag type;
2043 JsonAggConstructor *constructor; /* common fields */
2044 JsonKeyValue *arg; /* object key-value pair */
2045 bool absent_on_null; /* skip NULL values? */
2046 bool unique; /* check key uniqueness? */
2047 } JsonObjectAgg;
2048
2049 /*
2050 * JsonArrayAgg -
2051 * untransformed representation of JSON_ARRAYAGG()
2052 */
2053 typedef struct JsonArrayAgg
2054 {
2055 NodeTag type;
2056 JsonAggConstructor *constructor; /* common fields */
2057 JsonValueExpr *arg; /* array element expression */
2058 bool absent_on_null; /* skip NULL elements? */
2059 } JsonArrayAgg;
2060
2061
2062 /*****************************************************************************
2063 * Raw Grammar Output Statements
2064 *****************************************************************************/
2065
2066 /*
2067 * RawStmt --- container for any one statement's raw parse tree
2068 *
2069 * Parse analysis converts a raw parse tree headed by a RawStmt node into
2070 * an analyzed statement headed by a Query node. For optimizable statements,
2071 * the conversion is complex. For utility statements, the parser usually just
2072 * transfers the raw parse tree (sans RawStmt) into the utilityStmt field of
2073 * the Query node, and all the useful work happens at execution time.
2074 *
2075 * stmt_location/stmt_len identify the portion of the source text string
2076 * containing this raw statement (useful for multi-statement strings).
2077 *
2078 * This is irrelevant for query jumbling, as this is not used in parsed
2079 * queries.
2080 */
2081 typedef struct RawStmt
2082 {
2083 pg_node_attr(no_query_jumble)
2084
2085 NodeTag type;
2086 Node *stmt; /* raw parse tree */
2087 ParseLoc stmt_location; /* start location, or -1 if unknown */
2088 ParseLoc stmt_len; /* length in bytes; 0 means "rest of string" */
2089 } RawStmt;
2090
2091 /*****************************************************************************
2092 * Optimizable Statements
2093 *****************************************************************************/
2094
2095 /* ----------------------
2096 * Insert Statement
2097 *
2098 * The source expression is represented by SelectStmt for both the
2099 * SELECT and VALUES cases. If selectStmt is NULL, then the query
2100 * is INSERT ... DEFAULT VALUES.
2101 * ----------------------
2102 */
2103 typedef struct InsertStmt
2104 {
2105 NodeTag type;
2106 RangeVar *relation; /* relation to insert into */
2107 List *cols; /* optional: names of the target columns */
2108 Node *selectStmt; /* the source SELECT/VALUES, or NULL */
2109 OnConflictClause *onConflictClause; /* ON CONFLICT clause */
2110 ReturningClause *returningClause; /* RETURNING clause */
2111 WithClause *withClause; /* WITH clause */
2112 OverridingKind override; /* OVERRIDING clause */
2113 } InsertStmt;
2114
2115 /* ----------------------
2116 * Delete Statement
2117 * ----------------------
2118 */
2119 typedef struct DeleteStmt
2120 {
2121 NodeTag type;
2122 RangeVar *relation; /* relation to delete from */
2123 List *usingClause; /* optional using clause for more tables */
2124 Node *whereClause; /* qualifications */
2125 ReturningClause *returningClause; /* RETURNING clause */
2126 WithClause *withClause; /* WITH clause */
2127 } DeleteStmt;
2128
2129 /* ----------------------
2130 * Update Statement
2131 * ----------------------
2132 */
2133 typedef struct UpdateStmt
2134 {
2135 NodeTag type;
2136 RangeVar *relation; /* relation to update */
2137 List *targetList; /* the target list (of ResTarget) */
2138 Node *whereClause; /* qualifications */
2139 List *fromClause; /* optional from clause for more tables */
2140 ReturningClause *returningClause; /* RETURNING clause */
2141 WithClause *withClause; /* WITH clause */
2142 } UpdateStmt;
2143
2144 /* ----------------------
2145 * Merge Statement
2146 * ----------------------
2147 */
2148 typedef struct MergeStmt
2149 {
2150 NodeTag type;
2151 RangeVar *relation; /* target relation to merge into */
2152 Node *sourceRelation; /* source relation */
2153 Node *joinCondition; /* join condition between source and target */
2154 List *mergeWhenClauses; /* list of MergeWhenClause(es) */
2155 ReturningClause *returningClause; /* RETURNING clause */
2156 WithClause *withClause; /* WITH clause */
2157 } MergeStmt;
2158
2159 /* ----------------------
2160 * Select Statement
2161 *
2162 * A "simple" SELECT is represented in the output of gram.y by a single
2163 * SelectStmt node; so is a VALUES construct. A query containing set
2164 * operators (UNION, INTERSECT, EXCEPT) is represented by a tree of SelectStmt
2165 * nodes, in which the leaf nodes are component SELECTs and the internal nodes
2166 * represent UNION, INTERSECT, or EXCEPT operators. Using the same node
2167 * type for both leaf and internal nodes allows gram.y to stick ORDER BY,
2168 * LIMIT, etc, clause values into a SELECT statement without worrying
2169 * whether it is a simple or compound SELECT.
2170 * ----------------------
2171 */
2172 typedef enum SetOperation
2173 {
2174 SETOP_NONE = 0,
2175 SETOP_UNION,
2176 SETOP_INTERSECT,
2177 SETOP_EXCEPT,
2178 } SetOperation;
2179
2180 typedef struct SelectStmt
2181 {
2182 NodeTag type;
2183
2184 /*
2185 * These fields are used only in "leaf" SelectStmts.
2186 */
2187 List *distinctClause; /* NULL, list of DISTINCT ON exprs, or
2188 * lcons(NIL,NIL) for all (SELECT DISTINCT) */
2189 IntoClause *intoClause; /* target for SELECT INTO */
2190 List *targetList; /* the target list (of ResTarget) */
2191 List *fromClause; /* the FROM clause */
2192 Node *whereClause; /* WHERE qualification */
2193 List *groupClause; /* GROUP BY clauses */
2194 bool groupDistinct; /* Is this GROUP BY DISTINCT? */
2195 Node *havingClause; /* HAVING conditional-expression */
2196 List *windowClause; /* WINDOW window_name AS (...), ... */
2197
2198 /*
2199 * In a "leaf" node representing a VALUES list, the above fields are all
2200 * null, and instead this field is set. Note that the elements of the
2201 * sublists are just expressions, without ResTarget decoration. Also note
2202 * that a list element can be DEFAULT (represented as a SetToDefault
2203 * node), regardless of the context of the VALUES list. It's up to parse
2204 * analysis to reject that where not valid.
2205 */
2206 List *valuesLists; /* untransformed list of expression lists */
2207
2208 /*
2209 * These fields are used in both "leaf" SelectStmts and upper-level
2210 * SelectStmts.
2211 */
2212 List *sortClause; /* sort clause (a list of SortBy's) */
2213 Node *limitOffset; /* # of result tuples to skip */
2214 Node *limitCount; /* # of result tuples to return */
2215 LimitOption limitOption; /* limit type */
2216 List *lockingClause; /* FOR UPDATE (list of LockingClause's) */
2217 WithClause *withClause; /* WITH clause */
2218
2219 /*
2220 * These fields are used only in upper-level SelectStmts.
2221 */
2222 SetOperation op; /* type of set op */
2223 bool all; /* ALL specified? */
2224 struct SelectStmt *larg; /* left child */
2225 struct SelectStmt *rarg; /* right child */
2226 /* Eventually add fields for CORRESPONDING spec here */
2227 } SelectStmt;
2228
2229
2230 /* ----------------------
2231 * Set Operation node for post-analysis query trees
2232 *
2233 * After parse analysis, a SELECT with set operations is represented by a
2234 * top-level Query node containing the leaf SELECTs as subqueries in its
2235 * range table. Its setOperations field shows the tree of set operations,
2236 * with leaf SelectStmt nodes replaced by RangeTblRef nodes, and internal
2237 * nodes replaced by SetOperationStmt nodes. Information about the output
2238 * column types is added, too. (Note that the child nodes do not necessarily
2239 * produce these types directly, but we've checked that their output types
2240 * can be coerced to the output column type.) Also, if it's not UNION ALL,
2241 * information about the types' sort/group semantics is provided in the form
2242 * of a SortGroupClause list (same representation as, eg, DISTINCT).
2243 * The resolved common column collations are provided too; but note that if
2244 * it's not UNION ALL, it's okay for a column to not have a common collation,
2245 * so a member of the colCollations list could be InvalidOid even though the
2246 * column has a collatable type.
2247 * ----------------------
2248 */
2249 typedef struct SetOperationStmt
2250 {
2251 NodeTag type;
2252 SetOperation op; /* type of set op */
2253 bool all; /* ALL specified? */
2254 Node *larg; /* left child */
2255 Node *rarg; /* right child */
2256 /* Eventually add fields for CORRESPONDING spec here */
2257
2258 /* Fields derived during parse analysis (irrelevant for query jumbling): */
2259 /* OID list of output column type OIDs */
2260 List *colTypes pg_node_attr(query_jumble_ignore);
2261 /* integer list of output column typmods */
2262 List *colTypmods pg_node_attr(query_jumble_ignore);
2263 /* OID list of output column collation OIDs */
2264 List *colCollations pg_node_attr(query_jumble_ignore);
2265 /* a list of SortGroupClause's */
2266 List *groupClauses pg_node_attr(query_jumble_ignore);
2267 /* groupClauses is NIL if UNION ALL, but must be set otherwise */
2268 } SetOperationStmt;
2269
2270
2271 /*
2272 * RETURN statement (inside SQL function body)
2273 */
2274 typedef struct ReturnStmt
2275 {
2276 NodeTag type;
2277 Node *returnval;
2278 } ReturnStmt;
2279
2280
2281 /* ----------------------
2282 * PL/pgSQL Assignment Statement
2283 *
2284 * Like SelectStmt, this is transformed into a SELECT Query.
2285 * However, the targetlist of the result looks more like an UPDATE.
2286 * ----------------------
2287 */
2288 typedef struct PLAssignStmt
2289 {
2290 NodeTag type;
2291
2292 char *name; /* initial column name */
2293 List *indirection; /* subscripts and field names, if any */
2294 int nnames; /* number of names to use in ColumnRef */
2295 SelectStmt *val; /* the PL/pgSQL expression to assign */
2296 ParseLoc location; /* name's token location, or -1 if unknown */
2297 } PLAssignStmt;
2298
2299
2300 /*****************************************************************************
2301 * Other Statements (no optimizations required)
2302 *
2303 * These are not touched by parser/analyze.c except to put them into
2304 * the utilityStmt field of a Query. This is eventually passed to
2305 * ProcessUtility (by-passing rewriting and planning). Some of the
2306 * statements do need attention from parse analysis, and this is
2307 * done by routines in parser/parse_utilcmd.c after ProcessUtility
2308 * receives the command for execution.
2309 * DECLARE CURSOR, EXPLAIN, and CREATE TABLE AS are special cases:
2310 * they contain optimizable statements, which get processed normally
2311 * by parser/analyze.c.
2312 *****************************************************************************/
2313
2314 /*
2315 * When a command can act on several kinds of objects with only one
2316 * parse structure required, use these constants to designate the
2317 * object type. Note that commands typically don't support all the types.
2318 */
2319
2320 typedef enum ObjectType
2321 {
2322 OBJECT_ACCESS_METHOD,
2323 OBJECT_AGGREGATE,
2324 OBJECT_AMOP,
2325 OBJECT_AMPROC,
2326 OBJECT_ATTRIBUTE, /* type's attribute, when distinct from column */
2327 OBJECT_CAST,
2328 OBJECT_COLUMN,
2329 OBJECT_COLLATION,
2330 OBJECT_CONVERSION,
2331 OBJECT_DATABASE,
2332 OBJECT_DEFAULT,
2333 OBJECT_DEFACL,
2334 OBJECT_DOMAIN,
2335 OBJECT_DOMCONSTRAINT,
2336 OBJECT_EVENT_TRIGGER,
2337 OBJECT_EXTENSION,
2338 OBJECT_FDW,
2339 OBJECT_FOREIGN_SERVER,
2340 OBJECT_FOREIGN_TABLE,
2341 OBJECT_FUNCTION,
2342 OBJECT_INDEX,
2343 OBJECT_LANGUAGE,
2344 OBJECT_LARGEOBJECT,
2345 OBJECT_MATVIEW,
2346 OBJECT_OPCLASS,
2347 OBJECT_OPERATOR,
2348 OBJECT_OPFAMILY,
2349 OBJECT_PARAMETER_ACL,
2350 OBJECT_POLICY,
2351 OBJECT_PROCEDURE,
2352 OBJECT_PUBLICATION,
2353 OBJECT_PUBLICATION_NAMESPACE,
2354 OBJECT_PUBLICATION_REL,
2355 OBJECT_ROLE,
2356 OBJECT_ROUTINE,
2357 OBJECT_RULE,
2358 OBJECT_SCHEMA,
2359 OBJECT_SEQUENCE,
2360 OBJECT_SUBSCRIPTION,
2361 OBJECT_STATISTIC_EXT,
2362 OBJECT_TABCONSTRAINT,
2363 OBJECT_TABLE,
2364 OBJECT_TABLESPACE,
2365 OBJECT_TRANSFORM,
2366 OBJECT_TRIGGER,
2367 OBJECT_TSCONFIGURATION,
2368 OBJECT_TSDICTIONARY,
2369 OBJECT_TSPARSER,
2370 OBJECT_TSTEMPLATE,
2371 OBJECT_TYPE,
2372 OBJECT_USER_MAPPING,
2373 OBJECT_VIEW,
2374 } ObjectType;
2375
2376 /* ----------------------
2377 * Create Schema Statement
2378 *
2379 * NOTE: the schemaElts list contains raw parsetrees for component statements
2380 * of the schema, such as CREATE TABLE, GRANT, etc. These are analyzed and
2381 * executed after the schema itself is created.
2382 * ----------------------
2383 */
2384 typedef struct CreateSchemaStmt
2385 {
2386 NodeTag type;
2387 char *schemaname; /* the name of the schema to create */
2388 RoleSpec *authrole; /* the owner of the created schema */
2389 List *schemaElts; /* schema components (list of parsenodes) */
2390 bool if_not_exists; /* just do nothing if schema already exists? */
2391 } CreateSchemaStmt;
2392
2393 typedef enum DropBehavior
2394 {
2395 DROP_RESTRICT, /* drop fails if any dependent objects */
2396 DROP_CASCADE, /* remove dependent objects too */
2397 } DropBehavior;
2398
2399 /* ----------------------
2400 * Alter Table
2401 * ----------------------
2402 */
2403 typedef struct AlterTableStmt
2404 {
2405 NodeTag type;
2406 RangeVar *relation; /* table to work on */
2407 List *cmds; /* list of subcommands */
2408 ObjectType objtype; /* type of object */
2409 bool missing_ok; /* skip error if table missing */
2410 } AlterTableStmt;
2411
2412 typedef enum AlterTableType
2413 {
2414 AT_AddColumn, /* add column */
2415 AT_AddColumnToView, /* implicitly via CREATE OR REPLACE VIEW */
2416 AT_ColumnDefault, /* alter column default */
2417 AT_CookedColumnDefault, /* add a pre-cooked column default */
2418 AT_DropNotNull, /* alter column drop not null */
2419 AT_SetNotNull, /* alter column set not null */
2420 AT_SetExpression, /* alter column set expression */
2421 AT_DropExpression, /* alter column drop expression */
2422 AT_SetStatistics, /* alter column set statistics */
2423 AT_SetOptions, /* alter column set ( options ) */
2424 AT_ResetOptions, /* alter column reset ( options ) */
2425 AT_SetStorage, /* alter column set storage */
2426 AT_SetCompression, /* alter column set compression */
2427 AT_DropColumn, /* drop column */
2428 AT_AddIndex, /* add index */
2429 AT_ReAddIndex, /* internal to commands/tablecmds.c */
2430 AT_AddConstraint, /* add constraint */
2431 AT_ReAddConstraint, /* internal to commands/tablecmds.c */
2432 AT_ReAddDomainConstraint, /* internal to commands/tablecmds.c */
2433 AT_AlterConstraint, /* alter constraint */
2434 AT_ValidateConstraint, /* validate constraint */
2435 AT_AddIndexConstraint, /* add constraint using existing index */
2436 AT_DropConstraint, /* drop constraint */
2437 AT_ReAddComment, /* internal to commands/tablecmds.c */
2438 AT_AlterColumnType, /* alter column type */
2439 AT_AlterColumnGenericOptions, /* alter column OPTIONS (...) */
2440 AT_ChangeOwner, /* change owner */
2441 AT_ClusterOn, /* CLUSTER ON */
2442 AT_DropCluster, /* SET WITHOUT CLUSTER */
2443 AT_SetLogged, /* SET LOGGED */
2444 AT_SetUnLogged, /* SET UNLOGGED */
2445 AT_DropOids, /* SET WITHOUT OIDS */
2446 AT_SetAccessMethod, /* SET ACCESS METHOD */
2447 AT_SetTableSpace, /* SET TABLESPACE */
2448 AT_SetRelOptions, /* SET (...) -- AM specific parameters */
2449 AT_ResetRelOptions, /* RESET (...) -- AM specific parameters */
2450 AT_ReplaceRelOptions, /* replace reloption list in its entirety */
2451 AT_EnableTrig, /* ENABLE TRIGGER name */
2452 AT_EnableAlwaysTrig, /* ENABLE ALWAYS TRIGGER name */
2453 AT_EnableReplicaTrig, /* ENABLE REPLICA TRIGGER name */
2454 AT_DisableTrig, /* DISABLE TRIGGER name */
2455 AT_EnableTrigAll, /* ENABLE TRIGGER ALL */
2456 AT_DisableTrigAll, /* DISABLE TRIGGER ALL */
2457 AT_EnableTrigUser, /* ENABLE TRIGGER USER */
2458 AT_DisableTrigUser, /* DISABLE TRIGGER USER */
2459 AT_EnableRule, /* ENABLE RULE name */
2460 AT_EnableAlwaysRule, /* ENABLE ALWAYS RULE name */
2461 AT_EnableReplicaRule, /* ENABLE REPLICA RULE name */
2462 AT_DisableRule, /* DISABLE RULE name */
2463 AT_AddInherit, /* INHERIT parent */
2464 AT_DropInherit, /* NO INHERIT parent */
2465 AT_AddOf, /* OF <type_name> */
2466 AT_DropOf, /* NOT OF */
2467 AT_ReplicaIdentity, /* REPLICA IDENTITY */
2468 AT_EnableRowSecurity, /* ENABLE ROW SECURITY */
2469 AT_DisableRowSecurity, /* DISABLE ROW SECURITY */
2470 AT_ForceRowSecurity, /* FORCE ROW SECURITY */
2471 AT_NoForceRowSecurity, /* NO FORCE ROW SECURITY */
2472 AT_GenericOptions, /* OPTIONS (...) */
2473 AT_AttachPartition, /* ATTACH PARTITION */
2474 AT_DetachPartition, /* DETACH PARTITION */
2475 AT_DetachPartitionFinalize, /* DETACH PARTITION FINALIZE */
2476 AT_AddIdentity, /* ADD IDENTITY */
2477 AT_SetIdentity, /* SET identity column options */
2478 AT_DropIdentity, /* DROP IDENTITY */
2479 AT_ReAddStatistics, /* internal to commands/tablecmds.c */
2480 } AlterTableType;
2481
2482 typedef struct AlterTableCmd /* one subcommand of an ALTER TABLE */
2483 {
2484 NodeTag type;
2485 AlterTableType subtype; /* Type of table alteration to apply */
2486 char *name; /* column, constraint, or trigger to act on,
2487 * or tablespace, access method */
2488 int16 num; /* attribute number for columns referenced by
2489 * number */
2490 RoleSpec *newowner;
2491 Node *def; /* definition of new column, index,
2492 * constraint, or parent table */
2493 DropBehavior behavior; /* RESTRICT or CASCADE for DROP cases */
2494 bool missing_ok; /* skip error if missing? */
2495 bool recurse; /* exec-time recursion */
2496 } AlterTableCmd;
2497
2498 /* Ad-hoc node for AT_AlterConstraint */
2499 typedef struct ATAlterConstraint
2500 {
2501 NodeTag type;
2502 char *conname; /* Constraint name */
2503 bool alterEnforceability; /* changing enforceability properties? */
2504 bool is_enforced; /* ENFORCED? */
2505 bool alterDeferrability; /* changing deferrability properties? */
2506 bool deferrable; /* DEFERRABLE? */
2507 bool initdeferred; /* INITIALLY DEFERRED? */
2508 bool alterInheritability; /* changing inheritability properties */
2509 bool noinherit;
2510 } ATAlterConstraint;
2511
2512 /* Ad-hoc node for AT_ReplicaIdentity */
2513 typedef struct ReplicaIdentityStmt
2514 {
2515 NodeTag type;
2516 char identity_type;
2517 char *name;
2518 } ReplicaIdentityStmt;
2519
2520
2521 /* ----------------------
2522 * Alter Collation
2523 * ----------------------
2524 */
2525 typedef struct AlterCollationStmt
2526 {
2527 NodeTag type;
2528 List *collname;
2529 } AlterCollationStmt;
2530
2531
2532 /* ----------------------
2533 * Alter Domain
2534 *
2535 * The fields are used in different ways by the different variants of
2536 * this command.
2537 * ----------------------
2538 */
2539 typedef struct AlterDomainStmt
2540 {
2541 NodeTag type;
2542 char subtype; /*------------
2543 * T = alter column default
2544 * N = alter column drop not null
2545 * O = alter column set not null
2546 * C = add constraint
2547 * X = drop constraint
2548 *------------
2549 */
2550 List *typeName; /* domain to work on */
2551 char *name; /* column or constraint name to act on */
2552 Node *def; /* definition of default or constraint */
2553 DropBehavior behavior; /* RESTRICT or CASCADE for DROP cases */
2554 bool missing_ok; /* skip error if missing? */
2555 } AlterDomainStmt;
2556
2557
2558 /* ----------------------
2559 * Grant|Revoke Statement
2560 * ----------------------
2561 */
2562 typedef enum GrantTargetType
2563 {
2564 ACL_TARGET_OBJECT, /* grant on specific named object(s) */
2565 ACL_TARGET_ALL_IN_SCHEMA, /* grant on all objects in given schema(s) */
2566 ACL_TARGET_DEFAULTS, /* ALTER DEFAULT PRIVILEGES */
2567 } GrantTargetType;
2568
2569 typedef struct GrantStmt
2570 {
2571 NodeTag type;
2572 bool is_grant; /* true = GRANT, false = REVOKE */
2573 GrantTargetType targtype; /* type of the grant target */
2574 ObjectType objtype; /* kind of object being operated on */
2575 List *objects; /* list of RangeVar nodes, ObjectWithArgs
2576 * nodes, or plain names (as String values) */
2577 List *privileges; /* list of AccessPriv nodes */
2578 /* privileges == NIL denotes ALL PRIVILEGES */
2579 List *grantees; /* list of RoleSpec nodes */
2580 bool grant_option; /* grant or revoke grant option */
2581 RoleSpec *grantor;
2582 DropBehavior behavior; /* drop behavior (for REVOKE) */
2583 } GrantStmt;
2584
2585 /*
2586 * ObjectWithArgs represents a function/procedure/operator name plus parameter
2587 * identification.
2588 *
2589 * objargs includes only the types of the input parameters of the object.
2590 * In some contexts, that will be all we have, and it's enough to look up
2591 * objects according to the traditional Postgres rules (i.e., when only input
2592 * arguments matter).
2593 *
2594 * objfuncargs, if not NIL, carries the full specification of the parameter
2595 * list, including parameter mode annotations.
2596 *
2597 * Some grammar productions can set args_unspecified = true instead of
2598 * providing parameter info. In this case, lookup will succeed only if
2599 * the object name is unique. Note that otherwise, NIL parameter lists
2600 * mean zero arguments.
2601 */
2602 typedef struct ObjectWithArgs
2603 {
2604 NodeTag type;
2605 List *objname; /* qualified name of function/operator */
2606 List *objargs; /* list of Typename nodes (input args only) */
2607 List *objfuncargs; /* list of FunctionParameter nodes */
2608 bool args_unspecified; /* argument list was omitted? */
2609 } ObjectWithArgs;
2610
2611 /*
2612 * An access privilege, with optional list of column names
2613 * priv_name == NULL denotes ALL PRIVILEGES (only used with a column list)
2614 * cols == NIL denotes "all columns"
2615 * Note that simple "ALL PRIVILEGES" is represented as a NIL list, not
2616 * an AccessPriv with both fields null.
2617 */
2618 typedef struct AccessPriv
2619 {
2620 NodeTag type;
2621 char *priv_name; /* string name of privilege */
2622 List *cols; /* list of String */
2623 } AccessPriv;
2624
2625 /* ----------------------
2626 * Grant/Revoke Role Statement
2627 *
2628 * Note: because of the parsing ambiguity with the GRANT <privileges>
2629 * statement, granted_roles is a list of AccessPriv; the execution code
2630 * should complain if any column lists appear. grantee_roles is a list
2631 * of role names, as String values.
2632 * ----------------------
2633 */
2634 typedef struct GrantRoleStmt
2635 {
2636 NodeTag type;
2637 List *granted_roles; /* list of roles to be granted/revoked */
2638 List *grantee_roles; /* list of member roles to add/delete */
2639 bool is_grant; /* true = GRANT, false = REVOKE */
2640 List *opt; /* options e.g. WITH GRANT OPTION */
2641 RoleSpec *grantor; /* set grantor to other than current role */
2642 DropBehavior behavior; /* drop behavior (for REVOKE) */
2643 } GrantRoleStmt;
2644
2645 /* ----------------------
2646 * Alter Default Privileges Statement
2647 * ----------------------
2648 */
2649 typedef struct AlterDefaultPrivilegesStmt
2650 {
2651 NodeTag type;
2652 List *options; /* list of DefElem */
2653 GrantStmt *action; /* GRANT/REVOKE action (with objects=NIL) */
2654 } AlterDefaultPrivilegesStmt;
2655
2656 /* ----------------------
2657 * Copy Statement
2658 *
2659 * We support "COPY relation FROM file", "COPY relation TO file", and
2660 * "COPY (query) TO file". In any given CopyStmt, exactly one of "relation"
2661 * and "query" must be non-NULL.
2662 * ----------------------
2663 */
2664 typedef struct CopyStmt
2665 {
2666 NodeTag type;
2667 RangeVar *relation; /* the relation to copy */
2668 Node *query; /* the query (SELECT or DML statement with
2669 * RETURNING) to copy, as a raw parse tree */
2670 List *attlist; /* List of column names (as Strings), or NIL
2671 * for all columns */
2672 bool is_from; /* TO or FROM */
2673 bool is_program; /* is 'filename' a program to popen? */
2674 char *filename; /* filename, or NULL for STDIN/STDOUT */
2675 List *options; /* List of DefElem nodes */
2676 Node *whereClause; /* WHERE condition (or NULL) */
2677 } CopyStmt;
2678
2679 /* ----------------------
2680 * SET Statement (includes RESET)
2681 *
2682 * "SET var TO DEFAULT" and "RESET var" are semantically equivalent, but we
2683 * preserve the distinction in VariableSetKind for CreateCommandTag().
2684 * ----------------------
2685 */
2686 typedef enum VariableSetKind
2687 {
2688 VAR_SET_VALUE, /* SET var = value */
2689 VAR_SET_DEFAULT, /* SET var TO DEFAULT */
2690 VAR_SET_CURRENT, /* SET var FROM CURRENT */
2691 VAR_SET_MULTI, /* special case for SET TRANSACTION ... */
2692 VAR_RESET, /* RESET var */
2693 VAR_RESET_ALL, /* RESET ALL */
2694 } VariableSetKind;
2695
2696 typedef struct VariableSetStmt
2697 {
2698 pg_node_attr(custom_query_jumble)
2699
2700 NodeTag type;
2701 VariableSetKind kind;
2702 /* variable to be set */
2703 char *name;
2704 /* List of A_Const nodes */
2705 List *args;
2706
2707 /*
2708 * True if arguments should be accounted for in query jumbling. We use a
2709 * separate flag rather than query_jumble_ignore on "args" as several
2710 * grammar flavors of SET rely on a list of values that are parsed
2711 * directly from the grammar's keywords.
2712 */
2713 bool jumble_args;
2714 /* SET LOCAL? */
2715 bool is_local;
2716 /* token location, or -1 if unknown */
2717 ParseLoc location pg_node_attr(query_jumble_location);
2718 } VariableSetStmt;
2719
2720 /* ----------------------
2721 * Show Statement
2722 * ----------------------
2723 */
2724 typedef struct VariableShowStmt
2725 {
2726 NodeTag type;
2727 char *name;
2728 } VariableShowStmt;
2729
2730 /* ----------------------
2731 * Create Table Statement
2732 *
2733 * NOTE: in the raw gram.y output, ColumnDef and Constraint nodes are
2734 * intermixed in tableElts, and constraints and nnconstraints are NIL. After
2735 * parse analysis, tableElts contains just ColumnDefs, nnconstraints contains
2736 * Constraint nodes of CONSTR_NOTNULL type from various sources, and
2737 * constraints contains just CONSTR_CHECK Constraint nodes.
2738 * ----------------------
2739 */
2740
2741 typedef struct CreateStmt
2742 {
2743 NodeTag type;
2744 RangeVar *relation; /* relation to create */
2745 List *tableElts; /* column definitions (list of ColumnDef) */
2746 List *inhRelations; /* relations to inherit from (list of
2747 * RangeVar) */
2748 PartitionBoundSpec *partbound; /* FOR VALUES clause */
2749 PartitionSpec *partspec; /* PARTITION BY clause */
2750 TypeName *ofTypename; /* OF typename */
2751 List *constraints; /* constraints (list of Constraint nodes) */
2752 List *nnconstraints; /* NOT NULL constraints (ditto) */
2753 List *options; /* options from WITH clause */
2754 OnCommitAction oncommit; /* what do we do at COMMIT? */
2755 char *tablespacename; /* table space to use, or NULL */
2756 char *accessMethod; /* table access method */
2757 bool if_not_exists; /* just do nothing if it already exists? */
2758 } CreateStmt;
2759
2760 /* ----------
2761 * Definitions for constraints in CreateStmt
2762 *
2763 * Note that column defaults are treated as a type of constraint,
2764 * even though that's a bit odd semantically.
2765 *
2766 * For constraints that use expressions (CONSTR_CHECK, CONSTR_DEFAULT)
2767 * we may have the expression in either "raw" form (an untransformed
2768 * parse tree) or "cooked" form (the nodeToString representation of
2769 * an executable expression tree), depending on how this Constraint
2770 * node was created (by parsing, or by inheritance from an existing
2771 * relation). We should never have both in the same node!
2772 *
2773 * FKCONSTR_ACTION_xxx values are stored into pg_constraint.confupdtype
2774 * and pg_constraint.confdeltype columns; FKCONSTR_MATCH_xxx values are
2775 * stored into pg_constraint.confmatchtype. Changing the code values may
2776 * require an initdb!
2777 *
2778 * If skip_validation is true then we skip checking that the existing rows
2779 * in the table satisfy the constraint, and just install the catalog entries
2780 * for the constraint. A new FK constraint is marked as valid iff
2781 * initially_valid is true. (Usually skip_validation and initially_valid
2782 * are inverses, but we can set both true if the table is known empty.)
2783 *
2784 * Constraint attributes (DEFERRABLE etc) are initially represented as
2785 * separate Constraint nodes for simplicity of parsing. parse_utilcmd.c makes
2786 * a pass through the constraints list to insert the info into the appropriate
2787 * Constraint node.
2788 * ----------
2789 */
2790
2791 typedef enum ConstrType /* types of constraints */
2792 {
2793 CONSTR_NULL, /* not standard SQL, but a lot of people
2794 * expect it */
2795 CONSTR_NOTNULL,
2796 CONSTR_DEFAULT,
2797 CONSTR_IDENTITY,
2798 CONSTR_GENERATED,
2799 CONSTR_CHECK,
2800 CONSTR_PRIMARY,
2801 CONSTR_UNIQUE,
2802 CONSTR_EXCLUSION,
2803 CONSTR_FOREIGN,
2804 CONSTR_ATTR_DEFERRABLE, /* attributes for previous constraint node */
2805 CONSTR_ATTR_NOT_DEFERRABLE,
2806 CONSTR_ATTR_DEFERRED,
2807 CONSTR_ATTR_IMMEDIATE,
2808 CONSTR_ATTR_ENFORCED,
2809 CONSTR_ATTR_NOT_ENFORCED,
2810 } ConstrType;
2811
2812 /* Foreign key action codes */
2813 #define FKCONSTR_ACTION_NOACTION 'a'
2814 #define FKCONSTR_ACTION_RESTRICT 'r'
2815 #define FKCONSTR_ACTION_CASCADE 'c'
2816 #define FKCONSTR_ACTION_SETNULL 'n'
2817 #define FKCONSTR_ACTION_SETDEFAULT 'd'
2818
2819 /* Foreign key matchtype codes */
2820 #define FKCONSTR_MATCH_FULL 'f'
2821 #define FKCONSTR_MATCH_PARTIAL 'p'
2822 #define FKCONSTR_MATCH_SIMPLE 's'
2823
2824 typedef struct Constraint
2825 {
2826 NodeTag type;
2827 ConstrType contype; /* see above */
2828 char *conname; /* Constraint name, or NULL if unnamed */
2829 bool deferrable; /* DEFERRABLE? */
2830 bool initdeferred; /* INITIALLY DEFERRED? */
2831 bool is_enforced; /* enforced constraint? */
2832 bool skip_validation; /* skip validation of existing rows? */
2833 bool initially_valid; /* mark the new constraint as valid? */
2834 bool is_no_inherit; /* is constraint non-inheritable? */
2835 Node *raw_expr; /* CHECK or DEFAULT expression, as
2836 * untransformed parse tree */
2837 char *cooked_expr; /* CHECK or DEFAULT expression, as
2838 * nodeToString representation */
2839 char generated_when; /* ALWAYS or BY DEFAULT */
2840 char generated_kind; /* STORED or VIRTUAL */
2841 bool nulls_not_distinct; /* null treatment for UNIQUE constraints */
2842 List *keys; /* String nodes naming referenced key
2843 * column(s); for UNIQUE/PK/NOT NULL */
2844 bool without_overlaps; /* WITHOUT OVERLAPS specified */
2845 List *including; /* String nodes naming referenced nonkey
2846 * column(s); for UNIQUE/PK */
2847 List *exclusions; /* list of (IndexElem, operator name) pairs;
2848 * for exclusion constraints */
2849 List *options; /* options from WITH clause */
2850 char *indexname; /* existing index to use; otherwise NULL */
2851 char *indexspace; /* index tablespace; NULL for default */
2852 bool reset_default_tblspc; /* reset default_tablespace prior to
2853 * creating the index */
2854 char *access_method; /* index access method; NULL for default */
2855 Node *where_clause; /* partial index predicate */
2856
2857 /* Fields used for FOREIGN KEY constraints: */
2858 RangeVar *pktable; /* Primary key table */
2859 List *fk_attrs; /* Attributes of foreign key */
2860 List *pk_attrs; /* Corresponding attrs in PK table */
2861 bool fk_with_period; /* Last attribute of FK uses PERIOD */
2862 bool pk_with_period; /* Last attribute of PK uses PERIOD */
2863 char fk_matchtype; /* FULL, PARTIAL, SIMPLE */
2864 char fk_upd_action; /* ON UPDATE action */
2865 char fk_del_action; /* ON DELETE action */
2866 List *fk_del_set_cols; /* ON DELETE SET NULL/DEFAULT (col1, col2) */
2867 List *old_conpfeqop; /* pg_constraint.conpfeqop of my former self */
2868 Oid old_pktable_oid; /* pg_constraint.confrelid of my former
2869 * self */
2870
2871 ParseLoc location; /* token location, or -1 if unknown */
2872 } Constraint;
2873
2874 /* ----------------------
2875 * Create/Drop Table Space Statements
2876 * ----------------------
2877 */
2878
2879 typedef struct CreateTableSpaceStmt
2880 {
2881 NodeTag type;
2882 char *tablespacename;
2883 RoleSpec *owner;
2884 char *location;
2885 List *options;
2886 } CreateTableSpaceStmt;
2887
2888 typedef struct DropTableSpaceStmt
2889 {
2890 NodeTag type;
2891 char *tablespacename;
2892 bool missing_ok; /* skip error if missing? */
2893 } DropTableSpaceStmt;
2894
2895 typedef struct AlterTableSpaceOptionsStmt
2896 {
2897 NodeTag type;
2898 char *tablespacename;
2899 List *options;
2900 bool isReset;
2901 } AlterTableSpaceOptionsStmt;
2902
2903 typedef struct AlterTableMoveAllStmt
2904 {
2905 NodeTag type;
2906 char *orig_tablespacename;
2907 ObjectType objtype; /* Object type to move */
2908 List *roles; /* List of roles to move objects of */
2909 char *new_tablespacename;
2910 bool nowait;
2911 } AlterTableMoveAllStmt;
2912
2913 /* ----------------------
2914 * Create/Alter Extension Statements
2915 * ----------------------
2916 */
2917
2918 typedef struct CreateExtensionStmt
2919 {
2920 NodeTag type;
2921 char *extname;
2922 bool if_not_exists; /* just do nothing if it already exists? */
2923 List *options; /* List of DefElem nodes */
2924 } CreateExtensionStmt;
2925
2926 /* Only used for ALTER EXTENSION UPDATE; later might need an action field */
2927 typedef struct AlterExtensionStmt
2928 {
2929 NodeTag type;
2930 char *extname;
2931 List *options; /* List of DefElem nodes */
2932 } AlterExtensionStmt;
2933
2934 typedef struct AlterExtensionContentsStmt
2935 {
2936 NodeTag type;
2937 char *extname; /* Extension's name */
2938 int action; /* +1 = add object, -1 = drop object */
2939 ObjectType objtype; /* Object's type */
2940 Node *object; /* Qualified name of the object */
2941 } AlterExtensionContentsStmt;
2942
2943 /* ----------------------
2944 * Create/Alter FOREIGN DATA WRAPPER Statements
2945 * ----------------------
2946 */
2947
2948 typedef struct CreateFdwStmt
2949 {
2950 NodeTag type;
2951 char *fdwname; /* foreign-data wrapper name */
2952 List *func_options; /* HANDLER/VALIDATOR options */
2953 List *options; /* generic options to FDW */
2954 } CreateFdwStmt;
2955
2956 typedef struct AlterFdwStmt
2957 {
2958 NodeTag type;
2959 char *fdwname; /* foreign-data wrapper name */
2960 List *func_options; /* HANDLER/VALIDATOR options */
2961 List *options; /* generic options to FDW */
2962 } AlterFdwStmt;
2963
2964 /* ----------------------
2965 * Create/Alter FOREIGN SERVER Statements
2966 * ----------------------
2967 */
2968
2969 typedef struct CreateForeignServerStmt
2970 {
2971 NodeTag type;
2972 char *servername; /* server name */
2973 char *servertype; /* optional server type */
2974 char *version; /* optional server version */
2975 char *fdwname; /* FDW name */
2976 bool if_not_exists; /* just do nothing if it already exists? */
2977 List *options; /* generic options to server */
2978 } CreateForeignServerStmt;
2979
2980 typedef struct AlterForeignServerStmt
2981 {
2982 NodeTag type;
2983 char *servername; /* server name */
2984 char *version; /* optional server version */
2985 List *options; /* generic options to server */
2986 bool has_version; /* version specified */
2987 } AlterForeignServerStmt;
2988
2989 /* ----------------------
2990 * Create FOREIGN TABLE Statement
2991 * ----------------------
2992 */
2993
2994 typedef struct CreateForeignTableStmt
2995 {
2996 CreateStmt base;
2997 char *servername;
2998 List *options;
2999 } CreateForeignTableStmt;
3000
3001 /* ----------------------
3002 * Create/Drop USER MAPPING Statements
3003 * ----------------------
3004 */
3005
3006 typedef struct CreateUserMappingStmt
3007 {
3008 NodeTag type;
3009 RoleSpec *user; /* user role */
3010 char *servername; /* server name */
3011 bool if_not_exists; /* just do nothing if it already exists? */
3012 List *options; /* generic options to server */
3013 } CreateUserMappingStmt;
3014
3015 typedef struct AlterUserMappingStmt
3016 {
3017 NodeTag type;
3018 RoleSpec *user; /* user role */
3019 char *servername; /* server name */
3020 List *options; /* generic options to server */
3021 } AlterUserMappingStmt;
3022
3023 typedef struct DropUserMappingStmt
3024 {
3025 NodeTag type;
3026 RoleSpec *user; /* user role */
3027 char *servername; /* server name */
3028 bool missing_ok; /* ignore missing mappings */
3029 } DropUserMappingStmt;
3030
3031 /* ----------------------
3032 * Import Foreign Schema Statement
3033 * ----------------------
3034 */
3035
3036 typedef enum ImportForeignSchemaType
3037 {
3038 FDW_IMPORT_SCHEMA_ALL, /* all relations wanted */
3039 FDW_IMPORT_SCHEMA_LIMIT_TO, /* include only listed tables in import */
3040 FDW_IMPORT_SCHEMA_EXCEPT, /* exclude listed tables from import */
3041 } ImportForeignSchemaType;
3042
3043 typedef struct ImportForeignSchemaStmt
3044 {
3045 NodeTag type;
3046 char *server_name; /* FDW server name */
3047 char *remote_schema; /* remote schema name to query */
3048 char *local_schema; /* local schema to create objects in */
3049 ImportForeignSchemaType list_type; /* type of table list */
3050 List *table_list; /* List of RangeVar */
3051 List *options; /* list of options to pass to FDW */
3052 } ImportForeignSchemaStmt;
3053
3054 /*----------------------
3055 * Create POLICY Statement
3056 *----------------------
3057 */
3058 typedef struct CreatePolicyStmt
3059 {
3060 NodeTag type;
3061 char *policy_name; /* Policy's name */
3062 RangeVar *table; /* the table name the policy applies to */
3063 char *cmd_name; /* the command name the policy applies to */
3064 bool permissive; /* restrictive or permissive policy */
3065 List *roles; /* the roles associated with the policy */
3066 Node *qual; /* the policy's condition */
3067 Node *with_check; /* the policy's WITH CHECK condition. */
3068 } CreatePolicyStmt;
3069
3070 /*----------------------
3071 * Alter POLICY Statement
3072 *----------------------
3073 */
3074 typedef struct AlterPolicyStmt
3075 {
3076 NodeTag type;
3077 char *policy_name; /* Policy's name */
3078 RangeVar *table; /* the table name the policy applies to */
3079 List *roles; /* the roles associated with the policy */
3080 Node *qual; /* the policy's condition */
3081 Node *with_check; /* the policy's WITH CHECK condition. */
3082 } AlterPolicyStmt;
3083
3084 /*----------------------
3085 * Create ACCESS METHOD Statement
3086 *----------------------
3087 */
3088 typedef struct CreateAmStmt
3089 {
3090 NodeTag type;
3091 char *amname; /* access method name */
3092 List *handler_name; /* handler function name */
3093 char amtype; /* type of access method */
3094 } CreateAmStmt;
3095
3096 /* ----------------------
3097 * Create TRIGGER Statement
3098 * ----------------------
3099 */
3100 typedef struct CreateTrigStmt
3101 {
3102 NodeTag type;
3103 bool replace; /* replace trigger if already exists */
3104 bool isconstraint; /* This is a constraint trigger */
3105 char *trigname; /* TRIGGER's name */
3106 RangeVar *relation; /* relation trigger is on */
3107 List *funcname; /* qual. name of function to call */
3108 List *args; /* list of String or NIL */
3109 bool row; /* ROW/STATEMENT */
3110 /* timing uses the TRIGGER_TYPE bits defined in catalog/pg_trigger.h */
3111 int16 timing; /* BEFORE, AFTER, or INSTEAD */
3112 /* events uses the TRIGGER_TYPE bits defined in catalog/pg_trigger.h */
3113 int16 events; /* "OR" of INSERT/UPDATE/DELETE/TRUNCATE */
3114 List *columns; /* column names, or NIL for all columns */
3115 Node *whenClause; /* qual expression, or NULL if none */
3116 /* explicitly named transition data */
3117 List *transitionRels; /* TriggerTransition nodes, or NIL if none */
3118 /* The remaining fields are only used for constraint triggers */
3119 bool deferrable; /* [NOT] DEFERRABLE */
3120 bool initdeferred; /* INITIALLY {DEFERRED|IMMEDIATE} */
3121 RangeVar *constrrel; /* opposite relation, if RI trigger */
3122 } CreateTrigStmt;
3123
3124 /* ----------------------
3125 * Create EVENT TRIGGER Statement
3126 * ----------------------
3127 */
3128 typedef struct CreateEventTrigStmt
3129 {
3130 NodeTag type;
3131 char *trigname; /* TRIGGER's name */
3132 char *eventname; /* event's identifier */
3133 List *whenclause; /* list of DefElems indicating filtering */
3134 List *funcname; /* qual. name of function to call */
3135 } CreateEventTrigStmt;
3136
3137 /* ----------------------
3138 * Alter EVENT TRIGGER Statement
3139 * ----------------------
3140 */
3141 typedef struct AlterEventTrigStmt
3142 {
3143 NodeTag type;
3144 char *trigname; /* TRIGGER's name */
3145 char tgenabled; /* trigger's firing configuration WRT
3146 * session_replication_role */
3147 } AlterEventTrigStmt;
3148
3149 /* ----------------------
3150 * Create LANGUAGE Statements
3151 * ----------------------
3152 */
3153 typedef struct CreatePLangStmt
3154 {
3155 NodeTag type;
3156 bool replace; /* T => replace if already exists */
3157 char *plname; /* PL name */
3158 List *plhandler; /* PL call handler function (qual. name) */
3159 List *plinline; /* optional inline function (qual. name) */
3160 List *plvalidator; /* optional validator function (qual. name) */
3161 bool pltrusted; /* PL is trusted */
3162 } CreatePLangStmt;
3163
3164 /* ----------------------
3165 * Create/Alter/Drop Role Statements
3166 *
3167 * Note: these node types are also used for the backwards-compatible
3168 * Create/Alter/Drop User/Group statements. In the ALTER and DROP cases
3169 * there's really no need to distinguish what the original spelling was,
3170 * but for CREATE we mark the type because the defaults vary.
3171 * ----------------------
3172 */
3173 typedef enum RoleStmtType
3174 {
3175 ROLESTMT_ROLE,
3176 ROLESTMT_USER,
3177 ROLESTMT_GROUP,
3178 } RoleStmtType;
3179
3180 typedef struct CreateRoleStmt
3181 {
3182 NodeTag type;
3183 RoleStmtType stmt_type; /* ROLE/USER/GROUP */
3184 char *role; /* role name */
3185 List *options; /* List of DefElem nodes */
3186 } CreateRoleStmt;
3187
3188 typedef struct AlterRoleStmt
3189 {
3190 NodeTag type;
3191 RoleSpec *role; /* role */
3192 List *options; /* List of DefElem nodes */
3193 int action; /* +1 = add members, -1 = drop members */
3194 } AlterRoleStmt;
3195
3196 typedef struct AlterRoleSetStmt
3197 {
3198 NodeTag type;
3199 RoleSpec *role; /* role */
3200 char *database; /* database name, or NULL */
3201 VariableSetStmt *setstmt; /* SET or RESET subcommand */
3202 } AlterRoleSetStmt;
3203
3204 typedef struct DropRoleStmt
3205 {
3206 NodeTag type;
3207 List *roles; /* List of roles to remove */
3208 bool missing_ok; /* skip error if a role is missing? */
3209 } DropRoleStmt;
3210
3211 /* ----------------------
3212 * {Create|Alter} SEQUENCE Statement
3213 * ----------------------
3214 */
3215
3216 typedef struct CreateSeqStmt
3217 {
3218 NodeTag type;
3219 RangeVar *sequence; /* the sequence to create */
3220 List *options;
3221 Oid ownerId; /* ID of owner, or InvalidOid for default */
3222 bool for_identity;
3223 bool if_not_exists; /* just do nothing if it already exists? */
3224 } CreateSeqStmt;
3225
3226 typedef struct AlterSeqStmt
3227 {
3228 NodeTag type;
3229 RangeVar *sequence; /* the sequence to alter */
3230 List *options;
3231 bool for_identity;
3232 bool missing_ok; /* skip error if a role is missing? */
3233 } AlterSeqStmt;
3234
3235 /* ----------------------
3236 * Create {Aggregate|Operator|Type} Statement
3237 * ----------------------
3238 */
3239 typedef struct DefineStmt
3240 {
3241 NodeTag type;
3242 ObjectType kind; /* aggregate, operator, type */
3243 bool oldstyle; /* hack to signal old CREATE AGG syntax */
3244 List *defnames; /* qualified name (list of String) */
3245 List *args; /* a list of TypeName (if needed) */
3246 List *definition; /* a list of DefElem */
3247 bool if_not_exists; /* just do nothing if it already exists? */
3248 bool replace; /* replace if already exists? */
3249 } DefineStmt;
3250
3251 /* ----------------------
3252 * Create Domain Statement
3253 * ----------------------
3254 */
3255 typedef struct CreateDomainStmt
3256 {
3257 NodeTag type;
3258 List *domainname; /* qualified name (list of String) */
3259 TypeName *typeName; /* the base type */
3260 CollateClause *collClause; /* untransformed COLLATE spec, if any */
3261 List *constraints; /* constraints (list of Constraint nodes) */
3262 } CreateDomainStmt;
3263
3264 /* ----------------------
3265 * Create Operator Class Statement
3266 * ----------------------
3267 */
3268 typedef struct CreateOpClassStmt
3269 {
3270 NodeTag type;
3271 List *opclassname; /* qualified name (list of String) */
3272 List *opfamilyname; /* qualified name (ditto); NIL if omitted */
3273 char *amname; /* name of index AM opclass is for */
3274 TypeName *datatype; /* datatype of indexed column */
3275 List *items; /* List of CreateOpClassItem nodes */
3276 bool isDefault; /* Should be marked as default for type? */
3277 } CreateOpClassStmt;
3278
3279 #define OPCLASS_ITEM_OPERATOR 1
3280 #define OPCLASS_ITEM_FUNCTION 2
3281 #define OPCLASS_ITEM_STORAGETYPE 3
3282
3283 typedef struct CreateOpClassItem
3284 {
3285 NodeTag type;
3286 int itemtype; /* see codes above */
3287 ObjectWithArgs *name; /* operator or function name and args */
3288 int number; /* strategy num or support proc num */
3289 List *order_family; /* only used for ordering operators */
3290 List *class_args; /* amproclefttype/amprocrighttype or
3291 * amoplefttype/amoprighttype */
3292 /* fields used for a storagetype item: */
3293 TypeName *storedtype; /* datatype stored in index */
3294 } CreateOpClassItem;
3295
3296 /* ----------------------
3297 * Create Operator Family Statement
3298 * ----------------------
3299 */
3300 typedef struct CreateOpFamilyStmt
3301 {
3302 NodeTag type;
3303 List *opfamilyname; /* qualified name (list of String) */
3304 char *amname; /* name of index AM opfamily is for */
3305 } CreateOpFamilyStmt;
3306
3307 /* ----------------------
3308 * Alter Operator Family Statement
3309 * ----------------------
3310 */
3311 typedef struct AlterOpFamilyStmt
3312 {
3313 NodeTag type;
3314 List *opfamilyname; /* qualified name (list of String) */
3315 char *amname; /* name of index AM opfamily is for */
3316 bool isDrop; /* ADD or DROP the items? */
3317 List *items; /* List of CreateOpClassItem nodes */
3318 } AlterOpFamilyStmt;
3319
3320 /* ----------------------
3321 * Drop Table|Sequence|View|Index|Type|Domain|Conversion|Schema Statement
3322 * ----------------------
3323 */
3324
3325 typedef struct DropStmt
3326 {
3327 NodeTag type;
3328 List *objects; /* list of names */
3329 ObjectType removeType; /* object type */
3330 DropBehavior behavior; /* RESTRICT or CASCADE behavior */
3331 bool missing_ok; /* skip error if object is missing? */
3332 bool concurrent; /* drop index concurrently? */
3333 } DropStmt;
3334
3335 /* ----------------------
3336 * Truncate Table Statement
3337 * ----------------------
3338 */
3339 typedef struct TruncateStmt
3340 {
3341 NodeTag type;
3342 List *relations; /* relations (RangeVars) to be truncated */
3343 bool restart_seqs; /* restart owned sequences? */
3344 DropBehavior behavior; /* RESTRICT or CASCADE behavior */
3345 } TruncateStmt;
3346
3347 /* ----------------------
3348 * Comment On Statement
3349 * ----------------------
3350 */
3351 typedef struct CommentStmt
3352 {
3353 NodeTag type;
3354 ObjectType objtype; /* Object's type */
3355 Node *object; /* Qualified name of the object */
3356 char *comment; /* Comment to insert, or NULL to remove */
3357 } CommentStmt;
3358
3359 /* ----------------------
3360 * SECURITY LABEL Statement
3361 * ----------------------
3362 */
3363 typedef struct SecLabelStmt
3364 {
3365 NodeTag type;
3366 ObjectType objtype; /* Object's type */
3367 Node *object; /* Qualified name of the object */
3368 char *provider; /* Label provider (or NULL) */
3369 char *label; /* New security label to be assigned */
3370 } SecLabelStmt;
3371
3372 /* ----------------------
3373 * Declare Cursor Statement
3374 *
3375 * The "query" field is initially a raw parse tree, and is converted to a
3376 * Query node during parse analysis. Note that rewriting and planning
3377 * of the query are always postponed until execution.
3378 * ----------------------
3379 */
3380 #define CURSOR_OPT_BINARY 0x0001 /* BINARY */
3381 #define CURSOR_OPT_SCROLL 0x0002 /* SCROLL explicitly given */
3382 #define CURSOR_OPT_NO_SCROLL 0x0004 /* NO SCROLL explicitly given */
3383 #define CURSOR_OPT_INSENSITIVE 0x0008 /* INSENSITIVE */
3384 #define CURSOR_OPT_ASENSITIVE 0x0010 /* ASENSITIVE */
3385 #define CURSOR_OPT_HOLD 0x0020 /* WITH HOLD */
3386 /* these planner-control flags do not correspond to any SQL grammar: */
3387 #define CURSOR_OPT_FAST_PLAN 0x0100 /* prefer fast-start plan */
3388 #define CURSOR_OPT_GENERIC_PLAN 0x0200 /* force use of generic plan */
3389 #define CURSOR_OPT_CUSTOM_PLAN 0x0400 /* force use of custom plan */
3390 #define CURSOR_OPT_PARALLEL_OK 0x0800 /* parallel mode OK */
3391
3392 typedef struct DeclareCursorStmt
3393 {
3394 NodeTag type;
3395 char *portalname; /* name of the portal (cursor) */
3396 int options; /* bitmask of options (see above) */
3397 Node *query; /* the query (see comments above) */
3398 } DeclareCursorStmt;
3399
3400 /* ----------------------
3401 * Close Portal Statement
3402 * ----------------------
3403 */
3404 typedef struct ClosePortalStmt
3405 {
3406 NodeTag type;
3407 char *portalname; /* name of the portal (cursor) */
3408 /* NULL means CLOSE ALL */
3409 } ClosePortalStmt;
3410
3411 /* ----------------------
3412 * Fetch Statement (also Move)
3413 * ----------------------
3414 */
3415 typedef enum FetchDirection
3416 {
3417 /* for these, howMany is how many rows to fetch; FETCH_ALL means ALL */
3418 FETCH_FORWARD,
3419 FETCH_BACKWARD,
3420 /* for these, howMany indicates a position; only one row is fetched */
3421 FETCH_ABSOLUTE,
3422 FETCH_RELATIVE,
3423 } FetchDirection;
3424
3425 #define FETCH_ALL LONG_MAX
3426
3427 typedef struct FetchStmt
3428 {
3429 NodeTag type;
3430 FetchDirection direction; /* see above */
3431 long howMany; /* number of rows, or position argument */
3432 char *portalname; /* name of portal (cursor) */
3433 bool ismove; /* true if MOVE */
3434 } FetchStmt;
3435
3436 /* ----------------------
3437 * Create Index Statement
3438 *
3439 * This represents creation of an index and/or an associated constraint.
3440 * If isconstraint is true, we should create a pg_constraint entry along
3441 * with the index. But if indexOid isn't InvalidOid, we are not creating an
3442 * index, just a UNIQUE/PKEY constraint using an existing index. isconstraint
3443 * must always be true in this case, and the fields describing the index
3444 * properties are empty.
3445 * ----------------------
3446 */
3447 typedef struct IndexStmt
3448 {
3449 NodeTag type;
3450 char *idxname; /* name of new index, or NULL for default */
3451 RangeVar *relation; /* relation to build index on */
3452 char *accessMethod; /* name of access method (eg. btree) */
3453 char *tableSpace; /* tablespace, or NULL for default */
3454 List *indexParams; /* columns to index: a list of IndexElem */
3455 List *indexIncludingParams; /* additional columns to index: a list
3456 * of IndexElem */
3457 List *options; /* WITH clause options: a list of DefElem */
3458 Node *whereClause; /* qualification (partial-index predicate) */
3459 List *excludeOpNames; /* exclusion operator names, or NIL if none */
3460 char *idxcomment; /* comment to apply to index, or NULL */
3461 Oid indexOid; /* OID of an existing index, if any */
3462 RelFileNumber oldNumber; /* relfilenumber of existing storage, if any */
3463 SubTransactionId oldCreateSubid; /* rd_createSubid of oldNumber */
3464 SubTransactionId oldFirstRelfilelocatorSubid; /* rd_firstRelfilelocatorSubid
3465 * of oldNumber */
3466 bool unique; /* is index unique? */
3467 bool nulls_not_distinct; /* null treatment for UNIQUE constraints */
3468 bool primary; /* is index a primary key? */
3469 bool isconstraint; /* is it for a pkey/unique constraint? */
3470 bool iswithoutoverlaps; /* is the constraint WITHOUT OVERLAPS? */
3471 bool deferrable; /* is the constraint DEFERRABLE? */
3472 bool initdeferred; /* is the constraint INITIALLY DEFERRED? */
3473 bool transformed; /* true when transformIndexStmt is finished */
3474 bool concurrent; /* should this be a concurrent index build? */
3475 bool if_not_exists; /* just do nothing if index already exists? */
3476 bool reset_default_tblspc; /* reset default_tablespace prior to
3477 * executing */
3478 } IndexStmt;
3479
3480 /* ----------------------
3481 * Create Statistics Statement
3482 * ----------------------
3483 */
3484 typedef struct CreateStatsStmt
3485 {
3486 NodeTag type;
3487 List *defnames; /* qualified name (list of String) */
3488 List *stat_types; /* stat types (list of String) */
3489 List *exprs; /* expressions to build statistics on */
3490 List *relations; /* rels to build stats on (list of RangeVar) */
3491 char *stxcomment; /* comment to apply to stats, or NULL */
3492 bool transformed; /* true when transformStatsStmt is finished */
3493 bool if_not_exists; /* do nothing if stats name already exists */
3494 Oid owner; /* OID of owner, or InvalidOid for default */
3495 } CreateStatsStmt;
3496
3497 /*
3498 * StatsElem - statistics parameters (used in CREATE STATISTICS)
3499 *
3500 * For a plain attribute, 'name' is the name of the referenced table column
3501 * and 'expr' is NULL. For an expression, 'name' is NULL and 'expr' is the
3502 * expression tree.
3503 */
3504 typedef struct StatsElem
3505 {
3506 NodeTag type;
3507 char *name; /* name of attribute to index, or NULL */
3508 Node *expr; /* expression to index, or NULL */
3509 } StatsElem;
3510
3511
3512 /* ----------------------
3513 * Alter Statistics Statement
3514 * ----------------------
3515 */
3516 typedef struct AlterStatsStmt
3517 {
3518 NodeTag type;
3519 List *defnames; /* qualified name (list of String) */
3520 Node *stxstattarget; /* statistics target */
3521 bool missing_ok; /* skip error if statistics object is missing */
3522 } AlterStatsStmt;
3523
3524 /* ----------------------
3525 * Create Function Statement
3526 * ----------------------
3527 */
3528 typedef struct CreateFunctionStmt
3529 {
3530 NodeTag type;
3531 bool is_procedure; /* it's really CREATE PROCEDURE */
3532 bool replace; /* T => replace if already exists */
3533 List *funcname; /* qualified name of function to create */
3534 List *parameters; /* a list of FunctionParameter */
3535 TypeName *returnType; /* the return type */
3536 List *options; /* a list of DefElem */
3537 Node *sql_body;
3538 } CreateFunctionStmt;
3539
3540 typedef enum FunctionParameterMode
3541 {
3542 /* the assigned enum values appear in pg_proc, don't change 'em! */
3543 FUNC_PARAM_IN = 'i', /* input only */
3544 FUNC_PARAM_OUT = 'o', /* output only */
3545 FUNC_PARAM_INOUT = 'b', /* both */
3546 FUNC_PARAM_VARIADIC = 'v', /* variadic (always input) */
3547 FUNC_PARAM_TABLE = 't', /* table function output column */
3548 /* this is not used in pg_proc: */
3549 FUNC_PARAM_DEFAULT = 'd', /* default; effectively same as IN */
3550 } FunctionParameterMode;
3551
3552 typedef struct FunctionParameter
3553 {
3554 NodeTag type;
3555 char *name; /* parameter name, or NULL if not given */
3556 TypeName *argType; /* TypeName for parameter type */
3557 FunctionParameterMode mode; /* IN/OUT/etc */
3558 Node *defexpr; /* raw default expr, or NULL if not given */
3559 ParseLoc location; /* token location, or -1 if unknown */
3560 } FunctionParameter;
3561
3562 typedef struct AlterFunctionStmt
3563 {
3564 NodeTag type;
3565 ObjectType objtype;
3566 ObjectWithArgs *func; /* name and args of function */
3567 List *actions; /* list of DefElem */
3568 } AlterFunctionStmt;
3569
3570 /* ----------------------
3571 * DO Statement
3572 *
3573 * DoStmt is the raw parser output, InlineCodeBlock is the execution-time API
3574 * ----------------------
3575 */
3576 typedef struct DoStmt
3577 {
3578 NodeTag type;
3579 List *args; /* List of DefElem nodes */
3580 } DoStmt;
3581
3582 typedef struct InlineCodeBlock
3583 {
3584 pg_node_attr(nodetag_only) /* this is not a member of parse trees */
3585
3586 NodeTag type;
3587 char *source_text; /* source text of anonymous code block */
3588 Oid langOid; /* OID of selected language */
3589 bool langIsTrusted; /* trusted property of the language */
3590 bool atomic; /* atomic execution context */
3591 } InlineCodeBlock;
3592
3593 /* ----------------------
3594 * CALL statement
3595 *
3596 * OUT-mode arguments are removed from the transformed funcexpr. The outargs
3597 * list contains copies of the expressions for all output arguments, in the
3598 * order of the procedure's declared arguments. (outargs is never evaluated,
3599 * but is useful to the caller as a reference for what to assign to.)
3600 * The transformed call state is not relevant in the query jumbling, only the
3601 * function call is.
3602 * ----------------------
3603 */
3604 typedef struct CallStmt
3605 {
3606 NodeTag type;
3607 /* from the parser */
3608 FuncCall *funccall pg_node_attr(query_jumble_ignore);
3609 /* transformed call, with only input args */
3610 FuncExpr *funcexpr;
3611 /* transformed output-argument expressions */
3612 List *outargs;
3613 } CallStmt;
3614
3615 typedef struct CallContext
3616 {
3617 pg_node_attr(nodetag_only) /* this is not a member of parse trees */
3618
3619 NodeTag type;
3620 bool atomic;
3621 } CallContext;
3622
3623 /* ----------------------
3624 * Alter Object Rename Statement
3625 * ----------------------
3626 */
3627 typedef struct RenameStmt
3628 {
3629 NodeTag type;
3630 ObjectType renameType; /* OBJECT_TABLE, OBJECT_COLUMN, etc */
3631 ObjectType relationType; /* if column name, associated relation type */
3632 RangeVar *relation; /* in case it's a table */
3633 Node *object; /* in case it's some other object */
3634 char *subname; /* name of contained object (column, rule,
3635 * trigger, etc) */
3636 char *newname; /* the new name */
3637 DropBehavior behavior; /* RESTRICT or CASCADE behavior */
3638 bool missing_ok; /* skip error if missing? */
3639 } RenameStmt;
3640
3641 /* ----------------------
3642 * ALTER object DEPENDS ON EXTENSION extname
3643 * ----------------------
3644 */
3645 typedef struct AlterObjectDependsStmt
3646 {
3647 NodeTag type;
3648 ObjectType objectType; /* OBJECT_FUNCTION, OBJECT_TRIGGER, etc */
3649 RangeVar *relation; /* in case a table is involved */
3650 Node *object; /* name of the object */
3651 String *extname; /* extension name */
3652 bool remove; /* set true to remove dep rather than add */
3653 } AlterObjectDependsStmt;
3654
3655 /* ----------------------
3656 * ALTER object SET SCHEMA Statement
3657 * ----------------------
3658 */
3659 typedef struct AlterObjectSchemaStmt
3660 {
3661 NodeTag type;
3662 ObjectType objectType; /* OBJECT_TABLE, OBJECT_TYPE, etc */
3663 RangeVar *relation; /* in case it's a table */
3664 Node *object; /* in case it's some other object */
3665 char *newschema; /* the new schema */
3666 bool missing_ok; /* skip error if missing? */
3667 } AlterObjectSchemaStmt;
3668
3669 /* ----------------------
3670 * Alter Object Owner Statement
3671 * ----------------------
3672 */
3673 typedef struct AlterOwnerStmt
3674 {
3675 NodeTag type;
3676 ObjectType objectType; /* OBJECT_TABLE, OBJECT_TYPE, etc */
3677 RangeVar *relation; /* in case it's a table */
3678 Node *object; /* in case it's some other object */
3679 RoleSpec *newowner; /* the new owner */
3680 } AlterOwnerStmt;
3681
3682 /* ----------------------
3683 * Alter Operator Set ( this-n-that )
3684 * ----------------------
3685 */
3686 typedef struct AlterOperatorStmt
3687 {
3688 NodeTag type;
3689 ObjectWithArgs *opername; /* operator name and argument types */
3690 List *options; /* List of DefElem nodes */
3691 } AlterOperatorStmt;
3692
3693 /* ------------------------
3694 * Alter Type Set ( this-n-that )
3695 * ------------------------
3696 */
3697 typedef struct AlterTypeStmt
3698 {
3699 NodeTag type;
3700 List *typeName; /* type name (possibly qualified) */
3701 List *options; /* List of DefElem nodes */
3702 } AlterTypeStmt;
3703
3704 /* ----------------------
3705 * Create Rule Statement
3706 * ----------------------
3707 */
3708 typedef struct RuleStmt
3709 {
3710 NodeTag type;
3711 RangeVar *relation; /* relation the rule is for */
3712 char *rulename; /* name of the rule */
3713 Node *whereClause; /* qualifications */
3714 CmdType event; /* SELECT, INSERT, etc */
3715 bool instead; /* is a 'do instead'? */
3716 List *actions; /* the action statements */
3717 bool replace; /* OR REPLACE */
3718 } RuleStmt;
3719
3720 /* ----------------------
3721 * Notify Statement
3722 * ----------------------
3723 */
3724 typedef struct NotifyStmt
3725 {
3726 NodeTag type;
3727 char *conditionname; /* condition name to notify */
3728 char *payload; /* the payload string, or NULL if none */
3729 } NotifyStmt;
3730
3731 /* ----------------------
3732 * Listen Statement
3733 * ----------------------
3734 */
3735 typedef struct ListenStmt
3736 {
3737 NodeTag type;
3738 char *conditionname; /* condition name to listen on */
3739 } ListenStmt;
3740
3741 /* ----------------------
3742 * Unlisten Statement
3743 * ----------------------
3744 */
3745 typedef struct UnlistenStmt
3746 {
3747 NodeTag type;
3748 char *conditionname; /* name to unlisten on, or NULL for all */
3749 } UnlistenStmt;
3750
3751 /* ----------------------
3752 * {Begin|Commit|Rollback} Transaction Statement
3753 * ----------------------
3754 */
3755 typedef enum TransactionStmtKind
3756 {
3757 TRANS_STMT_BEGIN,
3758 TRANS_STMT_START, /* semantically identical to BEGIN */
3759 TRANS_STMT_COMMIT,
3760 TRANS_STMT_ROLLBACK,
3761 TRANS_STMT_SAVEPOINT,
3762 TRANS_STMT_RELEASE,
3763 TRANS_STMT_ROLLBACK_TO,
3764 TRANS_STMT_PREPARE,
3765 TRANS_STMT_COMMIT_PREPARED,
3766 TRANS_STMT_ROLLBACK_PREPARED,
3767 } TransactionStmtKind;
3768
3769 typedef struct TransactionStmt
3770 {
3771 NodeTag type;
3772 TransactionStmtKind kind; /* see above */
3773 List *options; /* for BEGIN/START commands */
3774 /* for savepoint commands */
3775 char *savepoint_name pg_node_attr(query_jumble_ignore);
3776 /* for two-phase-commit related commands */
3777 char *gid pg_node_attr(query_jumble_ignore);
3778 bool chain; /* AND CHAIN option */
3779 /* token location, or -1 if unknown */
3780 ParseLoc location pg_node_attr(query_jumble_location);
3781 } TransactionStmt;
3782
3783 /* ----------------------
3784 * Create Type Statement, composite types
3785 * ----------------------
3786 */
3787 typedef struct CompositeTypeStmt
3788 {
3789 NodeTag type;
3790 RangeVar *typevar; /* the composite type to be created */
3791 List *coldeflist; /* list of ColumnDef nodes */
3792 } CompositeTypeStmt;
3793
3794 /* ----------------------
3795 * Create Type Statement, enum types
3796 * ----------------------
3797 */
3798 typedef struct CreateEnumStmt
3799 {
3800 NodeTag type;
3801 List *typeName; /* qualified name (list of String) */
3802 List *vals; /* enum values (list of String) */
3803 } CreateEnumStmt;
3804
3805 /* ----------------------
3806 * Create Type Statement, range types
3807 * ----------------------
3808 */
3809 typedef struct CreateRangeStmt
3810 {
3811 NodeTag type;
3812 List *typeName; /* qualified name (list of String) */
3813 List *params; /* range parameters (list of DefElem) */
3814 } CreateRangeStmt;
3815
3816 /* ----------------------
3817 * Alter Type Statement, enum types
3818 * ----------------------
3819 */
3820 typedef struct AlterEnumStmt
3821 {
3822 NodeTag type;
3823 List *typeName; /* qualified name (list of String) */
3824 char *oldVal; /* old enum value's name, if renaming */
3825 char *newVal; /* new enum value's name */
3826 char *newValNeighbor; /* neighboring enum value, if specified */
3827 bool newValIsAfter; /* place new enum value after neighbor? */
3828 bool skipIfNewValExists; /* no error if new already exists? */
3829 } AlterEnumStmt;
3830
3831 /* ----------------------
3832 * Create View Statement
3833 * ----------------------
3834 */
3835 typedef enum ViewCheckOption
3836 {
3837 NO_CHECK_OPTION,
3838 LOCAL_CHECK_OPTION,
3839 CASCADED_CHECK_OPTION,
3840 } ViewCheckOption;
3841
3842 typedef struct ViewStmt
3843 {
3844 NodeTag type;
3845 RangeVar *view; /* the view to be created */
3846 List *aliases; /* target column names */
3847 Node *query; /* the SELECT query (as a raw parse tree) */
3848 bool replace; /* replace an existing view? */
3849 List *options; /* options from WITH clause */
3850 ViewCheckOption withCheckOption; /* WITH CHECK OPTION */
3851 } ViewStmt;
3852
3853 /* ----------------------
3854 * Load Statement
3855 * ----------------------
3856 */
3857 typedef struct LoadStmt
3858 {
3859 NodeTag type;
3860 char *filename; /* file to load */
3861 } LoadStmt;
3862
3863 /* ----------------------
3864 * Createdb Statement
3865 * ----------------------
3866 */
3867 typedef struct CreatedbStmt
3868 {
3869 NodeTag type;
3870 char *dbname; /* name of database to create */
3871 List *options; /* List of DefElem nodes */
3872 } CreatedbStmt;
3873
3874 /* ----------------------
3875 * Alter Database
3876 * ----------------------
3877 */
3878 typedef struct AlterDatabaseStmt
3879 {
3880 NodeTag type;
3881 char *dbname; /* name of database to alter */
3882 List *options; /* List of DefElem nodes */
3883 } AlterDatabaseStmt;
3884
3885 typedef struct AlterDatabaseRefreshCollStmt
3886 {
3887 NodeTag type;
3888 char *dbname;
3889 } AlterDatabaseRefreshCollStmt;
3890
3891 typedef struct AlterDatabaseSetStmt
3892 {
3893 NodeTag type;
3894 char *dbname; /* database name */
3895 VariableSetStmt *setstmt; /* SET or RESET subcommand */
3896 } AlterDatabaseSetStmt;
3897
3898 /* ----------------------
3899 * Dropdb Statement
3900 * ----------------------
3901 */
3902 typedef struct DropdbStmt
3903 {
3904 NodeTag type;
3905 char *dbname; /* database to drop */
3906 bool missing_ok; /* skip error if db is missing? */
3907 List *options; /* currently only FORCE is supported */
3908 } DropdbStmt;
3909
3910 /* ----------------------
3911 * Alter System Statement
3912 * ----------------------
3913 */
3914 typedef struct AlterSystemStmt
3915 {
3916 NodeTag type;
3917 VariableSetStmt *setstmt; /* SET subcommand */
3918 } AlterSystemStmt;
3919
3920 /* ----------------------
3921 * Cluster Statement (support pbrown's cluster index implementation)
3922 * ----------------------
3923 */
3924 typedef struct ClusterStmt
3925 {
3926 NodeTag type;
3927 RangeVar *relation; /* relation being indexed, or NULL if all */
3928 char *indexname; /* original index defined */
3929 List *params; /* list of DefElem nodes */
3930 } ClusterStmt;
3931
3932 /* ----------------------
3933 * Vacuum and Analyze Statements
3934 *
3935 * Even though these are nominally two statements, it's convenient to use
3936 * just one node type for both.
3937 * ----------------------
3938 */
3939 typedef struct VacuumStmt
3940 {
3941 NodeTag type;
3942 List *options; /* list of DefElem nodes */
3943 List *rels; /* list of VacuumRelation, or NIL for all */
3944 bool is_vacuumcmd; /* true for VACUUM, false for ANALYZE */
3945 } VacuumStmt;
3946
3947 /*
3948 * Info about a single target table of VACUUM/ANALYZE.
3949 *
3950 * If the OID field is set, it always identifies the table to process.
3951 * Then the relation field can be NULL; if it isn't, it's used only to report
3952 * failure to open/lock the relation.
3953 */
3954 typedef struct VacuumRelation
3955 {
3956 NodeTag type;
3957 RangeVar *relation; /* table name to process, or NULL */
3958 Oid oid; /* table's OID; InvalidOid if not looked up */
3959 List *va_cols; /* list of column names, or NIL for all */
3960 } VacuumRelation;
3961
3962 /* ----------------------
3963 * Explain Statement
3964 *
3965 * The "query" field is initially a raw parse tree, and is converted to a
3966 * Query node during parse analysis. Note that rewriting and planning
3967 * of the query are always postponed until execution.
3968 * ----------------------
3969 */
3970 typedef struct ExplainStmt
3971 {
3972 NodeTag type;
3973 Node *query; /* the query (see comments above) */
3974 List *options; /* list of DefElem nodes */
3975 } ExplainStmt;
3976
3977 /* ----------------------
3978 * CREATE TABLE AS Statement (a/k/a SELECT INTO)
3979 *
3980 * A query written as CREATE TABLE AS will produce this node type natively.
3981 * A query written as SELECT ... INTO will be transformed to this form during
3982 * parse analysis.
3983 * A query written as CREATE MATERIALIZED view will produce this node type,
3984 * during parse analysis, since it needs all the same data.
3985 *
3986 * The "query" field is handled similarly to EXPLAIN, though note that it
3987 * can be a SELECT or an EXECUTE, but not other DML statements.
3988 * ----------------------
3989 */
3990 typedef struct CreateTableAsStmt
3991 {
3992 NodeTag type;
3993 Node *query; /* the query (see comments above) */
3994 IntoClause *into; /* destination table */
3995 ObjectType objtype; /* OBJECT_TABLE or OBJECT_MATVIEW */
3996 bool is_select_into; /* it was written as SELECT INTO */
3997 bool if_not_exists; /* just do nothing if it already exists? */
3998 } CreateTableAsStmt;
3999
4000 /* ----------------------
4001 * REFRESH MATERIALIZED VIEW Statement
4002 * ----------------------
4003 */
4004 typedef struct RefreshMatViewStmt
4005 {
4006 NodeTag type;
4007 bool concurrent; /* allow concurrent access? */
4008 bool skipData; /* true for WITH NO DATA */
4009 RangeVar *relation; /* relation to insert into */
4010 } RefreshMatViewStmt;
4011
4012 /* ----------------------
4013 * Checkpoint Statement
4014 * ----------------------
4015 */
4016 typedef struct CheckPointStmt
4017 {
4018 NodeTag type;
4019 } CheckPointStmt;
4020
4021 /* ----------------------
4022 * Discard Statement
4023 * ----------------------
4024 */
4025
4026 typedef enum DiscardMode
4027 {
4028 DISCARD_ALL,
4029 DISCARD_PLANS,
4030 DISCARD_SEQUENCES,
4031 DISCARD_TEMP,
4032 } DiscardMode;
4033
4034 typedef struct DiscardStmt
4035 {
4036 NodeTag type;
4037 DiscardMode target;
4038 } DiscardStmt;
4039
4040 /* ----------------------
4041 * LOCK Statement
4042 * ----------------------
4043 */
4044 typedef struct LockStmt
4045 {
4046 NodeTag type;
4047 List *relations; /* relations to lock */
4048 int mode; /* lock mode */
4049 bool nowait; /* no wait mode */
4050 } LockStmt;
4051
4052 /* ----------------------
4053 * SET CONSTRAINTS Statement
4054 * ----------------------
4055 */
4056 typedef struct ConstraintsSetStmt
4057 {
4058 NodeTag type;
4059 List *constraints; /* List of names as RangeVars */
4060 bool deferred;
4061 } ConstraintsSetStmt;
4062
4063 /* ----------------------
4064 * REINDEX Statement
4065 * ----------------------
4066 */
4067 typedef enum ReindexObjectType
4068 {
4069 REINDEX_OBJECT_INDEX, /* index */
4070 REINDEX_OBJECT_TABLE, /* table or materialized view */
4071 REINDEX_OBJECT_SCHEMA, /* schema */
4072 REINDEX_OBJECT_SYSTEM, /* system catalogs */
4073 REINDEX_OBJECT_DATABASE, /* database */
4074 } ReindexObjectType;
4075
4076 typedef struct ReindexStmt
4077 {
4078 NodeTag type;
4079 ReindexObjectType kind; /* REINDEX_OBJECT_INDEX, REINDEX_OBJECT_TABLE,
4080 * etc. */
4081 RangeVar *relation; /* Table or index to reindex */
4082 const char *name; /* name of database to reindex */
4083 List *params; /* list of DefElem nodes */
4084 } ReindexStmt;
4085
4086 /* ----------------------
4087 * CREATE CONVERSION Statement
4088 * ----------------------
4089 */
4090 typedef struct CreateConversionStmt
4091 {
4092 NodeTag type;
4093 List *conversion_name; /* Name of the conversion */
4094 char *for_encoding_name; /* source encoding name */
4095 char *to_encoding_name; /* destination encoding name */
4096 List *func_name; /* qualified conversion function name */
4097 bool def; /* is this a default conversion? */
4098 } CreateConversionStmt;
4099
4100 /* ----------------------
4101 * CREATE CAST Statement
4102 * ----------------------
4103 */
4104 typedef struct CreateCastStmt
4105 {
4106 NodeTag type;
4107 TypeName *sourcetype;
4108 TypeName *targettype;
4109 ObjectWithArgs *func;
4110 CoercionContext context;
4111 bool inout;
4112 } CreateCastStmt;
4113
4114 /* ----------------------
4115 * CREATE TRANSFORM Statement
4116 * ----------------------
4117 */
4118 typedef struct CreateTransformStmt
4119 {
4120 NodeTag type;
4121 bool replace;
4122 TypeName *type_name;
4123 char *lang;
4124 ObjectWithArgs *fromsql;
4125 ObjectWithArgs *tosql;
4126 } CreateTransformStmt;
4127
4128 /* ----------------------
4129 * PREPARE Statement
4130 * ----------------------
4131 */
4132 typedef struct PrepareStmt
4133 {
4134 NodeTag type;
4135 char *name; /* Name of plan, arbitrary */
4136 List *argtypes; /* Types of parameters (List of TypeName) */
4137 Node *query; /* The query itself (as a raw parsetree) */
4138 } PrepareStmt;
4139
4140
4141 /* ----------------------
4142 * EXECUTE Statement
4143 * ----------------------
4144 */
4145
4146 typedef struct ExecuteStmt
4147 {
4148 NodeTag type;
4149 char *name; /* The name of the plan to execute */
4150 List *params; /* Values to assign to parameters */
4151 } ExecuteStmt;
4152
4153
4154 /* ----------------------
4155 * DEALLOCATE Statement
4156 * ----------------------
4157 */
4158 typedef struct DeallocateStmt
4159 {
4160 NodeTag type;
4161 /* The name of the plan to remove, NULL if DEALLOCATE ALL */
4162 char *name pg_node_attr(query_jumble_ignore);
4163
4164 /*
4165 * True if DEALLOCATE ALL. This is redundant with "name == NULL", but we
4166 * make it a separate field so that exactly this condition (and not the
4167 * precise name) will be accounted for in query jumbling.
4168 */
4169 bool isall;
4170 /* token location, or -1 if unknown */
4171 ParseLoc location pg_node_attr(query_jumble_location);
4172 } DeallocateStmt;
4173
4174 /*
4175 * DROP OWNED statement
4176 */
4177 typedef struct DropOwnedStmt
4178 {
4179 NodeTag type;
4180 List *roles;
4181 DropBehavior behavior;
4182 } DropOwnedStmt;
4183
4184 /*
4185 * REASSIGN OWNED statement
4186 */
4187 typedef struct ReassignOwnedStmt
4188 {
4189 NodeTag type;
4190 List *roles;
4191 RoleSpec *newrole;
4192 } ReassignOwnedStmt;
4193
4194 /*
4195 * TS Dictionary stmts: DefineStmt, RenameStmt and DropStmt are default
4196 */
4197 typedef struct AlterTSDictionaryStmt
4198 {
4199 NodeTag type;
4200 List *dictname; /* qualified name (list of String) */
4201 List *options; /* List of DefElem nodes */
4202 } AlterTSDictionaryStmt;
4203
4204 /*
4205 * TS Configuration stmts: DefineStmt, RenameStmt and DropStmt are default
4206 */
4207 typedef enum AlterTSConfigType
4208 {
4209 ALTER_TSCONFIG_ADD_MAPPING,
4210 ALTER_TSCONFIG_ALTER_MAPPING_FOR_TOKEN,
4211 ALTER_TSCONFIG_REPLACE_DICT,
4212 ALTER_TSCONFIG_REPLACE_DICT_FOR_TOKEN,
4213 ALTER_TSCONFIG_DROP_MAPPING,
4214 } AlterTSConfigType;
4215
4216 typedef struct AlterTSConfigurationStmt
4217 {
4218 NodeTag type;
4219 AlterTSConfigType kind; /* ALTER_TSCONFIG_ADD_MAPPING, etc */
4220 List *cfgname; /* qualified name (list of String) */
4221
4222 /*
4223 * dicts will be non-NIL if ADD/ALTER MAPPING was specified. If dicts is
4224 * NIL, but tokentype isn't, DROP MAPPING was specified.
4225 */
4226 List *tokentype; /* list of String */
4227 List *dicts; /* list of list of String */
4228 bool override; /* if true - remove old variant */
4229 bool replace; /* if true - replace dictionary by another */
4230 bool missing_ok; /* for DROP - skip error if missing? */
4231 } AlterTSConfigurationStmt;
4232
4233 typedef struct PublicationTable
4234 {
4235 NodeTag type;
4236 RangeVar *relation; /* relation to be published */
4237 Node *whereClause; /* qualifications */
4238 List *columns; /* List of columns in a publication table */
4239 } PublicationTable;
4240
4241 /*
4242 * Publication object type
4243 */
4244 typedef enum PublicationObjSpecType
4245 {
4246 PUBLICATIONOBJ_TABLE, /* A table */
4247 PUBLICATIONOBJ_TABLES_IN_SCHEMA, /* All tables in schema */
4248 PUBLICATIONOBJ_TABLES_IN_CUR_SCHEMA, /* All tables in first element of
4249 * search_path */
4250 PUBLICATIONOBJ_CONTINUATION, /* Continuation of previous type */
4251 } PublicationObjSpecType;
4252
4253 typedef struct PublicationObjSpec
4254 {
4255 NodeTag type;
4256 PublicationObjSpecType pubobjtype; /* type of this publication object */
4257 char *name;
4258 PublicationTable *pubtable;
4259 ParseLoc location; /* token location, or -1 if unknown */
4260 } PublicationObjSpec;
4261
4262 typedef struct CreatePublicationStmt
4263 {
4264 NodeTag type;
4265 char *pubname; /* Name of the publication */
4266 List *options; /* List of DefElem nodes */
4267 List *pubobjects; /* Optional list of publication objects */
4268 bool for_all_tables; /* Special publication for all tables in db */
4269 } CreatePublicationStmt;
4270
4271 typedef enum AlterPublicationAction
4272 {
4273 AP_AddObjects, /* add objects to publication */
4274 AP_DropObjects, /* remove objects from publication */
4275 AP_SetObjects, /* set list of objects */
4276 } AlterPublicationAction;
4277
4278 typedef struct AlterPublicationStmt
4279 {
4280 NodeTag type;
4281 char *pubname; /* Name of the publication */
4282
4283 /* parameters used for ALTER PUBLICATION ... WITH */
4284 List *options; /* List of DefElem nodes */
4285
4286 /*
4287 * Parameters used for ALTER PUBLICATION ... ADD/DROP/SET publication
4288 * objects.
4289 */
4290 List *pubobjects; /* Optional list of publication objects */
4291 bool for_all_tables; /* Special publication for all tables in db */
4292 AlterPublicationAction action; /* What action to perform with the given
4293 * objects */
4294 } AlterPublicationStmt;
4295
4296 typedef struct CreateSubscriptionStmt
4297 {
4298 NodeTag type;
4299 char *subname; /* Name of the subscription */
4300 char *conninfo; /* Connection string to publisher */
4301 List *publication; /* One or more publication to subscribe to */
4302 List *options; /* List of DefElem nodes */
4303 } CreateSubscriptionStmt;
4304
4305 typedef enum AlterSubscriptionType
4306 {
4307 ALTER_SUBSCRIPTION_OPTIONS,
4308 ALTER_SUBSCRIPTION_CONNECTION,
4309 ALTER_SUBSCRIPTION_SET_PUBLICATION,
4310 ALTER_SUBSCRIPTION_ADD_PUBLICATION,
4311 ALTER_SUBSCRIPTION_DROP_PUBLICATION,
4312 ALTER_SUBSCRIPTION_REFRESH,
4313 ALTER_SUBSCRIPTION_ENABLED,
4314 ALTER_SUBSCRIPTION_SKIP,
4315 } AlterSubscriptionType;
4316
4317 typedef struct AlterSubscriptionStmt
4318 {
4319 NodeTag type;
4320 AlterSubscriptionType kind; /* ALTER_SUBSCRIPTION_OPTIONS, etc */
4321 char *subname; /* Name of the subscription */
4322 char *conninfo; /* Connection string to publisher */
4323 List *publication; /* One or more publication to subscribe to */
4324 List *options; /* List of DefElem nodes */
4325 } AlterSubscriptionStmt;
4326
4327 typedef struct DropSubscriptionStmt
4328 {
4329 NodeTag type;
4330 char *subname; /* Name of the subscription */
4331 bool missing_ok; /* Skip error if missing? */
4332 DropBehavior behavior; /* RESTRICT or CASCADE behavior */
4333 } DropSubscriptionStmt;
4334
4335 #endif /* PARSENODES_H */