PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
plannodes.h
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * plannodes.h
4 * definitions for query plan nodes
5 *
6 *
7 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 * src/include/nodes/plannodes.h
11 *
12 *-------------------------------------------------------------------------
13 */
14#ifndef PLANNODES_H
15#define PLANNODES_H
16
17#include "access/sdir.h"
18#include "access/stratnum.h"
19#include "common/relpath.h"
20#include "lib/stringinfo.h"
21#include "nodes/bitmapset.h"
22#include "nodes/lockoptions.h"
23#include "nodes/primnodes.h"
24
25
26/* ----------------------------------------------------------------
27 * node definitions
28 * ----------------------------------------------------------------
29 */
30
31/* ----------------
32 * PlannedStmt node
33 *
34 * The output of the planner is a Plan tree headed by a PlannedStmt node.
35 * PlannedStmt holds the "one time" information needed by the executor.
36 *
37 * For simplicity in APIs, we also wrap utility statements in PlannedStmt
38 * nodes; in such cases, commandType == CMD_UTILITY, the statement itself
39 * is in the utilityStmt field, and the rest of the struct is mostly dummy.
40 * (We do use canSetTag, stmt_location, stmt_len, and possibly queryId.)
41 *
42 * PlannedStmt, as well as all varieties of Plan, do not support equal(),
43 * not because it's not sensible but because we currently have no need.
44 * ----------------
45 */
46typedef struct PlannedStmt
47{
48 pg_node_attr(no_equal, no_query_jumble)
49
51
52 CmdType commandType; /* select|insert|update|delete|merge|utility */
53
54 uint64 queryId; /* query identifier (copied from Query) */
55
56 bool hasReturning; /* is it insert|update|delete|merge RETURNING? */
57
58 bool hasModifyingCTE; /* has insert|update|delete|merge in WITH? */
59
60 bool canSetTag; /* do I set the command result tag? */
61
62 bool transientPlan; /* redo plan when TransactionXmin changes? */
63
64 bool dependsOnRole; /* is plan specific to current role? */
65
66 bool parallelModeNeeded; /* parallel mode required to execute? */
67
68 int jitFlags; /* which forms of JIT should be performed */
69
70 struct Plan *planTree; /* tree of Plan nodes */
71
72 List *rtable; /* list of RangeTblEntry nodes */
73
74 List *permInfos; /* list of RTEPermissionInfo nodes for rtable
75 * entries needing one */
76
77 /* rtable indexes of target relations for INSERT/UPDATE/DELETE/MERGE */
78 List *resultRelations; /* integer list of RT indexes, or NIL */
79
80 List *appendRelations; /* list of AppendRelInfo nodes */
81
82 List *subplans; /* Plan trees for SubPlan expressions; note
83 * that some could be NULL */
84
85 Bitmapset *rewindPlanIDs; /* indices of subplans that require REWIND */
86
87 List *rowMarks; /* a list of PlanRowMark's */
88
89 List *relationOids; /* OIDs of relations the plan depends on */
90
91 List *invalItems; /* other dependencies, as PlanInvalItems */
92
93 List *paramExecTypes; /* type OIDs for PARAM_EXEC Params */
94
95 Node *utilityStmt; /* non-null if this is utility stmt */
96
97 /* statement location in source string (copied from Query) */
98 ParseLoc stmt_location; /* start location, or -1 if unknown */
99 ParseLoc stmt_len; /* length in bytes; 0 means "rest of string" */
101
102/* macro for fetching the Plan associated with a SubPlan node */
103#define exec_subplan_get_plan(plannedstmt, subplan) \
104 ((Plan *) list_nth((plannedstmt)->subplans, (subplan)->plan_id - 1))
105
106
107/* ----------------
108 * Plan node
109 *
110 * All plan nodes "derive" from the Plan structure by having the
111 * Plan structure as the first field. This ensures that everything works
112 * when nodes are cast to Plan's. (node pointers are frequently cast to Plan*
113 * when passed around generically in the executor)
114 *
115 * We never actually instantiate any Plan nodes; this is just the common
116 * abstract superclass for all Plan-type nodes.
117 * ----------------
118 */
119typedef struct Plan
120{
121 pg_node_attr(abstract, no_equal, no_query_jumble)
122
124
125 /*
126 * estimated execution costs for plan (see costsize.c for more info)
127 */
128 int disabled_nodes; /* count of disabled nodes */
129 Cost startup_cost; /* cost expended before fetching any tuples */
130 Cost total_cost; /* total cost (assuming all tuples fetched) */
131
132 /*
133 * planner's estimate of result size of this plan step
134 */
135 Cardinality plan_rows; /* number of rows plan is expected to emit */
136 int plan_width; /* average row width in bytes */
137
138 /*
139 * information needed for parallel query
140 */
141 bool parallel_aware; /* engage parallel-aware logic? */
142 bool parallel_safe; /* OK to use as part of parallel plan? */
143
144 /*
145 * information needed for asynchronous execution
146 */
147 bool async_capable; /* engage asynchronous-capable logic? */
148
149 /*
150 * Common structural data for all Plan types.
151 */
152 int plan_node_id; /* unique across entire final plan tree */
153 List *targetlist; /* target list to be computed at this node */
154 List *qual; /* implicitly-ANDed qual conditions */
155 struct Plan *lefttree; /* input plan tree(s) */
157 List *initPlan; /* Init Plan nodes (un-correlated expr
158 * subselects) */
159
160 /*
161 * Information for management of parameter-change-driven rescanning
162 *
163 * extParam includes the paramIDs of all external PARAM_EXEC params
164 * affecting this plan node or its children. setParam params from the
165 * node's initPlans are not included, but their extParams are.
166 *
167 * allParam includes all the extParam paramIDs, plus the IDs of local
168 * params that affect the node (i.e., the setParams of its initplans).
169 * These are _all_ the PARAM_EXEC params that affect this node.
170 */
174
175/* ----------------
176 * these are defined to avoid confusion problems with "left"
177 * and "right" and "inner" and "outer". The convention is that
178 * the "left" plan is the "outer" plan and the "right" plan is
179 * the inner plan, but these make the code more readable.
180 * ----------------
181 */
182#define innerPlan(node) (((Plan *)(node))->righttree)
183#define outerPlan(node) (((Plan *)(node))->lefttree)
184
185
186/* ----------------
187 * Result node -
188 * If no outer plan, evaluate a variable-free targetlist.
189 * If outer plan, return tuples from outer plan (after a level of
190 * projection as shown by targetlist).
191 *
192 * If resconstantqual isn't NULL, it represents a one-time qualification
193 * test (i.e., one that doesn't depend on any variables from the outer plan,
194 * so needs to be evaluated only once).
195 * ----------------
196 */
197typedef struct Result
198{
202
203/* ----------------
204 * ProjectSet node -
205 * Apply a projection that includes set-returning functions to the
206 * output tuples of the outer plan.
207 * ----------------
208 */
209typedef struct ProjectSet
210{
213
214/* ----------------
215 * ModifyTable node -
216 * Apply rows produced by outer plan to result table(s),
217 * by inserting, updating, or deleting.
218 *
219 * If the originally named target table is a partitioned table or inheritance
220 * tree, both nominalRelation and rootRelation contain the RT index of the
221 * partition root or appendrel RTE, which is not otherwise mentioned in the
222 * plan. Otherwise rootRelation is zero. However, nominalRelation will
223 * always be set, as it's the rel that EXPLAIN should claim is the
224 * INSERT/UPDATE/DELETE/MERGE target.
225 *
226 * Note that rowMarks and epqParam are presumed to be valid for all the
227 * table(s); they can't contain any info that varies across tables.
228 * ----------------
229 */
230typedef struct ModifyTable
231{
233 CmdType operation; /* INSERT, UPDATE, DELETE, or MERGE */
234 bool canSetTag; /* do we set the command tag/es_processed? */
235 Index nominalRelation; /* Parent RT index for use of EXPLAIN */
236 Index rootRelation; /* Root RT index, if partitioned/inherited */
237 bool partColsUpdated; /* some part key in hierarchy updated? */
238 List *resultRelations; /* integer list of RT indexes */
239 List *updateColnosLists; /* per-target-table update_colnos lists */
240 List *withCheckOptionLists; /* per-target-table WCO lists */
241 List *returningLists; /* per-target-table RETURNING tlists */
242 List *fdwPrivLists; /* per-target-table FDW private data lists */
243 Bitmapset *fdwDirectModifyPlans; /* indices of FDW DM plans */
244 List *rowMarks; /* PlanRowMarks (non-locking only) */
245 int epqParam; /* ID of Param for EvalPlanQual re-eval */
246 OnConflictAction onConflictAction; /* ON CONFLICT action */
247 List *arbiterIndexes; /* List of ON CONFLICT arbiter index OIDs */
248 List *onConflictSet; /* INSERT ON CONFLICT DO UPDATE targetlist */
249 List *onConflictCols; /* target column numbers for onConflictSet */
250 Node *onConflictWhere; /* WHERE for ON CONFLICT UPDATE */
251 Index exclRelRTI; /* RTI of the EXCLUDED pseudo relation */
252 List *exclRelTlist; /* tlist of the EXCLUDED pseudo relation */
253 List *mergeActionLists; /* per-target-table lists of actions for
254 * MERGE */
255 List *mergeJoinConditions; /* per-target-table join conditions
256 * for MERGE */
258
259struct PartitionPruneInfo; /* forward reference to struct below */
260
261/* ----------------
262 * Append node -
263 * Generate the concatenation of the results of sub-plans.
264 * ----------------
265 */
266typedef struct Append
267{
269 Bitmapset *apprelids; /* RTIs of appendrel(s) formed by this node */
271 int nasyncplans; /* # of asynchronous plans */
272
273 /*
274 * All 'appendplans' preceding this index are non-partial plans. All
275 * 'appendplans' from this index onwards are partial plans.
276 */
278
279 /* Info for run-time subplan pruning; NULL if we're not doing that */
282
283/* ----------------
284 * MergeAppend node -
285 * Merge the results of pre-sorted sub-plans to preserve the ordering.
286 * ----------------
287 */
288typedef struct MergeAppend
289{
291
292 /* RTIs of appendrel(s) formed by this node */
294
296
297 /* these fields are just like the sort-key info in struct Sort: */
298
299 /* number of sort-key columns */
301
302 /* their indexes in the target list */
303 AttrNumber *sortColIdx pg_node_attr(array_size(numCols));
304
305 /* OIDs of operators to sort them by */
306 Oid *sortOperators pg_node_attr(array_size(numCols));
307
308 /* OIDs of collations */
309 Oid *collations pg_node_attr(array_size(numCols));
310
311 /* NULLS FIRST/LAST directions */
312 bool *nullsFirst pg_node_attr(array_size(numCols));
313
314 /* Info for run-time subplan pruning; NULL if we're not doing that */
317
318/* ----------------
319 * RecursiveUnion node -
320 * Generate a recursive union of two subplans.
321 *
322 * The "outer" subplan is always the non-recursive term, and the "inner"
323 * subplan is the recursive term.
324 * ----------------
325 */
326typedef struct RecursiveUnion
327{
329
330 /* ID of Param representing work table */
332
333 /* Remaining fields are zero/null in UNION ALL case */
334
335 /* number of columns to check for duplicate-ness */
337
338 /* their indexes in the target list */
339 AttrNumber *dupColIdx pg_node_attr(array_size(numCols));
340
341 /* equality operators to compare with */
342 Oid *dupOperators pg_node_attr(array_size(numCols));
343 Oid *dupCollations pg_node_attr(array_size(numCols));
344
345 /* estimated number of groups in input */
348
349/* ----------------
350 * BitmapAnd node -
351 * Generate the intersection of the results of sub-plans.
352 *
353 * The subplans must be of types that yield tuple bitmaps. The targetlist
354 * and qual fields of the plan are unused and are always NIL.
355 * ----------------
356 */
357typedef struct BitmapAnd
358{
362
363/* ----------------
364 * BitmapOr node -
365 * Generate the union of the results of sub-plans.
366 *
367 * The subplans must be of types that yield tuple bitmaps. The targetlist
368 * and qual fields of the plan are unused and are always NIL.
369 * ----------------
370 */
371typedef struct BitmapOr
372{
377
378/*
379 * ==========
380 * Scan nodes
381 *
382 * Scan is an abstract type that all relation scan plan types inherit from.
383 * ==========
384 */
385typedef struct Scan
386{
387 pg_node_attr(abstract)
388
389 Plan plan;
390 Index scanrelid; /* relid is index into the range table */
392
393/* ----------------
394 * sequential scan node
395 * ----------------
396 */
397typedef struct SeqScan
398{
401
402/* ----------------
403 * table sample scan node
404 * ----------------
405 */
406typedef struct SampleScan
407{
409 /* use struct pointer to avoid including parsenodes.h here */
412
413/* ----------------
414 * index scan node
415 *
416 * indexqualorig is an implicitly-ANDed list of index qual expressions, each
417 * in the same form it appeared in the query WHERE condition. Each should
418 * be of the form (indexkey OP comparisonval) or (comparisonval OP indexkey).
419 * The indexkey is a Var or expression referencing column(s) of the index's
420 * base table. The comparisonval might be any expression, but it won't use
421 * any columns of the base table. The expressions are ordered by index
422 * column position (but items referencing the same index column can appear
423 * in any order). indexqualorig is used at runtime only if we have to recheck
424 * a lossy indexqual.
425 *
426 * indexqual has the same form, but the expressions have been commuted if
427 * necessary to put the indexkeys on the left, and the indexkeys are replaced
428 * by Var nodes identifying the index columns (their varno is INDEX_VAR and
429 * their varattno is the index column number).
430 *
431 * indexorderbyorig is similarly the original form of any ORDER BY expressions
432 * that are being implemented by the index, while indexorderby is modified to
433 * have index column Vars on the left-hand side. Here, multiple expressions
434 * must appear in exactly the ORDER BY order, and this is not necessarily the
435 * index column order. Only the expressions are provided, not the auxiliary
436 * sort-order information from the ORDER BY SortGroupClauses; it's assumed
437 * that the sort ordering is fully determinable from the top-level operators.
438 * indexorderbyorig is used at runtime to recheck the ordering, if the index
439 * cannot calculate an accurate ordering. It is also needed for EXPLAIN.
440 *
441 * indexorderbyops is a list of the OIDs of the operators used to sort the
442 * ORDER BY expressions. This is used together with indexorderbyorig to
443 * recheck ordering at run time. (Note that indexorderby, indexorderbyorig,
444 * and indexorderbyops are used for amcanorderbyop cases, not amcanorder.)
445 *
446 * indexorderdir specifies the scan ordering, for indexscans on amcanorder
447 * indexes (for other indexes it should be "don't care").
448 * ----------------
449 */
450typedef struct IndexScan
451{
453 Oid indexid; /* OID of index to scan */
454 List *indexqual; /* list of index quals (usually OpExprs) */
455 List *indexqualorig; /* the same in original form */
456 List *indexorderby; /* list of index ORDER BY exprs */
457 List *indexorderbyorig; /* the same in original form */
458 List *indexorderbyops; /* OIDs of sort ops for ORDER BY exprs */
459 ScanDirection indexorderdir; /* forward or backward or don't care */
461
462/* ----------------
463 * index-only scan node
464 *
465 * IndexOnlyScan is very similar to IndexScan, but it specifies an
466 * index-only scan, in which the data comes from the index not the heap.
467 * Because of this, *all* Vars in the plan node's targetlist, qual, and
468 * index expressions reference index columns and have varno = INDEX_VAR.
469 *
470 * We could almost use indexqual directly against the index's output tuple
471 * when rechecking lossy index operators, but that won't work for quals on
472 * index columns that are not retrievable. Hence, recheckqual is needed
473 * for rechecks: it expresses the same condition as indexqual, but using
474 * only index columns that are retrievable. (We will not generate an
475 * index-only scan if this is not possible. An example is that if an
476 * index has table column "x" in a retrievable index column "ind1", plus
477 * an expression f(x) in a non-retrievable column "ind2", an indexable
478 * query on f(x) will use "ind2" in indexqual and f(ind1) in recheckqual.
479 * Without the "ind1" column, an index-only scan would be disallowed.)
480 *
481 * We don't currently need a recheckable equivalent of indexorderby,
482 * because we don't support lossy operators in index ORDER BY.
483 *
484 * To help EXPLAIN interpret the index Vars for display, we provide
485 * indextlist, which represents the contents of the index as a targetlist
486 * with one TLE per index column. Vars appearing in this list reference
487 * the base table, and this is the only field in the plan node that may
488 * contain such Vars. Also, for the convenience of setrefs.c, TLEs in
489 * indextlist are marked as resjunk if they correspond to columns that
490 * the index AM cannot reconstruct.
491 * ----------------
492 */
493typedef struct IndexOnlyScan
494{
496 Oid indexid; /* OID of index to scan */
497 List *indexqual; /* list of index quals (usually OpExprs) */
498 List *recheckqual; /* index quals in recheckable form */
499 List *indexorderby; /* list of index ORDER BY exprs */
500 List *indextlist; /* TargetEntry list describing index's cols */
501 ScanDirection indexorderdir; /* forward or backward or don't care */
503
504/* ----------------
505 * bitmap index scan node
506 *
507 * BitmapIndexScan delivers a bitmap of potential tuple locations;
508 * it does not access the heap itself. The bitmap is used by an
509 * ancestor BitmapHeapScan node, possibly after passing through
510 * intermediate BitmapAnd and/or BitmapOr nodes to combine it with
511 * the results of other BitmapIndexScans.
512 *
513 * The fields have the same meanings as for IndexScan, except we don't
514 * store a direction flag because direction is uninteresting.
515 *
516 * In a BitmapIndexScan plan node, the targetlist and qual fields are
517 * not used and are always NIL. The indexqualorig field is unused at
518 * run time too, but is saved for the benefit of EXPLAIN.
519 * ----------------
520 */
521typedef struct BitmapIndexScan
522{
524 Oid indexid; /* OID of index to scan */
525 bool isshared; /* Create shared bitmap if set */
526 List *indexqual; /* list of index quals (OpExprs) */
527 List *indexqualorig; /* the same in original form */
529
530/* ----------------
531 * bitmap sequential scan node
532 *
533 * This needs a copy of the qual conditions being used by the input index
534 * scans because there are various cases where we need to recheck the quals;
535 * for example, when the bitmap is lossy about the specific rows on a page
536 * that meet the index condition.
537 * ----------------
538 */
539typedef struct BitmapHeapScan
540{
542 List *bitmapqualorig; /* index quals, in standard expr form */
544
545/* ----------------
546 * tid scan node
547 *
548 * tidquals is an implicitly OR'ed list of qual expressions of the form
549 * "CTID = pseudoconstant", or "CTID = ANY(pseudoconstant_array)",
550 * or a CurrentOfExpr for the relation.
551 * ----------------
552 */
553typedef struct TidScan
554{
556 List *tidquals; /* qual(s) involving CTID = something */
558
559/* ----------------
560 * tid range scan node
561 *
562 * tidrangequals is an implicitly AND'ed list of qual expressions of the form
563 * "CTID relop pseudoconstant", where relop is one of >,>=,<,<=.
564 * ----------------
565 */
566typedef struct TidRangeScan
567{
569 List *tidrangequals; /* qual(s) involving CTID op something */
571
572/* ----------------
573 * subquery scan node
574 *
575 * SubqueryScan is for scanning the output of a sub-query in the range table.
576 * We often need an extra plan node above the sub-query's plan to perform
577 * expression evaluations (which we can't push into the sub-query without
578 * risking changing its semantics). Although we are not scanning a physical
579 * relation, we make this a descendant of Scan anyway for code-sharing
580 * purposes.
581 *
582 * SubqueryScanStatus caches the trivial_subqueryscan property of the node.
583 * SUBQUERY_SCAN_UNKNOWN means not yet determined. This is only used during
584 * planning.
585 *
586 * Note: we store the sub-plan in the type-specific subplan field, not in
587 * the generic lefttree field as you might expect. This is because we do
588 * not want plan-tree-traversal routines to recurse into the subplan without
589 * knowing that they are changing Query contexts.
590 * ----------------
591 */
593{
598
599typedef struct SubqueryScan
600{
605
606/* ----------------
607 * FunctionScan node
608 * ----------------
609 */
610typedef struct FunctionScan
611{
613 List *functions; /* list of RangeTblFunction nodes */
614 bool funcordinality; /* WITH ORDINALITY */
616
617/* ----------------
618 * ValuesScan node
619 * ----------------
620 */
621typedef struct ValuesScan
622{
624 List *values_lists; /* list of expression lists */
626
627/* ----------------
628 * TableFunc scan node
629 * ----------------
630 */
631typedef struct TableFuncScan
632{
634 TableFunc *tablefunc; /* table function node */
636
637/* ----------------
638 * CteScan node
639 * ----------------
640 */
641typedef struct CteScan
642{
644 int ctePlanId; /* ID of init SubPlan for CTE */
645 int cteParam; /* ID of Param representing CTE output */
647
648/* ----------------
649 * NamedTuplestoreScan node
650 * ----------------
651 */
653{
655 char *enrname; /* Name given to Ephemeral Named Relation */
657
658/* ----------------
659 * WorkTableScan node
660 * ----------------
661 */
662typedef struct WorkTableScan
663{
665 int wtParam; /* ID of Param representing work table */
667
668/* ----------------
669 * ForeignScan node
670 *
671 * fdw_exprs and fdw_private are both under the control of the foreign-data
672 * wrapper, but fdw_exprs is presumed to contain expression trees and will
673 * be post-processed accordingly by the planner; fdw_private won't be.
674 * Note that everything in both lists must be copiable by copyObject().
675 * One way to store an arbitrary blob of bytes is to represent it as a bytea
676 * Const. Usually, though, you'll be better off choosing a representation
677 * that can be dumped usefully by nodeToString().
678 *
679 * fdw_scan_tlist is a targetlist describing the contents of the scan tuple
680 * returned by the FDW; it can be NIL if the scan tuple matches the declared
681 * rowtype of the foreign table, which is the normal case for a simple foreign
682 * table scan. (If the plan node represents a foreign join, fdw_scan_tlist
683 * is required since there is no rowtype available from the system catalogs.)
684 * When fdw_scan_tlist is provided, Vars in the node's tlist and quals must
685 * have varno INDEX_VAR, and their varattnos correspond to resnos in the
686 * fdw_scan_tlist (which are also column numbers in the actual scan tuple).
687 * fdw_scan_tlist is never actually executed; it just holds expression trees
688 * describing what is in the scan tuple's columns.
689 *
690 * fdw_recheck_quals should contain any quals which the core system passed to
691 * the FDW but which were not added to scan.plan.qual; that is, it should
692 * contain the quals being checked remotely. This is needed for correct
693 * behavior during EvalPlanQual rechecks.
694 *
695 * When the plan node represents a foreign join, scan.scanrelid is zero and
696 * fs_relids must be consulted to identify the join relation. (fs_relids
697 * is valid for simple scans as well, but will always match scan.scanrelid.)
698 * fs_relids includes outer joins; fs_base_relids does not.
699 *
700 * If the FDW's PlanDirectModify() callback decides to repurpose a ForeignScan
701 * node to perform the UPDATE or DELETE operation directly in the remote
702 * server, it sets 'operation' and 'resultRelation' to identify the operation
703 * type and target relation. Note that these fields are only set if the
704 * modification is performed *fully* remotely; otherwise, the modification is
705 * driven by a local ModifyTable node and 'operation' is left to CMD_SELECT.
706 * ----------------
707 */
708typedef struct ForeignScan
709{
711 CmdType operation; /* SELECT/INSERT/UPDATE/DELETE */
712 Index resultRelation; /* direct modification target's RT index */
713 Oid checkAsUser; /* user to perform the scan as; 0 means to
714 * check as current user */
715 Oid fs_server; /* OID of foreign server */
716 List *fdw_exprs; /* expressions that FDW may evaluate */
717 List *fdw_private; /* private data for FDW */
718 List *fdw_scan_tlist; /* optional tlist describing scan tuple */
719 List *fdw_recheck_quals; /* original quals not in scan.plan.qual */
720 Bitmapset *fs_relids; /* base+OJ RTIs generated by this scan */
721 Bitmapset *fs_base_relids; /* base RTIs generated by this scan */
722 bool fsSystemCol; /* true if any "system column" is needed */
724
725/* ----------------
726 * CustomScan node
727 *
728 * The comments for ForeignScan's fdw_exprs, fdw_private, fdw_scan_tlist,
729 * and fs_relids fields apply equally to CustomScan's custom_exprs,
730 * custom_private, custom_scan_tlist, and custom_relids fields. The
731 * convention of setting scan.scanrelid to zero for joins applies as well.
732 *
733 * Note that since Plan trees can be copied, custom scan providers *must*
734 * fit all plan data they need into those fields; embedding CustomScan in
735 * a larger struct will not work.
736 * ----------------
737 */
738struct CustomScanMethods;
739
740typedef struct CustomScan
741{
743 uint32 flags; /* mask of CUSTOMPATH_* flags, see
744 * nodes/extensible.h */
745 List *custom_plans; /* list of Plan nodes, if any */
746 List *custom_exprs; /* expressions that custom code may evaluate */
747 List *custom_private; /* private data for custom code */
748 List *custom_scan_tlist; /* optional tlist describing scan tuple */
749 Bitmapset *custom_relids; /* RTIs generated by this scan */
750
751 /*
752 * NOTE: The method field of CustomScan is required to be a pointer to a
753 * static table of callback functions. So we don't copy the table itself,
754 * just reference the original one.
755 */
758
759/*
760 * ==========
761 * Join nodes
762 * ==========
763 */
764
765/* ----------------
766 * Join node
767 *
768 * jointype: rule for joining tuples from left and right subtrees
769 * inner_unique each outer tuple can match to no more than one inner tuple
770 * joinqual: qual conditions that came from JOIN/ON or JOIN/USING
771 * (plan.qual contains conditions that came from WHERE)
772 *
773 * When jointype is INNER, joinqual and plan.qual are semantically
774 * interchangeable. For OUTER jointypes, the two are *not* interchangeable;
775 * only joinqual is used to determine whether a match has been found for
776 * the purpose of deciding whether to generate null-extended tuples.
777 * (But plan.qual is still applied before actually returning a tuple.)
778 * For an outer join, only joinquals are allowed to be used as the merge
779 * or hash condition of a merge or hash join.
780 *
781 * inner_unique is set if the joinquals are such that no more than one inner
782 * tuple could match any given outer tuple. This allows the executor to
783 * skip searching for additional matches. (This must be provable from just
784 * the joinquals, ignoring plan.qual, due to where the executor tests it.)
785 * ----------------
786 */
787typedef struct Join
788{
789 pg_node_attr(abstract)
790
791 Plan plan;
794 List *joinqual; /* JOIN quals (in addition to plan.qual) */
796
797/* ----------------
798 * nest loop join node
799 *
800 * The nestParams list identifies any executor Params that must be passed
801 * into execution of the inner subplan carrying values from the current row
802 * of the outer subplan. Currently we restrict these values to be simple
803 * Vars, but perhaps someday that'd be worth relaxing. (Note: during plan
804 * creation, the paramval can actually be a PlaceHolderVar expression; but it
805 * must be a Var with varno OUTER_VAR by the time it gets to the executor.)
806 * ----------------
807 */
808typedef struct NestLoop
809{
811 List *nestParams; /* list of NestLoopParam nodes */
813
814typedef struct NestLoopParam
815{
816 pg_node_attr(no_equal, no_query_jumble)
817
819 int paramno; /* number of the PARAM_EXEC Param to set */
820 Var *paramval; /* outer-relation Var to assign to Param */
822
823/* ----------------
824 * merge join node
825 *
826 * The expected ordering of each mergeable column is described by a btree
827 * opfamily OID, a collation OID, a direction (BTLessStrategyNumber or
828 * BTGreaterStrategyNumber) and a nulls-first flag. Note that the two sides
829 * of each mergeclause may be of different datatypes, but they are ordered the
830 * same way according to the common opfamily and collation. The operator in
831 * each mergeclause must be an equality operator of the indicated opfamily.
832 * ----------------
833 */
834typedef struct MergeJoin
835{
837
838 /* Can we skip mark/restore calls? */
840
841 /* mergeclauses as expression trees */
843
844 /* these are arrays, but have the same length as the mergeclauses list: */
845
846 /* per-clause OIDs of btree opfamilies */
847 Oid *mergeFamilies pg_node_attr(array_size(mergeclauses));
848
849 /* per-clause OIDs of collations */
850 Oid *mergeCollations pg_node_attr(array_size(mergeclauses));
851
852 /* per-clause ordering (ASC or DESC) */
853 bool *mergeReversals pg_node_attr(array_size(mergeclauses));
854
855 /* per-clause nulls ordering */
856 bool *mergeNullsFirst pg_node_attr(array_size(mergeclauses));
858
859/* ----------------
860 * hash join node
861 * ----------------
862 */
863typedef struct HashJoin
864{
869
870 /*
871 * List of expressions to be hashed for tuples from the outer plan, to
872 * perform lookups in the hashtable over the inner plan.
873 */
876
877/* ----------------
878 * materialization node
879 * ----------------
880 */
881typedef struct Material
882{
885
886/* ----------------
887 * memoize node
888 * ----------------
889 */
890typedef struct Memoize
891{
893
894 /* size of the two arrays below */
896
897 /* hash operators for each key */
898 Oid *hashOperators pg_node_attr(array_size(numKeys));
899
900 /* collations for each key */
901 Oid *collations pg_node_attr(array_size(numKeys));
902
903 /* cache keys in the form of exprs containing parameters */
905
906 /*
907 * true if the cache entry should be marked as complete after we store the
908 * first tuple in it.
909 */
911
912 /*
913 * true when cache key should be compared bit by bit, false when using
914 * hash equality ops
915 */
917
918 /*
919 * The maximum number of entries that the planner expects will fit in the
920 * cache, or 0 if unknown
921 */
923
924 /* paramids from param_exprs */
927
928/* ----------------
929 * sort node
930 * ----------------
931 */
932typedef struct Sort
933{
935
936 /* number of sort-key columns */
938
939 /* their indexes in the target list */
940 AttrNumber *sortColIdx pg_node_attr(array_size(numCols));
941
942 /* OIDs of operators to sort them by */
943 Oid *sortOperators pg_node_attr(array_size(numCols));
944
945 /* OIDs of collations */
946 Oid *collations pg_node_attr(array_size(numCols));
947
948 /* NULLS FIRST/LAST directions */
949 bool *nullsFirst pg_node_attr(array_size(numCols));
951
952/* ----------------
953 * incremental sort node
954 * ----------------
955 */
956typedef struct IncrementalSort
957{
959 int nPresortedCols; /* number of presorted columns */
961
962/* ---------------
963 * group node -
964 * Used for queries with GROUP BY (but no aggregates) specified.
965 * The input must be presorted according to the grouping columns.
966 * ---------------
967 */
968typedef struct Group
969{
971
972 /* number of grouping columns */
974
975 /* their indexes in the target list */
976 AttrNumber *grpColIdx pg_node_attr(array_size(numCols));
977
978 /* equality operators to compare with */
979 Oid *grpOperators pg_node_attr(array_size(numCols));
980 Oid *grpCollations pg_node_attr(array_size(numCols));
982
983/* ---------------
984 * aggregate node
985 *
986 * An Agg node implements plain or grouped aggregation. For grouped
987 * aggregation, we can work with presorted input or unsorted input;
988 * the latter strategy uses an internal hashtable.
989 *
990 * Notice the lack of any direct info about the aggregate functions to be
991 * computed. They are found by scanning the node's tlist and quals during
992 * executor startup. (It is possible that there are no aggregate functions;
993 * this could happen if they get optimized away by constant-folding, or if
994 * we are using the Agg node to implement hash-based grouping.)
995 * ---------------
996 */
997typedef struct Agg
998{
1000
1001 /* basic strategy, see nodes.h */
1003
1004 /* agg-splitting mode, see nodes.h */
1006
1007 /* number of grouping columns */
1009
1010 /* their indexes in the target list */
1011 AttrNumber *grpColIdx pg_node_attr(array_size(numCols));
1012
1013 /* equality operators to compare with */
1014 Oid *grpOperators pg_node_attr(array_size(numCols));
1015 Oid *grpCollations pg_node_attr(array_size(numCols));
1016
1017 /* estimated number of groups in input */
1019
1020 /* for pass-by-ref transition data */
1022
1023 /* IDs of Params used in Aggref inputs */
1025
1026 /* Note: planner provides numGroups & aggParams only in HASHED/MIXED case */
1027
1028 /* grouping sets to use */
1030
1031 /* chained Agg/Sort nodes */
1034
1035/* ----------------
1036 * window aggregate node
1037 * ----------------
1038 */
1039typedef struct WindowAgg
1040{
1042
1043 /* ID referenced by window functions */
1045
1046 /* number of columns in partition clause */
1048
1049 /* their indexes in the target list */
1050 AttrNumber *partColIdx pg_node_attr(array_size(partNumCols));
1051
1052 /* equality operators for partition columns */
1053 Oid *partOperators pg_node_attr(array_size(partNumCols));
1054
1055 /* collations for partition columns */
1056 Oid *partCollations pg_node_attr(array_size(partNumCols));
1057
1058 /* number of columns in ordering clause */
1060
1061 /* their indexes in the target list */
1062 AttrNumber *ordColIdx pg_node_attr(array_size(ordNumCols));
1063
1064 /* equality operators for ordering columns */
1065 Oid *ordOperators pg_node_attr(array_size(ordNumCols));
1066
1067 /* collations for ordering columns */
1068 Oid *ordCollations pg_node_attr(array_size(ordNumCols));
1069
1070 /* frame_clause options, see WindowDef */
1072
1073 /* expression for starting bound, if any */
1075
1076 /* expression for ending bound, if any */
1078
1079 /* qual to help short-circuit execution */
1081
1082 /* runCondition for display in EXPLAIN */
1084
1085 /* these fields are used with RANGE offset PRECEDING/FOLLOWING: */
1086
1087 /* in_range function for startOffset */
1089
1090 /* in_range function for endOffset */
1092
1093 /* collation for in_range tests */
1095
1096 /* use ASC sort order for in_range tests? */
1098
1099 /* nulls sort first for in_range tests? */
1101
1102 /*
1103 * false for all apart from the WindowAgg that's closest to the root of
1104 * the plan
1105 */
1108
1109/* ----------------
1110 * unique node
1111 * ----------------
1112 */
1113typedef struct Unique
1114{
1116
1117 /* number of columns to check for uniqueness */
1119
1120 /* their indexes in the target list */
1121 AttrNumber *uniqColIdx pg_node_attr(array_size(numCols));
1122
1123 /* equality operators to compare with */
1124 Oid *uniqOperators pg_node_attr(array_size(numCols));
1125
1126 /* collations for equality comparisons */
1127 Oid *uniqCollations pg_node_attr(array_size(numCols));
1129
1130/* ------------
1131 * gather node
1132 *
1133 * Note: rescan_param is the ID of a PARAM_EXEC parameter slot. That slot
1134 * will never actually contain a value, but the Gather node must flag it as
1135 * having changed whenever it is rescanned. The child parallel-aware scan
1136 * nodes are marked as depending on that parameter, so that the rescan
1137 * machinery is aware that their output is likely to change across rescans.
1138 * In some cases we don't need a rescan Param, so rescan_param is set to -1.
1139 * ------------
1140 */
1141typedef struct Gather
1142{
1144 int num_workers; /* planned number of worker processes */
1145 int rescan_param; /* ID of Param that signals a rescan, or -1 */
1146 bool single_copy; /* don't execute plan more than once */
1147 bool invisible; /* suppress EXPLAIN display (for testing)? */
1148 Bitmapset *initParam; /* param id's of initplans which are referred
1149 * at gather or one of it's child node */
1151
1152/* ------------
1153 * gather merge node
1154 * ------------
1155 */
1156typedef struct GatherMerge
1157{
1159
1160 /* planned number of worker processes */
1162
1163 /* ID of Param that signals a rescan, or -1 */
1165
1166 /* remaining fields are just like the sort-key info in struct Sort */
1167
1168 /* number of sort-key columns */
1170
1171 /* their indexes in the target list */
1172 AttrNumber *sortColIdx pg_node_attr(array_size(numCols));
1173
1174 /* OIDs of operators to sort them by */
1175 Oid *sortOperators pg_node_attr(array_size(numCols));
1176
1177 /* OIDs of collations */
1178 Oid *collations pg_node_attr(array_size(numCols));
1179
1180 /* NULLS FIRST/LAST directions */
1181 bool *nullsFirst pg_node_attr(array_size(numCols));
1182
1183 /*
1184 * param id's of initplans which are referred at gather merge or one of
1185 * it's child node
1186 */
1189
1190/* ----------------
1191 * hash build node
1192 *
1193 * If the executor is supposed to try to apply skew join optimization, then
1194 * skewTable/skewColumn/skewInherit identify the outer relation's join key
1195 * column, from which the relevant MCV statistics can be fetched.
1196 * ----------------
1197 */
1198typedef struct Hash
1199{
1201
1202 /*
1203 * List of expressions to be hashed for tuples from Hash's outer plan,
1204 * needed to put them into the hashtable.
1205 */
1206 List *hashkeys; /* hash keys for the hashjoin condition */
1207 Oid skewTable; /* outer join key's table OID, or InvalidOid */
1208 AttrNumber skewColumn; /* outer join key's column #, or zero */
1209 bool skewInherit; /* is outer join rel an inheritance tree? */
1210 /* all other info is in the parent HashJoin node */
1211 Cardinality rows_total; /* estimate total rows if parallel_aware */
1213
1214/* ----------------
1215 * setop node
1216 * ----------------
1217 */
1218typedef struct SetOp
1219{
1221
1222 /* what to do, see nodes.h */
1224
1225 /* how to do it, see nodes.h */
1227
1228 /* number of columns to compare */
1230
1231 /* their indexes in the target list */
1232 AttrNumber *cmpColIdx pg_node_attr(array_size(numCols));
1233
1234 /* comparison operators (either equality operators or sort operators) */
1235 Oid *cmpOperators pg_node_attr(array_size(numCols));
1236 Oid *cmpCollations pg_node_attr(array_size(numCols));
1237
1238 /* nulls-first flags if sorting, otherwise not interesting */
1239 bool *cmpNullsFirst pg_node_attr(array_size(numCols));
1240
1241 /* estimated number of groups in left input */
1244
1245/* ----------------
1246 * lock-rows node
1247 *
1248 * rowMarks identifies the rels to be locked by this node; it should be
1249 * a subset of the rowMarks listed in the top-level PlannedStmt.
1250 * epqParam is a Param that all scan nodes below this one must depend on.
1251 * It is used to force re-evaluation of the plan during EvalPlanQual.
1252 * ----------------
1253 */
1254typedef struct LockRows
1255{
1257 List *rowMarks; /* a list of PlanRowMark's */
1258 int epqParam; /* ID of Param for EvalPlanQual re-eval */
1260
1261/* ----------------
1262 * limit node
1263 *
1264 * Note: as of Postgres 8.2, the offset and count expressions are expected
1265 * to yield int8, rather than int4 as before.
1266 * ----------------
1267 */
1268typedef struct Limit
1269{
1271
1272 /* OFFSET parameter, or NULL if none */
1274
1275 /* COUNT parameter, or NULL if none */
1277
1278 /* limit type */
1280
1281 /* number of columns to check for similarity */
1283
1284 /* their indexes in the target list */
1285 AttrNumber *uniqColIdx pg_node_attr(array_size(uniqNumCols));
1286
1287 /* equality operators to compare with */
1288 Oid *uniqOperators pg_node_attr(array_size(uniqNumCols));
1289
1290 /* collations for equality comparisons */
1291 Oid *uniqCollations pg_node_attr(array_size(uniqNumCols));
1293
1294
1295/*
1296 * RowMarkType -
1297 * enums for types of row-marking operations
1298 *
1299 * The first four of these values represent different lock strengths that
1300 * we can take on tuples according to SELECT FOR [KEY] UPDATE/SHARE requests.
1301 * We support these on regular tables, as well as on foreign tables whose FDWs
1302 * report support for late locking. For other foreign tables, any locking
1303 * that might be done for such requests must happen during the initial row
1304 * fetch; their FDWs provide no mechanism for going back to lock a row later.
1305 * This means that the semantics will be a bit different than for a local
1306 * table; in particular we are likely to lock more rows than would be locked
1307 * locally, since remote rows will be locked even if they then fail
1308 * locally-checked restriction or join quals. However, the prospect of
1309 * doing a separate remote query to lock each selected row is usually pretty
1310 * unappealing, so early locking remains a credible design choice for FDWs.
1311 *
1312 * When doing UPDATE/DELETE/MERGE/SELECT FOR UPDATE/SHARE, we have to uniquely
1313 * identify all the source rows, not only those from the target relations, so
1314 * that we can perform EvalPlanQual rechecking at need. For plain tables we
1315 * can just fetch the TID, much as for a target relation; this case is
1316 * represented by ROW_MARK_REFERENCE. Otherwise (for example for VALUES or
1317 * FUNCTION scans) we have to copy the whole row value. ROW_MARK_COPY is
1318 * pretty inefficient, since most of the time we'll never need the data; but
1319 * fortunately the overhead is usually not performance-critical in practice.
1320 * By default we use ROW_MARK_COPY for foreign tables, but if the FDW has
1321 * a concept of rowid it can request to use ROW_MARK_REFERENCE instead.
1322 * (Again, this probably doesn't make sense if a physical remote fetch is
1323 * needed, but for FDWs that map to local storage it might be credible.)
1324 */
1325typedef enum RowMarkType
1326{
1327 ROW_MARK_EXCLUSIVE, /* obtain exclusive tuple lock */
1328 ROW_MARK_NOKEYEXCLUSIVE, /* obtain no-key exclusive tuple lock */
1329 ROW_MARK_SHARE, /* obtain shared tuple lock */
1330 ROW_MARK_KEYSHARE, /* obtain keyshare tuple lock */
1331 ROW_MARK_REFERENCE, /* just fetch the TID, don't lock it */
1332 ROW_MARK_COPY, /* physically copy the row value */
1334
1335#define RowMarkRequiresRowShareLock(marktype) ((marktype) <= ROW_MARK_KEYSHARE)
1336
1337/*
1338 * PlanRowMark -
1339 * plan-time representation of FOR [KEY] UPDATE/SHARE clauses
1340 *
1341 * When doing UPDATE/DELETE/MERGE/SELECT FOR UPDATE/SHARE, we create a separate
1342 * PlanRowMark node for each non-target relation in the query. Relations that
1343 * are not specified as FOR UPDATE/SHARE are marked ROW_MARK_REFERENCE (if
1344 * regular tables or supported foreign tables) or ROW_MARK_COPY (if not).
1345 *
1346 * Initially all PlanRowMarks have rti == prti and isParent == false.
1347 * When the planner discovers that a relation is the root of an inheritance
1348 * tree, it sets isParent true, and adds an additional PlanRowMark to the
1349 * list for each child relation (including the target rel itself in its role
1350 * as a child, if it is not a partitioned table). Any non-leaf partitioned
1351 * child relations will also have entries with isParent = true. The child
1352 * entries have rti == child rel's RT index and prti == top parent's RT index,
1353 * and can therefore be recognized as children by the fact that prti != rti.
1354 * The parent's allMarkTypes field gets the OR of (1<<markType) across all
1355 * its children (this definition allows children to use different markTypes).
1356 *
1357 * The planner also adds resjunk output columns to the plan that carry
1358 * information sufficient to identify the locked or fetched rows. When
1359 * markType != ROW_MARK_COPY, these columns are named
1360 * tableoid%u OID of table
1361 * ctid%u TID of row
1362 * The tableoid column is only present for an inheritance hierarchy.
1363 * When markType == ROW_MARK_COPY, there is instead a single column named
1364 * wholerow%u whole-row value of relation
1365 * (An inheritance hierarchy could have all three resjunk output columns,
1366 * if some children use a different markType than others.)
1367 * In all three cases, %u represents the rowmark ID number (rowmarkId).
1368 * This number is unique within a plan tree, except that child relation
1369 * entries copy their parent's rowmarkId. (Assigning unique numbers
1370 * means we needn't renumber rowmarkIds when flattening subqueries, which
1371 * would require finding and renaming the resjunk columns as well.)
1372 * Note this means that all tables in an inheritance hierarchy share the
1373 * same resjunk column names.
1374 */
1375typedef struct PlanRowMark
1376{
1377 pg_node_attr(no_equal, no_query_jumble)
1378
1379 NodeTag type;
1380 Index rti; /* range table index of markable relation */
1381 Index prti; /* range table index of parent relation */
1382 Index rowmarkId; /* unique identifier for resjunk columns */
1383 RowMarkType markType; /* see enum above */
1384 int allMarkTypes; /* OR of (1<<markType) for all children */
1385 LockClauseStrength strength; /* LockingClause's strength, or LCS_NONE */
1386 LockWaitPolicy waitPolicy; /* NOWAIT and SKIP LOCKED options */
1387 bool isParent; /* true if this is a "dummy" parent entry */
1389
1390
1391/*
1392 * Node types to represent partition pruning information.
1393 */
1394
1395/*
1396 * PartitionPruneInfo - Details required to allow the executor to prune
1397 * partitions.
1398 *
1399 * Here we store mapping details to allow translation of a partitioned table's
1400 * index as returned by the partition pruning code into subplan indexes for
1401 * plan types which support arbitrary numbers of subplans, such as Append.
1402 * We also store various details to tell the executor when it should be
1403 * performing partition pruning.
1404 *
1405 * Each PartitionedRelPruneInfo describes the partitioning rules for a single
1406 * partitioned table (a/k/a level of partitioning). Since a partitioning
1407 * hierarchy could contain multiple levels, we represent it by a List of
1408 * PartitionedRelPruneInfos, where the first entry represents the topmost
1409 * partitioned table and additional entries represent non-leaf child
1410 * partitions, ordered such that parents appear before their children.
1411 * Then, since an Append-type node could have multiple partitioning
1412 * hierarchies among its children, we have an unordered List of those Lists.
1413 *
1414 * prune_infos List of Lists containing PartitionedRelPruneInfo nodes,
1415 * one sublist per run-time-prunable partition hierarchy
1416 * appearing in the parent plan node's subplans.
1417 * other_subplans Indexes of any subplans that are not accounted for
1418 * by any of the PartitionedRelPruneInfo nodes in
1419 * "prune_infos". These subplans must not be pruned.
1420 */
1422{
1423 pg_node_attr(no_equal, no_query_jumble)
1424
1425 NodeTag type;
1429
1430/*
1431 * PartitionedRelPruneInfo - Details required to allow the executor to prune
1432 * partitions for a single partitioned table.
1433 *
1434 * subplan_map[] and subpart_map[] are indexed by partition index of the
1435 * partitioned table referenced by 'rtindex', the partition index being the
1436 * order that the partitions are defined in the table's PartitionDesc. For a
1437 * leaf partition p, subplan_map[p] contains the zero-based index of the
1438 * partition's subplan in the parent plan's subplan list; it is -1 if the
1439 * partition is non-leaf or has been pruned. For a non-leaf partition p,
1440 * subpart_map[p] contains the zero-based index of that sub-partition's
1441 * PartitionedRelPruneInfo in the hierarchy's PartitionedRelPruneInfo list;
1442 * it is -1 if the partition is a leaf or has been pruned. Note that subplan
1443 * indexes, as stored in 'subplan_map', are global across the parent plan
1444 * node, but partition indexes are valid only within a particular hierarchy.
1445 * relid_map[p] contains the partition's OID, or 0 if the partition was pruned.
1446 */
1448{
1449 pg_node_attr(no_equal, no_query_jumble)
1450
1451 NodeTag type;
1452
1453 /* RT index of partition rel for this level */
1455
1456 /* Indexes of all partitions which subplans or subparts are present for */
1458
1459 /* Length of the following arrays: */
1461
1462 /* subplan index by partition index, or -1 */
1463 int *subplan_map pg_node_attr(array_size(nparts));
1464
1465 /* subpart index by partition index, or -1 */
1466 int *subpart_map pg_node_attr(array_size(nparts));
1467
1468 /* relation OID by partition index, or 0 */
1469 Oid *relid_map pg_node_attr(array_size(nparts));
1470
1471 /*
1472 * initial_pruning_steps shows how to prune during executor startup (i.e.,
1473 * without use of any PARAM_EXEC Params); it is NIL if no startup pruning
1474 * is required. exec_pruning_steps shows how to prune with PARAM_EXEC
1475 * Params; it is NIL if no per-scan pruning is required.
1476 */
1477 List *initial_pruning_steps; /* List of PartitionPruneStep */
1478 List *exec_pruning_steps; /* List of PartitionPruneStep */
1479
1480 /* All PARAM_EXEC Param IDs in exec_pruning_steps */
1483
1484/*
1485 * Abstract Node type for partition pruning steps (there are no concrete
1486 * Nodes of this type).
1487 *
1488 * step_id is the global identifier of the step within its pruning context.
1489 */
1491{
1492 pg_node_attr(abstract, no_equal, no_query_jumble)
1493
1494 NodeTag type;
1497
1498/*
1499 * PartitionPruneStepOp - Information to prune using a set of mutually ANDed
1500 * OpExpr clauses
1501 *
1502 * This contains information extracted from up to partnatts OpExpr clauses,
1503 * where partnatts is the number of partition key columns. 'opstrategy' is the
1504 * strategy of the operator in the clause matched to the last partition key.
1505 * 'exprs' contains expressions which comprise the lookup key to be passed to
1506 * the partition bound search function. 'cmpfns' contains the OIDs of
1507 * comparison functions used to compare aforementioned expressions with
1508 * partition bounds. Both 'exprs' and 'cmpfns' contain the same number of
1509 * items, up to partnatts items.
1510 *
1511 * Once we find the offset of a partition bound using the lookup key, we
1512 * determine which partitions to include in the result based on the value of
1513 * 'opstrategy'. For example, if it were equality, we'd return just the
1514 * partition that would contain that key or a set of partitions if the key
1515 * didn't consist of all partitioning columns. For non-equality strategies,
1516 * we'd need to include other partitions as appropriate.
1517 *
1518 * 'nullkeys' is the set containing the offset of the partition keys (0 to
1519 * partnatts - 1) that were matched to an IS NULL clause. This is only
1520 * considered for hash partitioning as we need to pass which keys are null
1521 * to the hash partition bound search function. It is never possible to
1522 * have an expression be present in 'exprs' for a given partition key and
1523 * the corresponding bit set in 'nullkeys'.
1524 */
1526{
1528
1534
1535/*
1536 * PartitionPruneStepCombine - Information to prune using a BoolExpr clause
1537 *
1538 * For BoolExpr clauses, we combine the set of partitions determined for each
1539 * of the argument clauses.
1540 */
1542{
1546
1548{
1550
1554
1555
1556/*
1557 * Plan invalidation info
1558 *
1559 * We track the objects on which a PlannedStmt depends in two ways:
1560 * relations are recorded as a simple list of OIDs, and everything else
1561 * is represented as a list of PlanInvalItems. A PlanInvalItem is designed
1562 * to be used with the syscache invalidation mechanism, so it identifies a
1563 * system catalog entry by cache ID and hash value.
1564 */
1565typedef struct PlanInvalItem
1566{
1567 pg_node_attr(no_equal, no_query_jumble)
1568
1569 NodeTag type;
1570 int cacheId; /* a syscache ID, see utils/syscache.h */
1571 uint32 hashValue; /* hash value of object's cache lookup key */
1573
1574/*
1575 * MonotonicFunction
1576 *
1577 * Allows the planner to track monotonic properties of functions. A function
1578 * is monotonically increasing if a subsequent call cannot yield a lower value
1579 * than the previous call. A monotonically decreasing function cannot yield a
1580 * higher value on subsequent calls, and a function which is both must return
1581 * the same value on each call.
1582 */
1584{
1590
1591#endif /* PLANNODES_H */
int16 AttrNumber
Definition: attnum.h:21
uint64_t uint64
Definition: c.h:486
uint32_t uint32
Definition: c.h:485
unsigned int Index
Definition: c.h:568
LockWaitPolicy
Definition: lockoptions.h:37
LockClauseStrength
Definition: lockoptions.h:22
SetOpCmd
Definition: nodes.h:397
SetOpStrategy
Definition: nodes.h:405
double Cost
Definition: nodes.h:251
OnConflictAction
Definition: nodes.h:417
double Cardinality
Definition: nodes.h:252
CmdType
Definition: nodes.h:263
AggStrategy
Definition: nodes.h:353
NodeTag
Definition: nodes.h:27
AggSplit
Definition: nodes.h:375
LimitOption
Definition: nodes.h:430
int ParseLoc
Definition: nodes.h:240
JoinType
Definition: nodes.h:288
#define plan(x)
Definition: pg_regress.c:161
struct ForeignScan ForeignScan
struct TableFuncScan TableFuncScan
struct IndexScan IndexScan
struct MergeJoin MergeJoin
struct Memoize Memoize
struct Plan Plan
struct SampleScan SampleScan
struct WindowAgg WindowAgg
struct WorkTableScan WorkTableScan
struct ProjectSet ProjectSet
struct Sort Sort
struct PartitionedRelPruneInfo PartitionedRelPruneInfo
struct BitmapIndexScan BitmapIndexScan
struct TidScan TidScan
struct LockRows LockRows
struct TidRangeScan TidRangeScan
struct PartitionPruneStepOp PartitionPruneStepOp
SubqueryScanStatus
Definition: plannodes.h:593
@ SUBQUERY_SCAN_NONTRIVIAL
Definition: plannodes.h:596
@ SUBQUERY_SCAN_UNKNOWN
Definition: plannodes.h:594
@ SUBQUERY_SCAN_TRIVIAL
Definition: plannodes.h:595
struct PlanInvalItem PlanInvalItem
struct SubqueryScan SubqueryScan
PartitionPruneCombineOp
Definition: plannodes.h:1542
@ PARTPRUNE_COMBINE_INTERSECT
Definition: plannodes.h:1544
@ PARTPRUNE_COMBINE_UNION
Definition: plannodes.h:1543
struct IncrementalSort IncrementalSort
struct CteScan CteScan
struct NestLoop NestLoop
struct PlanRowMark PlanRowMark
struct Limit Limit
struct Unique Unique
struct Join Join
struct BitmapOr BitmapOr
struct SeqScan SeqScan
struct HashJoin HashJoin
struct Group Group
struct Scan Scan
struct PartitionPruneInfo PartitionPruneInfo
struct Append Append
struct Material Material
struct BitmapHeapScan BitmapHeapScan
struct NamedTuplestoreScan NamedTuplestoreScan
struct SetOp SetOp
struct NestLoopParam NestLoopParam
struct BitmapAnd BitmapAnd
struct GatherMerge GatherMerge
struct ModifyTable ModifyTable
struct PartitionPruneStep PartitionPruneStep
struct Hash Hash
RowMarkType
Definition: plannodes.h:1326
@ ROW_MARK_COPY
Definition: plannodes.h:1332
@ ROW_MARK_REFERENCE
Definition: plannodes.h:1331
@ ROW_MARK_SHARE
Definition: plannodes.h:1329
@ ROW_MARK_EXCLUSIVE
Definition: plannodes.h:1327
@ ROW_MARK_NOKEYEXCLUSIVE
Definition: plannodes.h:1328
@ ROW_MARK_KEYSHARE
Definition: plannodes.h:1330
MonotonicFunction
Definition: plannodes.h:1584
@ MONOTONICFUNC_NONE
Definition: plannodes.h:1585
@ MONOTONICFUNC_DECREASING
Definition: plannodes.h:1587
@ MONOTONICFUNC_INCREASING
Definition: plannodes.h:1586
@ MONOTONICFUNC_BOTH
Definition: plannodes.h:1588
struct RecursiveUnion RecursiveUnion
struct IndexOnlyScan IndexOnlyScan
struct FunctionScan FunctionScan
struct Result Result
struct MergeAppend MergeAppend
struct PartitionPruneStepCombine PartitionPruneStepCombine
struct CustomScan CustomScan
struct Agg Agg
struct ValuesScan ValuesScan
struct Gather Gather
struct PlannedStmt PlannedStmt
unsigned int Oid
Definition: postgres_ext.h:31
ScanDirection
Definition: sdir.h:25
uint16 StrategyNumber
Definition: stratnum.h:22
Definition: plannodes.h:998
AggSplit aggsplit
Definition: plannodes.h:1005
List * chain
Definition: plannodes.h:1032
Oid *grpCollations pg_node_attr(array_size(numCols))
long numGroups
Definition: plannodes.h:1018
List * groupingSets
Definition: plannodes.h:1029
Bitmapset * aggParams
Definition: plannodes.h:1024
Plan plan
Definition: plannodes.h:999
int numCols
Definition: plannodes.h:1008
Oid *grpOperators pg_node_attr(array_size(numCols))
uint64 transitionSpace
Definition: plannodes.h:1021
AttrNumber *grpColIdx pg_node_attr(array_size(numCols))
AggStrategy aggstrategy
Definition: plannodes.h:1002
int first_partial_plan
Definition: plannodes.h:277
struct PartitionPruneInfo * part_prune_info
Definition: plannodes.h:280
int nasyncplans
Definition: plannodes.h:271
Bitmapset * apprelids
Definition: plannodes.h:269
Plan plan
Definition: plannodes.h:268
List * appendplans
Definition: plannodes.h:270
Plan plan
Definition: plannodes.h:359
List * bitmapplans
Definition: plannodes.h:360
List * bitmapqualorig
Definition: plannodes.h:542
List * indexqualorig
Definition: plannodes.h:527
List * indexqual
Definition: plannodes.h:526
List * bitmapplans
Definition: plannodes.h:375
bool isshared
Definition: plannodes.h:374
Plan plan
Definition: plannodes.h:373
int ctePlanId
Definition: plannodes.h:644
int cteParam
Definition: plannodes.h:645
Scan scan
Definition: plannodes.h:643
uint32 flags
Definition: plannodes.h:743
List * custom_scan_tlist
Definition: plannodes.h:748
Scan scan
Definition: plannodes.h:742
List * custom_private
Definition: plannodes.h:747
Bitmapset * custom_relids
Definition: plannodes.h:749
List * custom_exprs
Definition: plannodes.h:746
const struct CustomScanMethods * methods
Definition: plannodes.h:756
List * custom_plans
Definition: plannodes.h:745
Oid checkAsUser
Definition: plannodes.h:713
CmdType operation
Definition: plannodes.h:711
Oid fs_server
Definition: plannodes.h:715
List * fdw_exprs
Definition: plannodes.h:716
bool fsSystemCol
Definition: plannodes.h:722
Bitmapset * fs_relids
Definition: plannodes.h:720
List * fdw_private
Definition: plannodes.h:717
Bitmapset * fs_base_relids
Definition: plannodes.h:721
Index resultRelation
Definition: plannodes.h:712
List * fdw_recheck_quals
Definition: plannodes.h:719
List * fdw_scan_tlist
Definition: plannodes.h:718
List * functions
Definition: plannodes.h:613
bool funcordinality
Definition: plannodes.h:614
int rescan_param
Definition: plannodes.h:1164
Oid *collations pg_node_attr(array_size(numCols))
Oid *sortOperators pg_node_attr(array_size(numCols))
bool *nullsFirst pg_node_attr(array_size(numCols))
Bitmapset * initParam
Definition: plannodes.h:1187
AttrNumber *sortColIdx pg_node_attr(array_size(numCols))
int num_workers
Definition: plannodes.h:1161
int num_workers
Definition: plannodes.h:1144
bool invisible
Definition: plannodes.h:1147
Bitmapset * initParam
Definition: plannodes.h:1148
bool single_copy
Definition: plannodes.h:1146
Plan plan
Definition: plannodes.h:1143
int rescan_param
Definition: plannodes.h:1145
AttrNumber *grpColIdx pg_node_attr(array_size(numCols))
int numCols
Definition: plannodes.h:973
Plan plan
Definition: plannodes.h:970
Oid *grpCollations pg_node_attr(array_size(numCols))
Oid *grpOperators pg_node_attr(array_size(numCols))
List * hashcollations
Definition: plannodes.h:868
List * hashclauses
Definition: plannodes.h:866
List * hashoperators
Definition: plannodes.h:867
Join join
Definition: plannodes.h:865
List * hashkeys
Definition: plannodes.h:874
AttrNumber skewColumn
Definition: plannodes.h:1208
List * hashkeys
Definition: plannodes.h:1206
Oid skewTable
Definition: plannodes.h:1207
bool skewInherit
Definition: plannodes.h:1209
Cardinality rows_total
Definition: plannodes.h:1211
Plan plan
Definition: plannodes.h:1200
List * indexqual
Definition: plannodes.h:497
List * recheckqual
Definition: plannodes.h:498
List * indextlist
Definition: plannodes.h:500
ScanDirection indexorderdir
Definition: plannodes.h:501
List * indexorderby
Definition: plannodes.h:499
List * indexorderby
Definition: plannodes.h:456
List * indexorderbyops
Definition: plannodes.h:458
ScanDirection indexorderdir
Definition: plannodes.h:459
Scan scan
Definition: plannodes.h:452
List * indexqualorig
Definition: plannodes.h:455
Oid indexid
Definition: plannodes.h:453
List * indexqual
Definition: plannodes.h:454
List * indexorderbyorig
Definition: plannodes.h:457
pg_node_attr(abstract) Plan plan
List * joinqual
Definition: plannodes.h:794
JoinType jointype
Definition: plannodes.h:792
bool inner_unique
Definition: plannodes.h:793
LimitOption limitOption
Definition: plannodes.h:1279
Oid *uniqOperators pg_node_attr(array_size(uniqNumCols))
Plan plan
Definition: plannodes.h:1270
Node * limitCount
Definition: plannodes.h:1276
AttrNumber *uniqColIdx pg_node_attr(array_size(uniqNumCols))
int uniqNumCols
Definition: plannodes.h:1282
Oid *uniqCollations pg_node_attr(array_size(uniqNumCols))
Node * limitOffset
Definition: plannodes.h:1273
Definition: pg_list.h:54
int epqParam
Definition: plannodes.h:1258
List * rowMarks
Definition: plannodes.h:1257
Plan plan
Definition: plannodes.h:1256
Plan plan
Definition: plannodes.h:883
Plan plan
Definition: plannodes.h:892
bool singlerow
Definition: plannodes.h:910
Bitmapset * keyparamids
Definition: plannodes.h:925
Oid *hashOperators pg_node_attr(array_size(numKeys))
bool binary_mode
Definition: plannodes.h:916
int numKeys
Definition: plannodes.h:895
List * param_exprs
Definition: plannodes.h:904
uint32 est_entries
Definition: plannodes.h:922
Oid *collations pg_node_attr(array_size(numKeys))
struct PartitionPruneInfo * part_prune_info
Definition: plannodes.h:315
bool *nullsFirst pg_node_attr(array_size(numCols))
AttrNumber *sortColIdx pg_node_attr(array_size(numCols))
Oid *sortOperators pg_node_attr(array_size(numCols))
Bitmapset * apprelids
Definition: plannodes.h:293
Oid *collations pg_node_attr(array_size(numCols))
List * mergeplans
Definition: plannodes.h:295
List * mergeclauses
Definition: plannodes.h:842
Join join
Definition: plannodes.h:836
Oid *mergeFamilies pg_node_attr(array_size(mergeclauses))
bool skip_mark_restore
Definition: plannodes.h:839
bool *mergeReversals pg_node_attr(array_size(mergeclauses))
bool *mergeNullsFirst pg_node_attr(array_size(mergeclauses))
Oid *mergeCollations pg_node_attr(array_size(mergeclauses))
List * updateColnosLists
Definition: plannodes.h:239
Index nominalRelation
Definition: plannodes.h:235
List * arbiterIndexes
Definition: plannodes.h:247
List * onConflictCols
Definition: plannodes.h:249
List * mergeJoinConditions
Definition: plannodes.h:255
CmdType operation
Definition: plannodes.h:233
int epqParam
Definition: plannodes.h:245
List * resultRelations
Definition: plannodes.h:238
Bitmapset * fdwDirectModifyPlans
Definition: plannodes.h:243
List * onConflictSet
Definition: plannodes.h:248
List * exclRelTlist
Definition: plannodes.h:252
List * mergeActionLists
Definition: plannodes.h:253
bool canSetTag
Definition: plannodes.h:234
List * fdwPrivLists
Definition: plannodes.h:242
bool partColsUpdated
Definition: plannodes.h:237
List * returningLists
Definition: plannodes.h:241
List * withCheckOptionLists
Definition: plannodes.h:240
Index rootRelation
Definition: plannodes.h:236
Node * onConflictWhere
Definition: plannodes.h:250
List * rowMarks
Definition: plannodes.h:244
OnConflictAction onConflictAction
Definition: plannodes.h:246
Index exclRelRTI
Definition: plannodes.h:251
Var * paramval
Definition: plannodes.h:820
pg_node_attr(no_equal, no_query_jumble) NodeTag type
List * nestParams
Definition: plannodes.h:811
Join join
Definition: plannodes.h:810
Definition: nodes.h:129
Bitmapset * other_subplans
Definition: plannodes.h:1427
pg_node_attr(no_equal, no_query_jumble) NodeTag type
PartitionPruneCombineOp combineOp
Definition: plannodes.h:1551
PartitionPruneStep step
Definition: plannodes.h:1549
PartitionPruneStep step
Definition: plannodes.h:1527
StrategyNumber opstrategy
Definition: plannodes.h:1529
Bitmapset * nullkeys
Definition: plannodes.h:1532
pg_node_attr(abstract, no_equal, no_query_jumble) NodeTag type
Oid *relid_map pg_node_attr(array_size(nparts))
pg_node_attr(no_equal, no_query_jumble) NodeTag type
Bitmapset * present_parts
Definition: plannodes.h:1457
Bitmapset * execparamids
Definition: plannodes.h:1481
int *subplan_map pg_node_attr(array_size(nparts))
int *subpart_map pg_node_attr(array_size(nparts))
uint32 hashValue
Definition: plannodes.h:1571
pg_node_attr(no_equal, no_query_jumble) NodeTag type
LockClauseStrength strength
Definition: plannodes.h:1385
Index prti
Definition: plannodes.h:1381
RowMarkType markType
Definition: plannodes.h:1383
LockWaitPolicy waitPolicy
Definition: plannodes.h:1386
bool isParent
Definition: plannodes.h:1387
Index rowmarkId
Definition: plannodes.h:1382
int allMarkTypes
Definition: plannodes.h:1384
pg_node_attr(no_equal, no_query_jumble) NodeTag type
Bitmapset * extParam
Definition: plannodes.h:171
struct Plan * lefttree
Definition: plannodes.h:155
bool async_capable
Definition: plannodes.h:147
Cost total_cost
Definition: plannodes.h:130
struct Plan * righttree
Definition: plannodes.h:156
bool parallel_aware
Definition: plannodes.h:141
Cost startup_cost
Definition: plannodes.h:129
List * qual
Definition: plannodes.h:154
int plan_width
Definition: plannodes.h:136
Bitmapset * allParam
Definition: plannodes.h:172
bool parallel_safe
Definition: plannodes.h:142
Cardinality plan_rows
Definition: plannodes.h:135
int plan_node_id
Definition: plannodes.h:152
int disabled_nodes
Definition: plannodes.h:128
List * targetlist
Definition: plannodes.h:153
pg_node_attr(abstract, no_equal, no_query_jumble) NodeTag type
List * initPlan
Definition: plannodes.h:157
struct Plan * planTree
Definition: plannodes.h:70
bool hasModifyingCTE
Definition: plannodes.h:58
List * appendRelations
Definition: plannodes.h:80
List * permInfos
Definition: plannodes.h:74
bool canSetTag
Definition: plannodes.h:60
List * rowMarks
Definition: plannodes.h:87
int jitFlags
Definition: plannodes.h:68
Bitmapset * rewindPlanIDs
Definition: plannodes.h:85
ParseLoc stmt_len
Definition: plannodes.h:99
bool hasReturning
Definition: plannodes.h:56
ParseLoc stmt_location
Definition: plannodes.h:98
List * invalItems
Definition: plannodes.h:91
bool transientPlan
Definition: plannodes.h:62
List * resultRelations
Definition: plannodes.h:78
List * subplans
Definition: plannodes.h:82
List * relationOids
Definition: plannodes.h:89
bool dependsOnRole
Definition: plannodes.h:64
CmdType commandType
Definition: plannodes.h:52
pg_node_attr(no_equal, no_query_jumble) NodeTag type
Node * utilityStmt
Definition: plannodes.h:95
List * rtable
Definition: plannodes.h:72
List * paramExecTypes
Definition: plannodes.h:93
bool parallelModeNeeded
Definition: plannodes.h:66
uint64 queryId
Definition: plannodes.h:54
Plan plan
Definition: plannodes.h:211
AttrNumber *dupColIdx pg_node_attr(array_size(numCols))
Oid *dupOperators pg_node_attr(array_size(numCols))
Oid *dupCollations pg_node_attr(array_size(numCols))
Node * resconstantqual
Definition: plannodes.h:200
Plan plan
Definition: plannodes.h:199
struct TableSampleClause * tablesample
Definition: plannodes.h:410
Scan scan
Definition: plannodes.h:408
Index scanrelid
Definition: plannodes.h:390
pg_node_attr(abstract) Plan plan
Scan scan
Definition: plannodes.h:399
SetOpStrategy strategy
Definition: plannodes.h:1226
Oid *cmpOperators pg_node_attr(array_size(numCols))
AttrNumber *cmpColIdx pg_node_attr(array_size(numCols))
SetOpCmd cmd
Definition: plannodes.h:1223
Oid *cmpCollations pg_node_attr(array_size(numCols))
int numCols
Definition: plannodes.h:1229
Plan plan
Definition: plannodes.h:1220
bool *cmpNullsFirst pg_node_attr(array_size(numCols))
long numGroups
Definition: plannodes.h:1242
Oid *collations pg_node_attr(array_size(numCols))
bool *nullsFirst pg_node_attr(array_size(numCols))
Oid *sortOperators pg_node_attr(array_size(numCols))
int numCols
Definition: plannodes.h:937
AttrNumber *sortColIdx pg_node_attr(array_size(numCols))
Plan plan
Definition: plannodes.h:934
SubqueryScanStatus scanstatus
Definition: plannodes.h:603
Plan * subplan
Definition: plannodes.h:602
TableFunc * tablefunc
Definition: plannodes.h:634
List * tidrangequals
Definition: plannodes.h:569
Scan scan
Definition: plannodes.h:555
List * tidquals
Definition: plannodes.h:556
AttrNumber *uniqColIdx pg_node_attr(array_size(numCols))
Oid *uniqOperators pg_node_attr(array_size(numCols))
Oid *uniqCollations pg_node_attr(array_size(numCols))
Plan plan
Definition: plannodes.h:1115
int numCols
Definition: plannodes.h:1118
Scan scan
Definition: plannodes.h:623
List * values_lists
Definition: plannodes.h:624
Definition: primnodes.h:248
AttrNumber *ordColIdx pg_node_attr(array_size(ordNumCols))
int partNumCols
Definition: plannodes.h:1047
Oid endInRangeFunc
Definition: plannodes.h:1091
Node * endOffset
Definition: plannodes.h:1077
Oid *partCollations pg_node_attr(array_size(partNumCols))
bool topWindow
Definition: plannodes.h:1106
Plan plan
Definition: plannodes.h:1041
Oid *ordOperators pg_node_attr(array_size(ordNumCols))
List * runConditionOrig
Definition: plannodes.h:1083
Oid inRangeColl
Definition: plannodes.h:1094
Node * startOffset
Definition: plannodes.h:1074
List * runCondition
Definition: plannodes.h:1080
Oid startInRangeFunc
Definition: plannodes.h:1088
bool inRangeAsc
Definition: plannodes.h:1097
Index winref
Definition: plannodes.h:1044
AttrNumber *partColIdx pg_node_attr(array_size(partNumCols))
bool inRangeNullsFirst
Definition: plannodes.h:1100
Oid *partOperators pg_node_attr(array_size(partNumCols))
int ordNumCols
Definition: plannodes.h:1059
Oid *ordCollations pg_node_attr(array_size(ordNumCols))
int frameOptions
Definition: plannodes.h:1071
const char * type