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