]> granicus.if.org Git - postgresql/blob - src/include/nodes/nodes.h
Core support for "extensions", which are packages of SQL objects.
[postgresql] / src / include / nodes / nodes.h
1 /*-------------------------------------------------------------------------
2  *
3  * nodes.h
4  *        Definitions for tagged nodes.
5  *
6  *
7  * Portions Copyright (c) 1996-2011, 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 the numbers of the node tags are not contiguous. We left holes
22  * here so that we can add more tags without changing the existing enum's.
23  * (Since node tag numbers never exist outside backend memory, there's no
24  * real harm in renumbering, it just costs a full rebuild ...)
25  */
26 typedef enum NodeTag
27 {
28         T_Invalid = 0,
29
30         /*
31          * TAGS FOR EXECUTOR NODES (execnodes.h)
32          */
33         T_IndexInfo = 10,
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 = 100,
45         T_Result,
46         T_ModifyTable,
47         T_Append,
48         T_MergeAppend,
49         T_RecursiveUnion,
50         T_BitmapAnd,
51         T_BitmapOr,
52         T_Scan,
53         T_SeqScan,
54         T_IndexScan,
55         T_BitmapIndexScan,
56         T_BitmapHeapScan,
57         T_TidScan,
58         T_SubqueryScan,
59         T_FunctionScan,
60         T_ValuesScan,
61         T_CteScan,
62         T_WorkTableScan,
63         T_Join,
64         T_NestLoop,
65         T_MergeJoin,
66         T_HashJoin,
67         T_Material,
68         T_Sort,
69         T_Group,
70         T_Agg,
71         T_WindowAgg,
72         T_Unique,
73         T_Hash,
74         T_SetOp,
75         T_LockRows,
76         T_Limit,
77         /* these aren't subclasses of Plan: */
78         T_NestLoopParam,
79         T_PlanRowMark,
80         T_PlanInvalItem,
81
82         /*
83          * TAGS FOR PLAN STATE NODES (execnodes.h)
84          *
85          * These should correspond one-to-one with Plan node types.
86          */
87         T_PlanState = 200,
88         T_ResultState,
89         T_ModifyTableState,
90         T_AppendState,
91         T_MergeAppendState,
92         T_RecursiveUnionState,
93         T_BitmapAndState,
94         T_BitmapOrState,
95         T_ScanState,
96         T_SeqScanState,
97         T_IndexScanState,
98         T_BitmapIndexScanState,
99         T_BitmapHeapScanState,
100         T_TidScanState,
101         T_SubqueryScanState,
102         T_FunctionScanState,
103         T_ValuesScanState,
104         T_CteScanState,
105         T_WorkTableScanState,
106         T_JoinState,
107         T_NestLoopState,
108         T_MergeJoinState,
109         T_HashJoinState,
110         T_MaterialState,
111         T_SortState,
112         T_GroupState,
113         T_AggState,
114         T_WindowAggState,
115         T_UniqueState,
116         T_HashState,
117         T_SetOpState,
118         T_LockRowsState,
119         T_LimitState,
120
121         /*
122          * TAGS FOR PRIMITIVE NODES (primnodes.h)
123          */
124         T_Alias = 300,
125         T_RangeVar,
126         T_Expr,
127         T_Var,
128         T_Const,
129         T_Param,
130         T_Aggref,
131         T_WindowFunc,
132         T_ArrayRef,
133         T_FuncExpr,
134         T_NamedArgExpr,
135         T_OpExpr,
136         T_DistinctExpr,
137         T_ScalarArrayOpExpr,
138         T_BoolExpr,
139         T_SubLink,
140         T_SubPlan,
141         T_AlternativeSubPlan,
142         T_FieldSelect,
143         T_FieldStore,
144         T_RelabelType,
145         T_CoerceViaIO,
146         T_ArrayCoerceExpr,
147         T_ConvertRowtypeExpr,
148         T_CaseExpr,
149         T_CaseWhen,
150         T_CaseTestExpr,
151         T_ArrayExpr,
152         T_RowExpr,
153         T_RowCompareExpr,
154         T_CoalesceExpr,
155         T_MinMaxExpr,
156         T_XmlExpr,
157         T_NullIfExpr,
158         T_NullTest,
159         T_BooleanTest,
160         T_CoerceToDomain,
161         T_CoerceToDomainValue,
162         T_SetToDefault,
163         T_CurrentOfExpr,
164         T_TargetEntry,
165         T_RangeTblRef,
166         T_JoinExpr,
167         T_FromExpr,
168         T_IntoClause,
169         T_CollateClause,
170
171         /*
172          * TAGS FOR EXPRESSION STATE NODES (execnodes.h)
173          *
174          * These correspond (not always one-for-one) to primitive nodes derived
175          * from Expr.
176          */
177         T_ExprState = 400,
178         T_GenericExprState,
179         T_AggrefExprState,
180         T_WindowFuncExprState,
181         T_ArrayRefExprState,
182         T_FuncExprState,
183         T_ScalarArrayOpExprState,
184         T_BoolExprState,
185         T_SubPlanState,
186         T_AlternativeSubPlanState,
187         T_FieldSelectState,
188         T_FieldStoreState,
189         T_CoerceViaIOState,
190         T_ArrayCoerceExprState,
191         T_ConvertRowtypeExprState,
192         T_CaseExprState,
193         T_CaseWhenState,
194         T_ArrayExprState,
195         T_RowExprState,
196         T_RowCompareExprState,
197         T_CoalesceExprState,
198         T_MinMaxExprState,
199         T_XmlExprState,
200         T_NullTestState,
201         T_CoerceToDomainState,
202         T_DomainConstraintState,
203
204         /*
205          * TAGS FOR PLANNER NODES (relation.h)
206          */
207         T_PlannerInfo = 500,
208         T_PlannerGlobal,
209         T_RelOptInfo,
210         T_IndexOptInfo,
211         T_Path,
212         T_IndexPath,
213         T_BitmapHeapPath,
214         T_BitmapAndPath,
215         T_BitmapOrPath,
216         T_NestPath,
217         T_MergePath,
218         T_HashPath,
219         T_TidPath,
220         T_AppendPath,
221         T_MergeAppendPath,
222         T_ResultPath,
223         T_MaterialPath,
224         T_UniquePath,
225         T_EquivalenceClass,
226         T_EquivalenceMember,
227         T_PathKey,
228         T_RestrictInfo,
229         T_InnerIndexscanInfo,
230         T_PlaceHolderVar,
231         T_SpecialJoinInfo,
232         T_AppendRelInfo,
233         T_PlaceHolderInfo,
234         T_MinMaxAggInfo,
235         T_PlannerParamItem,
236
237         /*
238          * TAGS FOR MEMORY NODES (memnodes.h)
239          */
240         T_MemoryContext = 600,
241         T_AllocSetContext,
242
243         /*
244          * TAGS FOR VALUE NODES (value.h)
245          */
246         T_Value = 650,
247         T_Integer,
248         T_Float,
249         T_String,
250         T_BitString,
251         T_Null,
252
253         /*
254          * TAGS FOR LIST NODES (pg_list.h)
255          */
256         T_List,
257         T_IntList,
258         T_OidList,
259
260         /*
261          * TAGS FOR STATEMENT NODES (mostly in parsenodes.h)
262          */
263         T_Query = 700,
264         T_PlannedStmt,
265         T_InsertStmt,
266         T_DeleteStmt,
267         T_UpdateStmt,
268         T_SelectStmt,
269         T_AlterTableStmt,
270         T_AlterTableCmd,
271         T_AlterDomainStmt,
272         T_SetOperationStmt,
273         T_GrantStmt,
274         T_GrantRoleStmt,
275         T_AlterDefaultPrivilegesStmt,
276         T_ClosePortalStmt,
277         T_ClusterStmt,
278         T_CopyStmt,
279         T_CreateStmt,
280         T_DefineStmt,
281         T_DropStmt,
282         T_TruncateStmt,
283         T_CommentStmt,
284         T_FetchStmt,
285         T_IndexStmt,
286         T_CreateFunctionStmt,
287         T_AlterFunctionStmt,
288         T_RemoveFuncStmt,
289         T_DoStmt,
290         T_RenameStmt,
291         T_RuleStmt,
292         T_NotifyStmt,
293         T_ListenStmt,
294         T_UnlistenStmt,
295         T_TransactionStmt,
296         T_ViewStmt,
297         T_LoadStmt,
298         T_CreateDomainStmt,
299         T_CreatedbStmt,
300         T_DropdbStmt,
301         T_VacuumStmt,
302         T_ExplainStmt,
303         T_CreateSeqStmt,
304         T_AlterSeqStmt,
305         T_VariableSetStmt,
306         T_VariableShowStmt,
307         T_DiscardStmt,
308         T_CreateTrigStmt,
309         T_DropPropertyStmt,
310         T_CreatePLangStmt,
311         T_DropPLangStmt,
312         T_CreateRoleStmt,
313         T_AlterRoleStmt,
314         T_DropRoleStmt,
315         T_LockStmt,
316         T_ConstraintsSetStmt,
317         T_ReindexStmt,
318         T_CheckPointStmt,
319         T_CreateSchemaStmt,
320         T_AlterDatabaseStmt,
321         T_AlterDatabaseSetStmt,
322         T_AlterRoleSetStmt,
323         T_CreateConversionStmt,
324         T_CreateCastStmt,
325         T_DropCastStmt,
326         T_CreateOpClassStmt,
327         T_CreateOpFamilyStmt,
328         T_AlterOpFamilyStmt,
329         T_RemoveOpClassStmt,
330         T_RemoveOpFamilyStmt,
331         T_PrepareStmt,
332         T_ExecuteStmt,
333         T_DeallocateStmt,
334         T_DeclareCursorStmt,
335         T_CreateTableSpaceStmt,
336         T_DropTableSpaceStmt,
337         T_AlterObjectSchemaStmt,
338         T_AlterOwnerStmt,
339         T_DropOwnedStmt,
340         T_ReassignOwnedStmt,
341         T_CompositeTypeStmt,
342         T_CreateEnumStmt,
343         T_AlterEnumStmt,
344         T_AlterTSDictionaryStmt,
345         T_AlterTSConfigurationStmt,
346         T_CreateFdwStmt,
347         T_AlterFdwStmt,
348         T_DropFdwStmt,
349         T_CreateForeignServerStmt,
350         T_AlterForeignServerStmt,
351         T_DropForeignServerStmt,
352         T_CreateUserMappingStmt,
353         T_AlterUserMappingStmt,
354         T_DropUserMappingStmt,
355         T_AlterTableSpaceOptionsStmt,
356         T_SecLabelStmt,
357         T_CreateForeignTableStmt,
358         T_CreateExtensionStmt,
359
360         /*
361          * TAGS FOR PARSE TREE NODES (parsenodes.h)
362          */
363         T_A_Expr = 900,
364         T_ColumnRef,
365         T_ParamRef,
366         T_A_Const,
367         T_FuncCall,
368         T_A_Star,
369         T_A_Indices,
370         T_A_Indirection,
371         T_A_ArrayExpr,
372         T_ResTarget,
373         T_TypeCast,
374         T_SortBy,
375         T_WindowDef,
376         T_RangeSubselect,
377         T_RangeFunction,
378         T_TypeName,
379         T_ColumnDef,
380         T_IndexElem,
381         T_Constraint,
382         T_DefElem,
383         T_RangeTblEntry,
384         T_SortGroupClause,
385         T_WindowClause,
386         T_PrivGrantee,
387         T_FuncWithArgs,
388         T_AccessPriv,
389         T_CreateOpClassItem,
390         T_InhRelation,
391         T_FunctionParameter,
392         T_LockingClause,
393         T_RowMarkClause,
394         T_XmlSerialize,
395         T_WithClause,
396         T_CommonTableExpr,
397
398         /*
399          * TAGS FOR RANDOM OTHER STUFF
400          *
401          * These are objects that aren't part of parse/plan/execute node tree
402          * structures, but we give them NodeTags anyway for identification
403          * purposes (usually because they are involved in APIs where we want to
404          * pass multiple object types through the same pointer).
405          */
406         T_TriggerData = 950,            /* in commands/trigger.h */
407         T_ReturnSetInfo,                        /* in nodes/execnodes.h */
408         T_WindowObjectData,                     /* private in nodeWindowAgg.c */
409         T_TIDBitmap,                            /* in nodes/tidbitmap.h */
410         T_InlineCodeBlock                       /* in nodes/parsenodes.h */
411 } NodeTag;
412
413 /*
414  * The first field of a node of any type is guaranteed to be the NodeTag.
415  * Hence the type of any node can be gotten by casting it to Node. Declaring
416  * a variable to be of Node * (instead of void *) can also facilitate
417  * debugging.
418  */
419 typedef struct Node
420 {
421         NodeTag         type;
422 } Node;
423
424 #define nodeTag(nodeptr)                (((Node*)(nodeptr))->type)
425
426 /*
427  * newNode -
428  *        create a new node of the specified size and tag the node with the
429  *        specified tag.
430  *
431  * !WARNING!: Avoid using newNode directly. You should be using the
432  *        macro makeNode.  eg. to create a Query node, use makeNode(Query)
433  *
434  * Note: the size argument should always be a compile-time constant, so the
435  * apparent risk of multiple evaluation doesn't matter in practice.
436  */
437 #ifdef __GNUC__
438
439 /* With GCC, we can use a compound statement within an expression */
440 #define newNode(size, tag) \
441 ({      Node   *_result; \
442         AssertMacro((size) >= sizeof(Node));            /* need the tag, at least */ \
443         _result = (Node *) palloc0fast(size); \
444         _result->type = (tag); \
445         _result; \
446 })
447 #else
448
449 /*
450  *      There is no way to dereference the palloc'ed pointer to assign the
451  *      tag, and also return the pointer itself, so we need a holder variable.
452  *      Fortunately, this macro isn't recursive so we just define
453  *      a global variable for this purpose.
454  */
455 extern PGDLLIMPORT Node *newNodeMacroHolder;
456
457 #define newNode(size, tag) \
458 ( \
459         AssertMacro((size) >= sizeof(Node)),            /* need the tag, at least */ \
460         newNodeMacroHolder = (Node *) palloc0fast(size), \
461         newNodeMacroHolder->type = (tag), \
462         newNodeMacroHolder \
463 )
464 #endif   /* __GNUC__ */
465
466
467 #define makeNode(_type_)                ((_type_ *) newNode(sizeof(_type_),T_##_type_))
468 #define NodeSetTag(nodeptr,t)   (((Node*)(nodeptr))->type = (t))
469
470 #define IsA(nodeptr,_type_)             (nodeTag(nodeptr) == T_##_type_)
471
472 /* ----------------------------------------------------------------
473  *                                        extern declarations follow
474  * ----------------------------------------------------------------
475  */
476
477 /*
478  * nodes/{outfuncs.c,print.c}
479  */
480 extern char *nodeToString(void *obj);
481
482 /*
483  * nodes/{readfuncs.c,read.c}
484  */
485 extern void *stringToNode(char *str);
486
487 /*
488  * nodes/copyfuncs.c
489  */
490 extern void *copyObject(void *obj);
491
492 /*
493  * nodes/equalfuncs.c
494  */
495 extern bool equal(void *a, void *b);
496
497
498 /*
499  * Typedefs for identifying qualifier selectivities and plan costs as such.
500  * These are just plain "double"s, but declaring a variable as Selectivity
501  * or Cost makes the intent more obvious.
502  *
503  * These could have gone into plannodes.h or some such, but many files
504  * depend on them...
505  */
506 typedef double Selectivity;             /* fraction of tuples a qualifier will pass */
507 typedef double Cost;                    /* execution cost (in page-access units) */
508
509
510 /*
511  * CmdType -
512  *        enums for type of operation represented by a Query or PlannedStmt
513  *
514  * This is needed in both parsenodes.h and plannodes.h, so put it here...
515  */
516 typedef enum CmdType
517 {
518         CMD_UNKNOWN,
519         CMD_SELECT,                                     /* select stmt */
520         CMD_UPDATE,                                     /* update stmt */
521         CMD_INSERT,                                     /* insert stmt */
522         CMD_DELETE,
523         CMD_UTILITY,                            /* cmds like create, destroy, copy, vacuum,
524                                                                  * etc. */
525         CMD_NOTHING                                     /* dummy command for instead nothing rules
526                                                                  * with qual */
527 } CmdType;
528
529
530 /*
531  * JoinType -
532  *        enums for types of relation joins
533  *
534  * JoinType determines the exact semantics of joining two relations using
535  * a matching qualification.  For example, it tells what to do with a tuple
536  * that has no match in the other relation.
537  *
538  * This is needed in both parsenodes.h and plannodes.h, so put it here...
539  */
540 typedef enum JoinType
541 {
542         /*
543          * The canonical kinds of joins according to the SQL JOIN syntax. Only
544          * these codes can appear in parser output (e.g., JoinExpr nodes).
545          */
546         JOIN_INNER,                                     /* matching tuple pairs only */
547         JOIN_LEFT,                                      /* pairs + unmatched LHS tuples */
548         JOIN_FULL,                                      /* pairs + unmatched LHS + unmatched RHS */
549         JOIN_RIGHT,                                     /* pairs + unmatched RHS tuples */
550
551         /*
552          * Semijoins and anti-semijoins (as defined in relational theory) do not
553          * appear in the SQL JOIN syntax, but there are standard idioms for
554          * representing them (e.g., using EXISTS).      The planner recognizes these
555          * cases and converts them to joins.  So the planner and executor must
556          * support these codes.  NOTE: in JOIN_SEMI output, it is unspecified
557          * which matching RHS row is joined to.  In JOIN_ANTI output, the row is
558          * guaranteed to be null-extended.
559          */
560         JOIN_SEMI,                                      /* 1 copy of each LHS row that has match(es) */
561         JOIN_ANTI,                                      /* 1 copy of each LHS row that has no match */
562
563         /*
564          * These codes are used internally in the planner, but are not supported
565          * by the executor (nor, indeed, by most of the planner).
566          */
567         JOIN_UNIQUE_OUTER,                      /* LHS path must be made unique */
568         JOIN_UNIQUE_INNER                       /* RHS path must be made unique */
569
570         /*
571          * We might need additional join types someday.
572          */
573 } JoinType;
574
575 /*
576  * OUTER joins are those for which pushed-down quals must behave differently
577  * from the join's own quals.  This is in fact everything except INNER and
578  * SEMI joins.  However, this macro must also exclude the JOIN_UNIQUE symbols
579  * since those are temporary proxies for what will eventually be an INNER
580  * join.
581  *
582  * Note: semijoins are a hybrid case, but we choose to treat them as not
583  * being outer joins.  This is okay principally because the SQL syntax makes
584  * it impossible to have a pushed-down qual that refers to the inner relation
585  * of a semijoin; so there is no strong need to distinguish join quals from
586  * pushed-down quals.  This is convenient because for almost all purposes,
587  * quals attached to a semijoin can be treated the same as innerjoin quals.
588  */
589 #define IS_OUTER_JOIN(jointype) \
590         (((1 << (jointype)) & \
591           ((1 << JOIN_LEFT) | \
592            (1 << JOIN_FULL) | \
593            (1 << JOIN_RIGHT) | \
594            (1 << JOIN_ANTI))) != 0)
595
596 #endif   /* NODES_H */