1 /*-------------------------------------------------------------------------
2 *
3 * nodes.h
4 * Definitions for tagged nodes.
5 *
6 *
7 * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 * src/include/nodes/nodes.h
11 *
12 *-------------------------------------------------------------------------
13 */
14 #ifndef NODES_H
15 #define NODES_H
16
17 /*
18 * The first field of every node is NodeTag. Each node created (with makeNode)
19 * will have one of the following tags as the value of its first field.
20 *
21 * Note that inserting or deleting node types changes the numbers of other
22 * node types later in the list. This is no problem during development, since
23 * the node numbers are never stored on disk. But don't do it in a released
24 * branch, because that would represent an ABI break for extensions.
25 */
26 typedef enum NodeTag
27 {
28 T_Invalid = 0,
29
30 /*
31 * TAGS FOR EXECUTOR NODES (execnodes.h)
32 */
33 T_IndexInfo,
34 T_ExprContext,
35 T_ProjectionInfo,
36 T_JunkFilter,
37 T_ResultRelInfo,
38 T_EState,
39 T_TupleTableSlot,
40
41 /*
42 * TAGS FOR PLAN NODES (plannodes.h)
43 */
44 T_Plan,
45 T_Result,
46 T_ProjectSet,
47 T_ModifyTable,
48 T_Append,
49 T_MergeAppend,
50 T_RecursiveUnion,
51 T_BitmapAnd,
52 T_BitmapOr,
53 T_Scan,
54 T_SeqScan,
55 T_SampleScan,
56 T_IndexScan,
57 T_IndexOnlyScan,
58 T_BitmapIndexScan,
59 T_BitmapHeapScan,
60 T_TidScan,
61 T_SubqueryScan,
62 T_FunctionScan,
63 T_ValuesScan,
64 T_TableFuncScan,
65 T_CteScan,
66 T_NamedTuplestoreScan,
67 T_WorkTableScan,
68 T_ForeignScan,
69 T_CustomScan,
70 T_Join,
71 T_NestLoop,
72 T_MergeJoin,
73 T_HashJoin,
74 T_Material,
75 T_Sort,
76 T_Group,
77 T_Agg,
78 T_WindowAgg,
79 T_Unique,
80 T_Gather,
81 T_GatherMerge,
82 T_Hash,
83 T_SetOp,
84 T_LockRows,
85 T_Limit,
86 /* these aren't subclasses of Plan: */
87 T_NestLoopParam,
88 T_PlanRowMark,
89 T_PlanInvalItem,
90
91 /*
92 * TAGS FOR PLAN STATE NODES (execnodes.h)
93 *
94 * These should correspond one-to-one with Plan node types.
95 */
96 T_PlanState,
97 T_ResultState,
98 T_ProjectSetState,
99 T_ModifyTableState,
100 T_AppendState,
101 T_MergeAppendState,
102 T_RecursiveUnionState,
103 T_BitmapAndState,
104 T_BitmapOrState,
105 T_ScanState,
106 T_SeqScanState,
107 T_SampleScanState,
108 T_IndexScanState,
109 T_IndexOnlyScanState,
110 T_BitmapIndexScanState,
111 T_BitmapHeapScanState,
112 T_TidScanState,
113 T_SubqueryScanState,
114 T_FunctionScanState,
115 T_TableFuncScanState,
116 T_ValuesScanState,
117 T_CteScanState,
118 T_NamedTuplestoreScanState,
119 T_WorkTableScanState,
120 T_ForeignScanState,
121 T_CustomScanState,
122 T_JoinState,
123 T_NestLoopState,
124 T_MergeJoinState,
125 T_HashJoinState,
126 T_MaterialState,
127 T_SortState,
128 T_GroupState,
129 T_AggState,
130 T_WindowAggState,
131 T_UniqueState,
132 T_GatherState,
133 T_GatherMergeState,
134 T_HashState,
135 T_SetOpState,
136 T_LockRowsState,
137 T_LimitState,
138
139 /*
140 * TAGS FOR PRIMITIVE NODES (primnodes.h)
141 */
142 T_Alias,
143 T_RangeVar,
144 T_TableFunc,
145 T_Expr,
146 T_Var,
147 T_Const,
148 T_Param,
149 T_Aggref,
150 T_GroupingFunc,
151 T_WindowFunc,
152 T_ArrayRef,
153 T_FuncExpr,
154 T_NamedArgExpr,
155 T_OpExpr,
156 T_DistinctExpr,
157 T_NullIfExpr,
158 T_ScalarArrayOpExpr,
159 T_BoolExpr,
160 T_SubLink,
161 T_SubPlan,
162 T_AlternativeSubPlan,
163 T_FieldSelect,
164 T_FieldStore,
165 T_RelabelType,
166 T_CoerceViaIO,
167 T_ArrayCoerceExpr,
168 T_ConvertRowtypeExpr,
169 T_CollateExpr,
170 T_CaseExpr,
171 T_CaseWhen,
172 T_CaseTestExpr,
173 T_ArrayExpr,
174 T_RowExpr,
175 T_RowCompareExpr,
176 T_CoalesceExpr,
177 T_MinMaxExpr,
178 T_SQLValueFunction,
179 T_XmlExpr,
180 T_NullTest,
181 T_BooleanTest,
182 T_CoerceToDomain,
183 T_CoerceToDomainValue,
184 T_SetToDefault,
185 T_CurrentOfExpr,
186 T_NextValueExpr,
187 T_InferenceElem,
188 T_TargetEntry,
189 T_RangeTblRef,
190 T_JoinExpr,
191 T_FromExpr,
192 T_OnConflictExpr,
193 T_IntoClause,
194
195 /*
196 * TAGS FOR EXPRESSION STATE NODES (execnodes.h)
197 *
198 * ExprState represents the evaluation state for a whole expression tree.
199 * Most Expr-based plan nodes do not have a corresponding expression state
200 * node, they're fully handled within execExpr* - but sometimes the state
201 * needs to be shared with other parts of the executor, as for example
202 * with AggrefExprState, which nodeAgg.c has to modify.
203 */
204 T_ExprState,
205 T_AggrefExprState,
206 T_WindowFuncExprState,
207 T_SetExprState,
208 T_SubPlanState,
209 T_AlternativeSubPlanState,
210 T_DomainConstraintState,
211
212 /*
213 * TAGS FOR PLANNER NODES (relation.h)
214 */
215 T_PlannerInfo,
216 T_PlannerGlobal,
217 T_RelOptInfo,
218 T_IndexOptInfo,
219 T_ForeignKeyOptInfo,
220 T_ParamPathInfo,
221 T_Path,
222 T_IndexPath,
223 T_BitmapHeapPath,
224 T_BitmapAndPath,
225 T_BitmapOrPath,
226 T_TidPath,
227 T_SubqueryScanPath,
228 T_ForeignPath,
229 T_CustomPath,
230 T_NestPath,
231 T_MergePath,
232 T_HashPath,
233 T_AppendPath,
234 T_MergeAppendPath,
235 T_ResultPath,
236 T_MaterialPath,
237 T_UniquePath,
238 T_GatherPath,
239 T_GatherMergePath,
240 T_ProjectionPath,
241 T_ProjectSetPath,
242 T_SortPath,
243 T_GroupPath,
244 T_UpperUniquePath,
245 T_AggPath,
246 T_GroupingSetsPath,
247 T_MinMaxAggPath,
248 T_WindowAggPath,
249 T_SetOpPath,
250 T_RecursiveUnionPath,
251 T_LockRowsPath,
252 T_ModifyTablePath,
253 T_LimitPath,
254 /* these aren't subclasses of Path: */
255 T_EquivalenceClass,
256 T_EquivalenceMember,
257 T_PathKey,
258 T_PathTarget,
259 T_RestrictInfo,
260 T_PlaceHolderVar,
261 T_SpecialJoinInfo,
262 T_AppendRelInfo,
263 T_PartitionedChildRelInfo,
264 T_PlaceHolderInfo,
265 T_MinMaxAggInfo,
266 T_PlannerParamItem,
267 T_RollupData,
268 T_GroupingSetData,
269 T_StatisticExtInfo,
270
271 /*
272 * TAGS FOR MEMORY NODES (memnodes.h)
273 */
274 T_MemoryContext,
275 T_AllocSetContext,
276 T_SlabContext,
277
278 /*
279 * TAGS FOR VALUE NODES (value.h)
280 */
281 T_Value,
282 T_Integer,
283 T_Float,
284 T_String,
285 T_BitString,
286 T_Null,
287
288 /*
289 * TAGS FOR LIST NODES (pg_list.h)
290 */
291 T_List,
292 T_IntList,
293 T_OidList,
294
295 /*
296 * TAGS FOR EXTENSIBLE NODES (extensible.h)
297 */
298 T_ExtensibleNode,
299
300 /*
301 * TAGS FOR STATEMENT NODES (mostly in parsenodes.h)
302 */
303 T_RawStmt,
304 T_Query,
305 T_PlannedStmt,
306 T_InsertStmt,
307 T_DeleteStmt,
308 T_UpdateStmt,
309 T_SelectStmt,
310 T_AlterTableStmt,
311 T_AlterTableCmd,
312 T_AlterDomainStmt,
313 T_SetOperationStmt,
314 T_GrantStmt,
315 T_GrantRoleStmt,
316 T_AlterDefaultPrivilegesStmt,
317 T_ClosePortalStmt,
318 T_ClusterStmt,
319 T_CopyStmt,
320 T_CreateStmt,
321 T_DefineStmt,
322 T_DropStmt,
323 T_TruncateStmt,
324 T_CommentStmt,
325 T_FetchStmt,
326 T_IndexStmt,
327 T_CreateFunctionStmt,
328 T_AlterFunctionStmt,
329 T_DoStmt,
330 T_RenameStmt,
331 T_RuleStmt,
332 T_NotifyStmt,
333 T_ListenStmt,
334 T_UnlistenStmt,
335 T_TransactionStmt,
336 T_ViewStmt,
337 T_LoadStmt,
338 T_CreateDomainStmt,
339 T_CreatedbStmt,
340 T_DropdbStmt,
341 T_VacuumStmt,
342 T_ExplainStmt,
343 T_CreateTableAsStmt,
344 T_CreateSeqStmt,
345 T_AlterSeqStmt,
346 T_VariableSetStmt,
347 T_VariableShowStmt,
348 T_DiscardStmt,
349 T_CreateTrigStmt,
350 T_CreatePLangStmt,
351 T_CreateRoleStmt,
352 T_AlterRoleStmt,
353 T_DropRoleStmt,
354 T_LockStmt,
355 T_ConstraintsSetStmt,
356 T_ReindexStmt,
357 T_CheckPointStmt,
358 T_CreateSchemaStmt,
359 T_AlterDatabaseStmt,
360 T_AlterDatabaseSetStmt,
361 T_AlterRoleSetStmt,
362 T_CreateConversionStmt,
363 T_CreateCastStmt,
364 T_CreateOpClassStmt,
365 T_CreateOpFamilyStmt,
366 T_AlterOpFamilyStmt,
367 T_PrepareStmt,
368 T_ExecuteStmt,
369 T_DeallocateStmt,
370 T_DeclareCursorStmt,
371 T_CreateTableSpaceStmt,
372 T_DropTableSpaceStmt,
373 T_AlterObjectDependsStmt,
374 T_AlterObjectSchemaStmt,
375 T_AlterOwnerStmt,
376 T_AlterOperatorStmt,
377 T_DropOwnedStmt,
378 T_ReassignOwnedStmt,
379 T_CompositeTypeStmt,
380 T_CreateEnumStmt,
381 T_CreateRangeStmt,
382 T_AlterEnumStmt,
383 T_AlterTSDictionaryStmt,
384 T_AlterTSConfigurationStmt,
385 T_CreateFdwStmt,
386 T_AlterFdwStmt,
387 T_CreateForeignServerStmt,
388 T_AlterForeignServerStmt,
389 T_CreateUserMappingStmt,
390 T_AlterUserMappingStmt,
391 T_DropUserMappingStmt,
392 T_AlterTableSpaceOptionsStmt,
393 T_AlterTableMoveAllStmt,
394 T_SecLabelStmt,
395 T_CreateForeignTableStmt,
396 T_ImportForeignSchemaStmt,
397 T_CreateExtensionStmt,
398 T_AlterExtensionStmt,
399 T_AlterExtensionContentsStmt,
400 T_CreateEventTrigStmt,
401 T_AlterEventTrigStmt,
402 T_RefreshMatViewStmt,
403 T_ReplicaIdentityStmt,
404 T_AlterSystemStmt,
405 T_CreatePolicyStmt,
406 T_AlterPolicyStmt,
407 T_CreateTransformStmt,
408 T_CreateAmStmt,
409 T_CreatePublicationStmt,
410 T_AlterPublicationStmt,
411 T_CreateSubscriptionStmt,
412 T_AlterSubscriptionStmt,
413 T_DropSubscriptionStmt,
414 T_CreateStatsStmt,
415 T_AlterCollationStmt,
416
417 /*
418 * TAGS FOR PARSE TREE NODES (parsenodes.h)
419 */
420 T_A_Expr,
421 T_ColumnRef,
422 T_ParamRef,
423 T_A_Const,
424 T_FuncCall,
425 T_A_Star,
426 T_A_Indices,
427 T_A_Indirection,
428 T_A_ArrayExpr,
429 T_ResTarget,
430 T_MultiAssignRef,
431 T_TypeCast,
432 T_CollateClause,
433 T_SortBy,
434 T_WindowDef,
435 T_RangeSubselect,
436 T_RangeFunction,
437 T_RangeTableSample,
438 T_RangeTableFunc,
439 T_RangeTableFuncCol,
440 T_TypeName,
441 T_ColumnDef,
442 T_IndexElem,
443 T_Constraint,
444 T_DefElem,
445 T_RangeTblEntry,
446 T_RangeTblFunction,
447 T_TableSampleClause,
448 T_WithCheckOption,
449 T_SortGroupClause,
450 T_GroupingSet,
451 T_WindowClause,
452 T_ObjectWithArgs,
453 T_AccessPriv,
454 T_CreateOpClassItem,
455 T_TableLikeClause,
456 T_FunctionParameter,
457 T_LockingClause,
458 T_RowMarkClause,
459 T_XmlSerialize,
460 T_WithClause,
461 T_InferClause,
462 T_OnConflictClause,
463 T_CommonTableExpr,
464 T_RoleSpec,
465 T_TriggerTransition,
466 T_PartitionElem,
467 T_PartitionSpec,
468 T_PartitionBoundSpec,
469 T_PartitionRangeDatum,
470 T_PartitionCmd,
471
472 /*
473 * TAGS FOR REPLICATION GRAMMAR PARSE NODES (replnodes.h)
474 */
475 T_IdentifySystemCmd,
476 T_BaseBackupCmd,
477 T_CreateReplicationSlotCmd,
478 T_DropReplicationSlotCmd,
479 T_StartReplicationCmd,
480 T_TimeLineHistoryCmd,
481 T_SQLCmd,
482
483 /*
484 * TAGS FOR RANDOM OTHER STUFF
485 *
486 * These are objects that aren't part of parse/plan/execute node tree
487 * structures, but we give them NodeTags anyway for identification
488 * purposes (usually because they are involved in APIs where we want to
489 * pass multiple object types through the same pointer).
490 */
491 T_TriggerData, /* in commands/trigger.h */
492 T_EventTriggerData, /* in commands/event_trigger.h */
493 T_ReturnSetInfo, /* in nodes/execnodes.h */
494 T_WindowObjectData, /* private in nodeWindowAgg.c */
495 T_TIDBitmap, /* in nodes/tidbitmap.h */
496 T_InlineCodeBlock, /* in nodes/parsenodes.h */
497 T_FdwRoutine, /* in foreign/fdwapi.h */
498 T_IndexAmRoutine, /* in access/amapi.h */
499 T_TsmRoutine, /* in access/tsmapi.h */
500 T_ForeignKeyCacheInfo /* in utils/rel.h */
501 } NodeTag;
502
503 /*
504 * The first field of a node of any type is guaranteed to be the NodeTag.
505 * Hence the type of any node can be gotten by casting it to Node. Declaring
506 * a variable to be of Node * (instead of void *) can also facilitate
507 * debugging.
508 */
509 typedef struct Node
510 {
511 NodeTag type;
512 } Node;
513
514 #define nodeTag(nodeptr) (((const Node*)(nodeptr))->type)
515
516 /*
517 * newNode -
518 * create a new node of the specified size and tag the node with the
519 * specified tag.
520 *
521 * !WARNING!: Avoid using newNode directly. You should be using the
522 * macro makeNode. eg. to create a Query node, use makeNode(Query)
523 *
524 * Note: the size argument should always be a compile-time constant, so the
525 * apparent risk of multiple evaluation doesn't matter in practice.
526 */
527 #ifdef __GNUC__
528
529 /* With GCC, we can use a compound statement within an expression */
530 #define newNode(size, tag) \
531 ({ Node *_result; \
532 AssertMacro((size) >= sizeof(Node)); /* need the tag, at least */ \
533 _result = (Node *) palloc0fast(size); \
534 _result->type = (tag); \
535 _result; \
536 })
537 #else
538
539 /*
540 * There is no way to dereference the palloc'ed pointer to assign the
541 * tag, and also return the pointer itself, so we need a holder variable.
542 * Fortunately, this macro isn't recursive so we just define
543 * a global variable for this purpose.
544 */
545 extern PGDLLIMPORT Node *newNodeMacroHolder;
546
547 #define newNode(size, tag) \
548 ( \
549 AssertMacro((size) >= sizeof(Node)), /* need the tag, at least */ \
550 newNodeMacroHolder = (Node *) palloc0fast(size), \
551 newNodeMacroHolder->type = (tag), \
552 newNodeMacroHolder \
553 )
554 #endif /* __GNUC__ */
555
556
557 #define makeNode(_type_) ((_type_ *) newNode(sizeof(_type_),T_##_type_))
558 #define NodeSetTag(nodeptr,t) (((Node*)(nodeptr))->type = (t))
559
560 #define IsA(nodeptr,_type_) (nodeTag(nodeptr) == T_##_type_)
561
562 /*
563 * castNode(type, ptr) casts ptr to "type *", and if assertions are enabled,
564 * verifies that the node has the appropriate type (using its nodeTag()).
565 *
566 * Use an inline function when assertions are enabled, to avoid multiple
567 * evaluations of the ptr argument (which could e.g. be a function call).
568 */
569 #ifdef USE_ASSERT_CHECKING
570 static inline Node *
castNodeImpl(NodeTag type,void * ptr)571 castNodeImpl(NodeTag type, void *ptr)
572 {
573 Assert(ptr == NULL || nodeTag(ptr) == type);
574 return (Node *) ptr;
575 }
576 #define castNode(_type_, nodeptr) ((_type_ *) castNodeImpl(T_##_type_, nodeptr))
577 #else
578 #define castNode(_type_, nodeptr) ((_type_ *) (nodeptr))
579 #endif /* USE_ASSERT_CHECKING */
580
581
582 /* ----------------------------------------------------------------
583 * extern declarations follow
584 * ----------------------------------------------------------------
585 */
586
587 /*
588 * nodes/{outfuncs.c,print.c}
589 */
590 struct Bitmapset; /* not to include bitmapset.h here */
591 struct StringInfoData; /* not to include stringinfo.h here */
592
593 extern void outNode(struct StringInfoData *str, const void *obj);
594 extern void outToken(struct StringInfoData *str, const char *s);
595 extern void outBitmapset(struct StringInfoData *str,
596 const struct Bitmapset *bms);
597 extern void outDatum(struct StringInfoData *str, uintptr_t value,
598 int typlen, bool typbyval);
599 extern char *nodeToString(const void *obj);
600 extern char *bmsToString(const struct Bitmapset *bms);
601
602 /*
603 * nodes/{readfuncs.c,read.c}
604 */
605 extern void *stringToNode(char *str);
606 extern struct Bitmapset *readBitmapset(void);
607 extern uintptr_t readDatum(bool typbyval);
608 extern bool *readBoolCols(int numCols);
609 extern int *readIntCols(int numCols);
610 extern Oid *readOidCols(int numCols);
611 extern int16 *readAttrNumberCols(int numCols);
612
613 /*
614 * nodes/copyfuncs.c
615 */
616 extern void *copyObjectImpl(const void *obj);
617
618 /* cast result back to argument type, if supported by compiler */
619 #ifdef HAVE_TYPEOF
620 #define copyObject(obj) ((typeof(obj)) copyObjectImpl(obj))
621 #else
622 #define copyObject(obj) copyObjectImpl(obj)
623 #endif
624
625 /*
626 * nodes/equalfuncs.c
627 */
628 extern bool equal(const void *a, const void *b);
629
630
631 /*
632 * Typedefs for identifying qualifier selectivities and plan costs as such.
633 * These are just plain "double"s, but declaring a variable as Selectivity
634 * or Cost makes the intent more obvious.
635 *
636 * These could have gone into plannodes.h or some such, but many files
637 * depend on them...
638 */
639 typedef double Selectivity; /* fraction of tuples a qualifier will pass */
640 typedef double Cost; /* execution cost (in page-access units) */
641
642
643 /*
644 * CmdType -
645 * enums for type of operation represented by a Query or PlannedStmt
646 *
647 * This is needed in both parsenodes.h and plannodes.h, so put it here...
648 */
649 typedef enum CmdType
650 {
651 CMD_UNKNOWN,
652 CMD_SELECT, /* select stmt */
653 CMD_UPDATE, /* update stmt */
654 CMD_INSERT, /* insert stmt */
655 CMD_DELETE,
656 CMD_UTILITY, /* cmds like create, destroy, copy, vacuum,
657 * etc. */
658 CMD_NOTHING /* dummy command for instead nothing rules
659 * with qual */
660 } CmdType;
661
662
663 /*
664 * JoinType -
665 * enums for types of relation joins
666 *
667 * JoinType determines the exact semantics of joining two relations using
668 * a matching qualification. For example, it tells what to do with a tuple
669 * that has no match in the other relation.
670 *
671 * This is needed in both parsenodes.h and plannodes.h, so put it here...
672 */
673 typedef enum JoinType
674 {
675 /*
676 * The canonical kinds of joins according to the SQL JOIN syntax. Only
677 * these codes can appear in parser output (e.g., JoinExpr nodes).
678 */
679 JOIN_INNER, /* matching tuple pairs only */
680 JOIN_LEFT, /* pairs + unmatched LHS tuples */
681 JOIN_FULL, /* pairs + unmatched LHS + unmatched RHS */
682 JOIN_RIGHT, /* pairs + unmatched RHS tuples */
683
684 /*
685 * Semijoins and anti-semijoins (as defined in relational theory) do not
686 * appear in the SQL JOIN syntax, but there are standard idioms for
687 * representing them (e.g., using EXISTS). The planner recognizes these
688 * cases and converts them to joins. So the planner and executor must
689 * support these codes. NOTE: in JOIN_SEMI output, it is unspecified
690 * which matching RHS row is joined to. In JOIN_ANTI output, the row is
691 * guaranteed to be null-extended.
692 */
693 JOIN_SEMI, /* 1 copy of each LHS row that has match(es) */
694 JOIN_ANTI, /* 1 copy of each LHS row that has no match */
695
696 /*
697 * These codes are used internally in the planner, but are not supported
698 * by the executor (nor, indeed, by most of the planner).
699 */
700 JOIN_UNIQUE_OUTER, /* LHS path must be made unique */
701 JOIN_UNIQUE_INNER /* RHS path must be made unique */
702
703 /*
704 * We might need additional join types someday.
705 */
706 } JoinType;
707
708 /*
709 * OUTER joins are those for which pushed-down quals must behave differently
710 * from the join's own quals. This is in fact everything except INNER and
711 * SEMI joins. However, this macro must also exclude the JOIN_UNIQUE symbols
712 * since those are temporary proxies for what will eventually be an INNER
713 * join.
714 *
715 * Note: semijoins are a hybrid case, but we choose to treat them as not
716 * being outer joins. This is okay principally because the SQL syntax makes
717 * it impossible to have a pushed-down qual that refers to the inner relation
718 * of a semijoin; so there is no strong need to distinguish join quals from
719 * pushed-down quals. This is convenient because for almost all purposes,
720 * quals attached to a semijoin can be treated the same as innerjoin quals.
721 */
722 #define IS_OUTER_JOIN(jointype) \
723 (((1 << (jointype)) & \
724 ((1 << JOIN_LEFT) | \
725 (1 << JOIN_FULL) | \
726 (1 << JOIN_RIGHT) | \
727 (1 << JOIN_ANTI))) != 0)
728
729 /*
730 * AggStrategy -
731 * overall execution strategies for Agg plan nodes
732 *
733 * This is needed in both plannodes.h and relation.h, so put it here...
734 */
735 typedef enum AggStrategy
736 {
737 AGG_PLAIN, /* simple agg across all input rows */
738 AGG_SORTED, /* grouped agg, input must be sorted */
739 AGG_HASHED, /* grouped agg, use internal hashtable */
740 AGG_MIXED /* grouped agg, hash and sort both used */
741 } AggStrategy;
742
743 /*
744 * AggSplit -
745 * splitting (partial aggregation) modes for Agg plan nodes
746 *
747 * This is needed in both plannodes.h and relation.h, so put it here...
748 */
749
750 /* Primitive options supported by nodeAgg.c: */
751 #define AGGSPLITOP_COMBINE 0x01 /* substitute combinefn for transfn */
752 #define AGGSPLITOP_SKIPFINAL 0x02 /* skip finalfn, return state as-is */
753 #define AGGSPLITOP_SERIALIZE 0x04 /* apply serializefn to output */
754 #define AGGSPLITOP_DESERIALIZE 0x08 /* apply deserializefn to input */
755
756 /* Supported operating modes (i.e., useful combinations of these options): */
757 typedef enum AggSplit
758 {
759 /* Basic, non-split aggregation: */
760 AGGSPLIT_SIMPLE = 0,
761 /* Initial phase of partial aggregation, with serialization: */
762 AGGSPLIT_INITIAL_SERIAL = AGGSPLITOP_SKIPFINAL | AGGSPLITOP_SERIALIZE,
763 /* Final phase of partial aggregation, with deserialization: */
764 AGGSPLIT_FINAL_DESERIAL = AGGSPLITOP_COMBINE | AGGSPLITOP_DESERIALIZE
765 } AggSplit;
766
767 /* Test whether an AggSplit value selects each primitive option: */
768 #define DO_AGGSPLIT_COMBINE(as) (((as) & AGGSPLITOP_COMBINE) != 0)
769 #define DO_AGGSPLIT_SKIPFINAL(as) (((as) & AGGSPLITOP_SKIPFINAL) != 0)
770 #define DO_AGGSPLIT_SERIALIZE(as) (((as) & AGGSPLITOP_SERIALIZE) != 0)
771 #define DO_AGGSPLIT_DESERIALIZE(as) (((as) & AGGSPLITOP_DESERIALIZE) != 0)
772
773 /*
774 * SetOpCmd and SetOpStrategy -
775 * overall semantics and execution strategies for SetOp plan nodes
776 *
777 * This is needed in both plannodes.h and relation.h, so put it here...
778 */
779 typedef enum SetOpCmd
780 {
781 SETOPCMD_INTERSECT,
782 SETOPCMD_INTERSECT_ALL,
783 SETOPCMD_EXCEPT,
784 SETOPCMD_EXCEPT_ALL
785 } SetOpCmd;
786
787 typedef enum SetOpStrategy
788 {
789 SETOP_SORTED, /* input must be sorted */
790 SETOP_HASHED /* use internal hashtable */
791 } SetOpStrategy;
792
793 /*
794 * OnConflictAction -
795 * "ON CONFLICT" clause type of query
796 *
797 * This is needed in both parsenodes.h and plannodes.h, so put it here...
798 */
799 typedef enum OnConflictAction
800 {
801 ONCONFLICT_NONE, /* No "ON CONFLICT" clause */
802 ONCONFLICT_NOTHING, /* ON CONFLICT ... DO NOTHING */
803 ONCONFLICT_UPDATE /* ON CONFLICT ... DO UPDATE */
804 } OnConflictAction;
805
806 #endif /* NODES_H */
807