1 /*-------------------------------------------------------------------------
4 * definitions for executor state nodes
7 * Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
10 * $PostgreSQL: pgsql/src/include/nodes/execnodes.h,v 1.220 2010/07/28 04:50:50 tgl Exp $
12 *-------------------------------------------------------------------------
17 #include "access/genam.h"
18 #include "access/heapam.h"
19 #include "access/skey.h"
20 #include "nodes/params.h"
21 #include "nodes/plannodes.h"
22 #include "nodes/tidbitmap.h"
23 #include "utils/hsearch.h"
24 #include "utils/rel.h"
25 #include "utils/snapshot.h"
26 #include "utils/tuplestore.h"
30 * IndexInfo information
32 * this struct holds the information needed to construct new index
33 * entries for a particular index. Used for both index_build and
34 * retail creation of index entries.
36 * NumIndexAttrs number of columns in this index
37 * KeyAttrNumbers underlying-rel attribute numbers used as keys
38 * (zeroes indicate expressions)
39 * Expressions expr trees for expression entries, or NIL if none
40 * ExpressionsState exec state for expressions, or NIL if none
41 * Predicate partial-index predicate, or NIL if none
42 * PredicateState exec state for predicate, or NIL if none
43 * ExclusionOps Per-column exclusion operators, or NULL if none
44 * ExclusionProcs Underlying function OIDs for ExclusionOps
45 * ExclusionStrats Opclass strategy numbers for ExclusionOps
46 * Unique is it a unique index?
47 * ReadyForInserts is it valid for inserts?
48 * Concurrent are we doing a concurrent index build?
49 * BrokenHotChain did we detect any broken HOT chains?
51 * ii_Concurrent and ii_BrokenHotChain are used only during index build;
52 * they're conventionally set to false otherwise.
55 typedef struct IndexInfo
59 AttrNumber ii_KeyAttrNumbers[INDEX_MAX_KEYS];
60 List *ii_Expressions; /* list of Expr */
61 List *ii_ExpressionsState; /* list of ExprState */
62 List *ii_Predicate; /* list of Expr */
63 List *ii_PredicateState; /* list of ExprState */
64 Oid *ii_ExclusionOps; /* array with one entry per column */
65 Oid *ii_ExclusionProcs; /* array with one entry per column */
66 uint16 *ii_ExclusionStrats; /* array with one entry per column */
68 bool ii_ReadyForInserts;
70 bool ii_BrokenHotChain;
76 * List of callbacks to be called at ExprContext shutdown.
79 typedef void (*ExprContextCallbackFunction) (Datum arg);
81 typedef struct ExprContext_CB
83 struct ExprContext_CB *next;
84 ExprContextCallbackFunction function;
91 * This class holds the "current context" information
92 * needed to evaluate expressions for doing tuple qualifications
93 * and tuple projections. For example, if an expression refers
94 * to an attribute in the current inner tuple then we need to know
95 * what the current inner tuple is and so we look at the expression
98 * There are two memory contexts associated with an ExprContext:
99 * * ecxt_per_query_memory is a query-lifespan context, typically the same
100 * context the ExprContext node itself is allocated in. This context
101 * can be used for purposes such as storing function call cache info.
102 * * ecxt_per_tuple_memory is a short-term context for expression results.
103 * As the name suggests, it will typically be reset once per tuple,
104 * before we begin to evaluate expressions for that tuple. Each
105 * ExprContext normally has its very own per-tuple memory context.
107 * CurrentMemoryContext should be set to ecxt_per_tuple_memory before
108 * calling ExecEvalExpr() --- see ExecEvalExprSwitchContext().
111 typedef struct ExprContext
115 /* Tuples that Var nodes in expression may refer to */
116 TupleTableSlot *ecxt_scantuple;
117 TupleTableSlot *ecxt_innertuple;
118 TupleTableSlot *ecxt_outertuple;
120 /* Memory contexts for expression evaluation --- see notes above */
121 MemoryContext ecxt_per_query_memory;
122 MemoryContext ecxt_per_tuple_memory;
124 /* Values to substitute for Param nodes in expression */
125 ParamExecData *ecxt_param_exec_vals; /* for PARAM_EXEC params */
126 ParamListInfo ecxt_param_list_info; /* for other param types */
129 * Values to substitute for Aggref nodes in the expressions of an Agg
130 * node, or for WindowFunc nodes within a WindowAgg node.
132 Datum *ecxt_aggvalues; /* precomputed values for aggs/windowfuncs */
133 bool *ecxt_aggnulls; /* null flags for aggs/windowfuncs */
135 /* Value to substitute for CaseTestExpr nodes in expression */
136 Datum caseValue_datum;
137 bool caseValue_isNull;
139 /* Value to substitute for CoerceToDomainValue nodes in expression */
140 Datum domainValue_datum;
141 bool domainValue_isNull;
143 /* Link to containing EState (NULL if a standalone ExprContext) */
144 struct EState *ecxt_estate;
146 /* Functions to call back when ExprContext is shut down */
147 ExprContext_CB *ecxt_callbacks;
151 * Set-result status returned by ExecEvalExpr()
155 ExprSingleResult, /* expression does not return a set */
156 ExprMultipleResult, /* this result is an element of a set */
157 ExprEndResult /* there are no more elements in the set */
161 * Return modes for functions returning sets. Note values must be chosen
162 * as separate bits so that a bitmask can be formed to indicate supported
163 * modes. SFRM_Materialize_Random and SFRM_Materialize_Preferred are
164 * auxiliary flags about SFRM_Materialize mode, rather than separate modes.
168 SFRM_ValuePerCall = 0x01, /* one value returned per call */
169 SFRM_Materialize = 0x02, /* result set instantiated in Tuplestore */
170 SFRM_Materialize_Random = 0x04, /* Tuplestore needs randomAccess */
171 SFRM_Materialize_Preferred = 0x08 /* caller prefers Tuplestore */
172 } SetFunctionReturnMode;
175 * When calling a function that might return a set (multiple rows),
176 * a node of this type is passed as fcinfo->resultinfo to allow
177 * return status to be passed back. A function returning set should
178 * raise an error if no such resultinfo is provided.
180 typedef struct ReturnSetInfo
183 /* values set by caller: */
184 ExprContext *econtext; /* context function is being called in */
185 TupleDesc expectedDesc; /* tuple descriptor expected by caller */
186 int allowedModes; /* bitmask: return modes caller can handle */
187 /* result status from function (but pre-initialized by caller): */
188 SetFunctionReturnMode returnMode; /* actual return mode */
189 ExprDoneCond isDone; /* status for ValuePerCall mode */
190 /* fields filled by function in Materialize return mode: */
191 Tuplestorestate *setResult; /* holds the complete returned tuple set */
192 TupleDesc setDesc; /* actual descriptor for returned tuples */
196 * ProjectionInfo node information
198 * This is all the information needed to perform projections ---
199 * that is, form new tuples by evaluation of targetlist expressions.
200 * Nodes which need to do projections create one of these.
202 * ExecProject() evaluates the tlist, forms a tuple, and stores it
203 * in the given slot. Note that the result will be a "virtual" tuple
204 * unless ExecMaterializeSlot() is then called to force it to be
205 * converted to a physical tuple. The slot must have a tupledesc
206 * that matches the output of the tlist!
208 * The planner very often produces tlists that consist entirely of
209 * simple Var references (lower levels of a plan tree almost always
210 * look like that). And top-level tlists are often mostly Vars too.
211 * We therefore optimize execution of simple-Var tlist entries.
212 * The pi_targetlist list actually contains only the tlist entries that
213 * aren't simple Vars, while those that are Vars are processed using the
214 * varSlotOffsets/varNumbers/varOutputCols arrays.
216 * The lastXXXVar fields are used to optimize fetching of fields from
217 * input tuples: they let us do a slot_getsomeattrs() call to ensure
218 * that all needed attributes are extracted in one pass.
220 * targetlist target list for projection (non-Var expressions only)
221 * exprContext expression context in which to evaluate targetlist
222 * slot slot to place projection result in
223 * itemIsDone workspace array for ExecProject
224 * directMap true if varOutputCols[] is an identity map
225 * numSimpleVars number of simple Vars found in original tlist
226 * varSlotOffsets array indicating which slot each simple Var is from
227 * varNumbers array containing input attr numbers of simple Vars
228 * varOutputCols array containing output attr numbers of simple Vars
229 * lastInnerVar highest attnum from inner tuple slot (0 if none)
230 * lastOuterVar highest attnum from outer tuple slot (0 if none)
231 * lastScanVar highest attnum from scan tuple slot (0 if none)
234 typedef struct ProjectionInfo
238 ExprContext *pi_exprContext;
239 TupleTableSlot *pi_slot;
240 ExprDoneCond *pi_itemIsDone;
242 int pi_numSimpleVars;
243 int *pi_varSlotOffsets;
245 int *pi_varOutputCols;
254 * This class is used to store information regarding junk attributes.
255 * A junk attribute is an attribute in a tuple that is needed only for
256 * storing intermediate information in the executor, and does not belong
257 * in emitted tuples. For example, when we do an UPDATE query,
258 * the planner adds a "junk" entry to the targetlist so that the tuples
259 * returned to ExecutePlan() contain an extra attribute: the ctid of
260 * the tuple to be updated. This is needed to do the update, but we
261 * don't want the ctid to be part of the stored new tuple! So, we
262 * apply a "junk filter" to remove the junk attributes and form the
263 * real output tuple. The junkfilter code also provides routines to
264 * extract the values of the junk attribute(s) from the input tuple.
266 * targetList: the original target list (including junk attributes).
267 * cleanTupType: the tuple descriptor for the "clean" tuple (with
268 * junk attributes removed).
269 * cleanMap: A map with the correspondence between the non-junk
270 * attribute numbers of the "original" tuple and the
271 * attribute numbers of the "clean" tuple.
272 * resultSlot: tuple slot used to hold cleaned tuple.
273 * junkAttNo: not used by junkfilter code. Can be used by caller
274 * to remember the attno of a specific junk attribute
275 * (execMain.c stores the "ctid" attno here).
278 typedef struct JunkFilter
282 TupleDesc jf_cleanTupType;
283 AttrNumber *jf_cleanMap;
284 TupleTableSlot *jf_resultSlot;
285 AttrNumber jf_junkAttNo;
289 * ResultRelInfo information
291 * Whenever we update an existing relation, we have to
292 * update indices on the relation, and perhaps also fire triggers.
293 * The ResultRelInfo class is used to hold all the information needed
294 * about a result relation, including indices.. -cim 10/15/89
296 * RangeTableIndex result relation's range table index
297 * RelationDesc relation descriptor for result relation
298 * NumIndices # of indices existing on result relation
299 * IndexRelationDescs array of relation descriptors for indices
300 * IndexRelationInfo array of key/attr info for indices
301 * TrigDesc triggers to be fired, if any
302 * TrigFunctions cached lookup info for trigger functions
303 * TrigWhenExprs array of trigger WHEN expr states
304 * TrigInstrument optional runtime measurements for triggers
305 * ConstraintExprs array of constraint-checking expr states
306 * junkFilter for removing junk attributes from tuples
307 * projectReturning for computing a RETURNING list
310 typedef struct ResultRelInfo
313 Index ri_RangeTableIndex;
314 Relation ri_RelationDesc;
316 RelationPtr ri_IndexRelationDescs;
317 IndexInfo **ri_IndexRelationInfo;
318 TriggerDesc *ri_TrigDesc;
319 FmgrInfo *ri_TrigFunctions;
320 List **ri_TrigWhenExprs;
321 struct Instrumentation *ri_TrigInstrument;
322 List **ri_ConstraintExprs;
323 JunkFilter *ri_junkFilter;
324 ProjectionInfo *ri_projectReturning;
330 * Master working state for an Executor invocation
333 typedef struct EState
337 /* Basic state for all query types: */
338 ScanDirection es_direction; /* current scan direction */
339 Snapshot es_snapshot; /* time qual to use */
340 Snapshot es_crosscheck_snapshot; /* crosscheck time qual for RI */
341 List *es_range_table; /* List of RangeTblEntry */
342 PlannedStmt *es_plannedstmt; /* link to top of plan tree */
344 JunkFilter *es_junkFilter; /* top-level junk filter, if any */
346 /* If query can insert/delete tuples, the command ID to mark them with */
347 CommandId es_output_cid;
349 /* Info about target table for insert/update/delete queries: */
350 ResultRelInfo *es_result_relations; /* array of ResultRelInfos */
351 int es_num_result_relations; /* length of array */
352 ResultRelInfo *es_result_relation_info; /* currently active array elt */
354 /* Stuff used for firing triggers: */
355 List *es_trig_target_relations; /* trigger-only ResultRelInfos */
356 TupleTableSlot *es_trig_tuple_slot; /* for trigger output tuples */
357 TupleTableSlot *es_trig_oldtup_slot; /* for trigger old tuples */
359 /* Parameter info: */
360 ParamListInfo es_param_list_info; /* values of external params */
361 ParamExecData *es_param_exec_vals; /* values of internal params */
363 /* Other working state: */
364 MemoryContext es_query_cxt; /* per-query context in which EState lives */
366 List *es_tupleTable; /* List of TupleTableSlots */
368 List *es_rowMarks; /* List of ExecRowMarks */
370 uint32 es_processed; /* # of tuples processed */
371 Oid es_lastoid; /* last oid processed (by INSERT) */
373 int es_instrument; /* OR of InstrumentOption flags */
374 bool es_select_into; /* true if doing SELECT INTO */
375 bool es_into_oids; /* true to generate OIDs in SELECT INTO */
377 List *es_exprcontexts; /* List of ExprContexts within EState */
379 List *es_subplanstates; /* List of PlanState for SubPlans */
382 * this ExprContext is for per-output-tuple operations, such as constraint
383 * checks and index-value computations. It will be reset for each output
384 * tuple. Note that it will be created only if needed.
386 ExprContext *es_per_tuple_exprcontext;
389 * These fields are for re-evaluating plan quals when an updated tuple is
390 * substituted in READ COMMITTED mode. es_epqTuple[] contains tuples that
391 * scan plan nodes should return instead of whatever they'd normally
392 * return, or NULL if nothing to return; es_epqTupleSet[] is true if a
393 * particular array entry is valid; and es_epqScanDone[] is state to
394 * remember if the tuple has been returned already. Arrays are of size
395 * list_length(es_range_table) and are indexed by scan node scanrelid - 1.
397 HeapTuple *es_epqTuple; /* array of EPQ substitute tuples */
398 bool *es_epqTupleSet; /* true if EPQ tuple is provided */
399 bool *es_epqScanDone; /* true if EPQ tuple has been fetched */
405 * runtime representation of FOR UPDATE/SHARE clauses
407 * When doing UPDATE, DELETE, or SELECT FOR UPDATE/SHARE, we should have an
408 * ExecRowMark for each non-target relation in the query (except inheritance
409 * parent RTEs, which can be ignored at runtime). See PlanRowMark for details
410 * about most of the fields.
412 * es_rowMarks is a list of these structs. Each LockRows node has its own
413 * list, which is the subset of locks that it is supposed to enforce; note
414 * that the per-node lists point to the same structs that are in the global
417 typedef struct ExecRowMark
419 Relation relation; /* opened and suitably locked relation */
420 Index rti; /* its range table index */
421 Index prti; /* parent range table index, if child */
422 RowMarkType markType; /* see enum in nodes/plannodes.h */
423 bool noWait; /* NOWAIT option */
424 AttrNumber ctidAttNo; /* resno of ctid junk attribute, if any */
425 AttrNumber toidAttNo; /* resno of tableoid junk attribute, if any */
426 AttrNumber wholeAttNo; /* resno of whole-row junk attribute, if any */
427 ItemPointerData curCtid; /* ctid of currently locked tuple, if any */
431 /* ----------------------------------------------------------------
434 * All-in-memory tuple hash tables are used for a number of purposes.
436 * Note: tab_hash_funcs are for the key datatype(s) stored in the table,
437 * and tab_eq_funcs are non-cross-type equality operators for those types.
438 * Normally these are the only functions used, but FindTupleHashEntry()
439 * supports searching a hashtable using cross-data-type hashing. For that,
440 * the caller must supply hash functions for the LHS datatype as well as
441 * the cross-type equality operators to use. in_hash_funcs and cur_eq_funcs
442 * are set to point to the caller's function arrays while doing such a search.
443 * During LookupTupleHashEntry(), they point to tab_hash_funcs and
444 * tab_eq_funcs respectively.
445 * ----------------------------------------------------------------
447 typedef struct TupleHashEntryData *TupleHashEntry;
448 typedef struct TupleHashTableData *TupleHashTable;
450 typedef struct TupleHashEntryData
452 /* firstTuple must be the first field in this struct! */
453 MinimalTuple firstTuple; /* copy of first tuple in this group */
454 /* there may be additional data beyond the end of this struct */
455 } TupleHashEntryData; /* VARIABLE LENGTH STRUCT */
457 typedef struct TupleHashTableData
459 HTAB *hashtab; /* underlying dynahash table */
460 int numCols; /* number of columns in lookup key */
461 AttrNumber *keyColIdx; /* attr numbers of key columns */
462 FmgrInfo *tab_hash_funcs; /* hash functions for table datatype(s) */
463 FmgrInfo *tab_eq_funcs; /* equality functions for table datatype(s) */
464 MemoryContext tablecxt; /* memory context containing table */
465 MemoryContext tempcxt; /* context for function evaluations */
466 Size entrysize; /* actual size to make each hash entry */
467 TupleTableSlot *tableslot; /* slot for referencing table entries */
468 /* The following fields are set transiently for each table search: */
469 TupleTableSlot *inputslot; /* current input tuple's slot */
470 FmgrInfo *in_hash_funcs; /* hash functions for input datatype(s) */
471 FmgrInfo *cur_eq_funcs; /* equality functions for input vs. table */
472 } TupleHashTableData;
474 typedef HASH_SEQ_STATUS TupleHashIterator;
477 * Use InitTupleHashIterator/TermTupleHashIterator for a read/write scan.
478 * Use ResetTupleHashIterator if the table can be frozen (in this case no
479 * explicit scan termination is needed).
481 #define InitTupleHashIterator(htable, iter) \
482 hash_seq_init(iter, (htable)->hashtab)
483 #define TermTupleHashIterator(iter) \
485 #define ResetTupleHashIterator(htable, iter) \
487 hash_freeze((htable)->hashtab); \
488 hash_seq_init(iter, (htable)->hashtab); \
490 #define ScanTupleHashTable(iter) \
491 ((TupleHashEntry) hash_seq_search(iter))
494 /* ----------------------------------------------------------------
495 * Expression State Trees
497 * Each executable expression tree has a parallel ExprState tree.
499 * Unlike PlanState, there is not an exact one-for-one correspondence between
500 * ExprState node types and Expr node types. Many Expr node types have no
501 * need for node-type-specific run-time state, and so they can use plain
502 * ExprState or GenericExprState as their associated ExprState node type.
503 * ----------------------------------------------------------------
509 * ExprState is the common superclass for all ExprState-type nodes.
511 * It can also be instantiated directly for leaf Expr nodes that need no
512 * local run-time state (such as Var, Const, or Param).
514 * To save on dispatch overhead, each ExprState node contains a function
515 * pointer to the routine to execute to evaluate the node.
519 typedef struct ExprState ExprState;
521 typedef Datum (*ExprStateEvalFunc) (ExprState *expression,
522 ExprContext *econtext,
524 ExprDoneCond *isDone);
529 Expr *expr; /* associated Expr node */
530 ExprStateEvalFunc evalfunc; /* routine to run to execute node */
534 * GenericExprState node
536 * This is used for Expr node types that need no local run-time state,
537 * but have one child Expr node.
540 typedef struct GenericExprState
543 ExprState *arg; /* state of my child node */
547 * AggrefExprState node
550 typedef struct AggrefExprState
553 List *args; /* states of argument expressions */
554 int aggno; /* ID number for agg within its plan node */
558 * WindowFuncExprState node
561 typedef struct WindowFuncExprState
564 List *args; /* states of argument expressions */
565 int wfuncno; /* ID number for wfunc within its plan node */
566 } WindowFuncExprState;
569 * ArrayRefExprState node
571 * Note: array types can be fixed-length (typlen > 0), but only when the
572 * element type is itself fixed-length. Otherwise they are varlena structures
573 * and have typlen = -1. In any case, an array type is never pass-by-value.
576 typedef struct ArrayRefExprState
579 List *refupperindexpr; /* states for child nodes */
580 List *reflowerindexpr;
582 ExprState *refassgnexpr;
583 int16 refattrlength; /* typlen of array type */
584 int16 refelemlength; /* typlen of the array element type */
585 bool refelembyval; /* is the element type pass-by-value? */
586 char refelemalign; /* typalign of the element type */
592 * Although named for FuncExpr, this is also used for OpExpr, DistinctExpr,
593 * and NullIf nodes; be careful to check what xprstate.expr is actually
597 typedef struct FuncExprState
600 List *args; /* states of argument expressions */
603 * Function manager's lookup info for the target function. If func.fn_oid
604 * is InvalidOid, we haven't initialized it yet (nor any of the following
610 * For a set-returning function (SRF) that returns a tuplestore, we keep
611 * the tuplestore here and dole out the result rows one at a time. The
612 * slot holds the row currently being returned.
614 Tuplestorestate *funcResultStore;
615 TupleTableSlot *funcResultSlot;
618 * In some cases we need to compute a tuple descriptor for the function's
619 * output. If so, it's stored here.
621 TupleDesc funcResultDesc;
622 bool funcReturnsTuple; /* valid when funcResultDesc isn't
626 * We need to store argument values across calls when evaluating a SRF
627 * that uses value-per-call mode.
629 * setArgsValid is true when we are evaluating a set-valued function and
630 * we are in the middle of a call series; we want to pass the same
631 * argument values to the function again (and again, until it returns
637 * Flag to remember whether we found a set-valued argument to the
638 * function. This causes the function result to be a set as well. Valid
639 * only when setArgsValid is true or funcResultStore isn't NULL.
641 bool setHasSetArg; /* some argument returns a set */
644 * Flag to remember whether we have registered a shutdown callback for
645 * this FuncExprState. We do so only if funcResultStore or setArgsValid
646 * has been set at least once (since all the callback is for is to release
647 * the tuplestore or clear setArgsValid).
649 bool shutdown_reg; /* a shutdown callback is registered */
652 * Current argument data for a set-valued function; contains valid data
653 * only if setArgsValid is true.
655 FunctionCallInfoData setArgs;
659 * ScalarArrayOpExprState node
661 * This is a FuncExprState plus some additional data.
664 typedef struct ScalarArrayOpExprState
666 FuncExprState fxprstate;
667 /* Cached info about array element type */
672 } ScalarArrayOpExprState;
678 typedef struct BoolExprState
681 List *args; /* states of argument expression(s) */
688 typedef struct SubPlanState
691 struct PlanState *planstate; /* subselect plan's state tree */
692 ExprState *testexpr; /* state of combining expression */
693 List *args; /* states of argument expression(s) */
694 HeapTuple curTuple; /* copy of most recent tuple from subplan */
695 /* these are used when hashing the subselect's output: */
696 ProjectionInfo *projLeft; /* for projecting lefthand exprs */
697 ProjectionInfo *projRight; /* for projecting subselect output */
698 TupleHashTable hashtable; /* hash table for no-nulls subselect rows */
699 TupleHashTable hashnulls; /* hash table for rows with null(s) */
700 bool havehashrows; /* TRUE if hashtable is not empty */
701 bool havenullrows; /* TRUE if hashnulls is not empty */
702 MemoryContext hashtablecxt; /* memory context containing hash tables */
703 MemoryContext hashtempcxt; /* temp memory context for hash tables */
704 ExprContext *innerecontext; /* econtext for computing inner tuples */
705 AttrNumber *keyColIdx; /* control data for hash tables */
706 FmgrInfo *tab_hash_funcs; /* hash functions for table datatype(s) */
707 FmgrInfo *tab_eq_funcs; /* equality functions for table datatype(s) */
708 FmgrInfo *lhs_hash_funcs; /* hash functions for lefthand datatype(s) */
709 FmgrInfo *cur_eq_funcs; /* equality functions for LHS vs. table */
713 * AlternativeSubPlanState node
716 typedef struct AlternativeSubPlanState
719 List *subplans; /* states of alternative subplans */
720 int active; /* list index of the one we're using */
721 } AlternativeSubPlanState;
724 * FieldSelectState node
727 typedef struct FieldSelectState
730 ExprState *arg; /* input expression */
731 TupleDesc argdesc; /* tupdesc for most recent input */
735 * FieldStoreState node
738 typedef struct FieldStoreState
741 ExprState *arg; /* input tuple value */
742 List *newvals; /* new value(s) for field(s) */
743 TupleDesc argdesc; /* tupdesc for most recent input */
747 * CoerceViaIOState node
750 typedef struct CoerceViaIOState
753 ExprState *arg; /* input expression */
754 FmgrInfo outfunc; /* lookup info for source output function */
755 FmgrInfo infunc; /* lookup info for result input function */
756 Oid intypioparam; /* argument needed for input function */
760 * ArrayCoerceExprState node
763 typedef struct ArrayCoerceExprState
766 ExprState *arg; /* input array value */
767 Oid resultelemtype; /* element type of result array */
768 FmgrInfo elemfunc; /* lookup info for element coercion function */
769 /* use struct pointer to avoid including array.h here */
770 struct ArrayMapState *amstate; /* workspace for array_map */
771 } ArrayCoerceExprState;
774 * ConvertRowtypeExprState node
777 typedef struct ConvertRowtypeExprState
780 ExprState *arg; /* input tuple value */
781 TupleDesc indesc; /* tupdesc for source rowtype */
782 TupleDesc outdesc; /* tupdesc for result rowtype */
783 /* use "struct" so we needn't include tupconvert.h here */
784 struct TupleConversionMap *map;
786 } ConvertRowtypeExprState;
792 typedef struct CaseExprState
795 ExprState *arg; /* implicit equality comparison argument */
796 List *args; /* the arguments (list of WHEN clauses) */
797 ExprState *defresult; /* the default result (ELSE clause) */
804 typedef struct CaseWhenState
807 ExprState *expr; /* condition expression */
808 ExprState *result; /* substitution result */
812 * ArrayExprState node
814 * Note: ARRAY[] expressions always produce varlena arrays, never fixed-length
818 typedef struct ArrayExprState
821 List *elements; /* states for child nodes */
822 int16 elemlength; /* typlen of the array element type */
823 bool elembyval; /* is the element type pass-by-value? */
824 char elemalign; /* typalign of the element type */
831 typedef struct RowExprState
834 List *args; /* the arguments */
835 TupleDesc tupdesc; /* descriptor for result tuples */
839 * RowCompareExprState node
842 typedef struct RowCompareExprState
845 List *largs; /* the left-hand input arguments */
846 List *rargs; /* the right-hand input arguments */
847 FmgrInfo *funcs; /* array of comparison function info */
848 } RowCompareExprState;
851 * CoalesceExprState node
854 typedef struct CoalesceExprState
857 List *args; /* the arguments */
861 * MinMaxExprState node
864 typedef struct MinMaxExprState
867 List *args; /* the arguments */
868 FmgrInfo cfunc; /* lookup info for comparison func */
875 typedef struct XmlExprState
878 List *named_args; /* ExprStates for named arguments */
879 List *args; /* ExprStates for other arguments */
886 typedef struct NullTestState
889 ExprState *arg; /* input expression */
890 /* used only if input is of composite type: */
891 TupleDesc argdesc; /* tupdesc for most recent input */
895 * CoerceToDomainState node
898 typedef struct CoerceToDomainState
901 ExprState *arg; /* input expression */
902 /* Cached list of constraints that need to be checked */
903 List *constraints; /* list of DomainConstraintState nodes */
904 } CoerceToDomainState;
907 * DomainConstraintState - one item to check during CoerceToDomain
909 * Note: this is just a Node, and not an ExprState, because it has no
910 * corresponding Expr to link to. Nonetheless it is part of an ExprState
911 * tree, so we give it a name following the xxxState convention.
913 typedef enum DomainConstraintType
915 DOM_CONSTRAINT_NOTNULL,
917 } DomainConstraintType;
919 typedef struct DomainConstraintState
922 DomainConstraintType constrainttype; /* constraint type */
923 char *name; /* name of constraint (for error msgs) */
924 ExprState *check_expr; /* for CHECK, a boolean expression */
925 } DomainConstraintState;
928 /* ----------------------------------------------------------------
929 * Executor State Trees
931 * An executing query has a PlanState tree paralleling the Plan tree
932 * that describes the plan.
933 * ----------------------------------------------------------------
939 * We never actually instantiate any PlanState nodes; this is just the common
940 * abstract superclass for all PlanState-type nodes.
943 typedef struct PlanState
947 Plan *plan; /* associated Plan node */
949 EState *state; /* at execution time, states of individual
950 * nodes point to one EState for the whole
953 struct Instrumentation *instrument; /* Optional runtime stats for this
957 * Common structural data for all Plan types. These links to subsidiary
958 * state trees parallel links in the associated plan tree (except for the
959 * subPlan list, which does not exist in the plan tree).
961 List *targetlist; /* target list to be computed at this node */
962 List *qual; /* implicitly-ANDed qual conditions */
963 struct PlanState *lefttree; /* input plan tree(s) */
964 struct PlanState *righttree;
965 List *initPlan; /* Init SubPlanState nodes (un-correlated expr
967 List *subPlan; /* SubPlanState nodes in my expressions */
970 * State for management of parameter-change-driven rescanning
972 Bitmapset *chgParam; /* set of IDs of changed Params */
975 * Other run-time state needed by most if not all node types.
977 TupleTableSlot *ps_ResultTupleSlot; /* slot for my result tuples */
978 ExprContext *ps_ExprContext; /* node's expression-evaluation context */
979 ProjectionInfo *ps_ProjInfo; /* info for doing tuple projection */
980 bool ps_TupFromTlist;/* state flag for processing set-valued
981 * functions in targetlist */
985 * these are are defined to avoid confusion problems with "left"
986 * and "right" and "inner" and "outer". The convention is that
987 * the "left" plan is the "outer" plan and the "right" plan is
988 * the inner plan, but these make the code more readable.
991 #define innerPlanState(node) (((PlanState *)(node))->righttree)
992 #define outerPlanState(node) (((PlanState *)(node))->lefttree)
995 * EPQState is state for executing an EvalPlanQual recheck on a candidate
996 * tuple in ModifyTable or LockRows. The estate and planstate fields are
999 typedef struct EPQState
1001 EState *estate; /* subsidiary EState */
1002 PlanState *planstate; /* plan state tree ready to be executed */
1003 TupleTableSlot *origslot; /* original output tuple to be rechecked */
1004 Plan *plan; /* plan tree to be executed */
1005 List *rowMarks; /* ExecRowMarks (non-locking only) */
1006 int epqParam; /* ID of Param to force scan node re-eval */
1011 * ResultState information
1014 typedef struct ResultState
1016 PlanState ps; /* its first field is NodeTag */
1017 ExprState *resconstantqual;
1018 bool rs_done; /* are we done? */
1019 bool rs_checkqual; /* do we need to check the qual? */
1023 * ModifyTableState information
1026 typedef struct ModifyTableState
1028 PlanState ps; /* its first field is NodeTag */
1030 PlanState **mt_plans; /* subplans (one per target rel) */
1031 int mt_nplans; /* number of plans in the array */
1032 int mt_whichplan; /* which one is being executed (0..n-1) */
1033 EPQState mt_epqstate; /* for evaluating EvalPlanQual rechecks */
1034 bool fireBSTriggers; /* do we need to fire stmt triggers? */
1038 * AppendState information
1040 * nplans how many plans are in the array
1041 * whichplan which plan is being executed (0 .. n-1)
1044 typedef struct AppendState
1046 PlanState ps; /* its first field is NodeTag */
1047 PlanState **appendplans; /* array of PlanStates for my inputs */
1053 * RecursiveUnionState information
1055 * RecursiveUnionState is used for performing a recursive union.
1057 * recursing T when we're done scanning the non-recursive term
1058 * intermediate_empty T if intermediate_table is currently empty
1059 * working_table working table (to be scanned by recursive term)
1060 * intermediate_table current recursive output (next generation of WT)
1063 typedef struct RecursiveUnionState
1065 PlanState ps; /* its first field is NodeTag */
1067 bool intermediate_empty;
1068 Tuplestorestate *working_table;
1069 Tuplestorestate *intermediate_table;
1070 /* Remaining fields are unused in UNION ALL case */
1071 FmgrInfo *eqfunctions; /* per-grouping-field equality fns */
1072 FmgrInfo *hashfunctions; /* per-grouping-field hash fns */
1073 MemoryContext tempContext; /* short-term context for comparisons */
1074 TupleHashTable hashtable; /* hash table for tuples already seen */
1075 MemoryContext tableContext; /* memory context containing hash table */
1076 } RecursiveUnionState;
1079 * BitmapAndState information
1082 typedef struct BitmapAndState
1084 PlanState ps; /* its first field is NodeTag */
1085 PlanState **bitmapplans; /* array of PlanStates for my inputs */
1086 int nplans; /* number of input plans */
1090 * BitmapOrState information
1093 typedef struct BitmapOrState
1095 PlanState ps; /* its first field is NodeTag */
1096 PlanState **bitmapplans; /* array of PlanStates for my inputs */
1097 int nplans; /* number of input plans */
1100 /* ----------------------------------------------------------------
1101 * Scan State Information
1102 * ----------------------------------------------------------------
1106 * ScanState information
1108 * ScanState extends PlanState for node types that represent
1109 * scans of an underlying relation. It can also be used for nodes
1110 * that scan the output of an underlying plan node --- in that case,
1111 * only ScanTupleSlot is actually useful, and it refers to the tuple
1112 * retrieved from the subplan.
1114 * currentRelation relation being scanned (NULL if none)
1115 * currentScanDesc current scan descriptor for scan (NULL if none)
1116 * ScanTupleSlot pointer to slot in tuple table holding scan tuple
1119 typedef struct ScanState
1121 PlanState ps; /* its first field is NodeTag */
1122 Relation ss_currentRelation;
1123 HeapScanDesc ss_currentScanDesc;
1124 TupleTableSlot *ss_ScanTupleSlot;
1128 * SeqScan uses a bare ScanState as its state node, since it needs
1129 * no additional fields.
1131 typedef ScanState SeqScanState;
1134 * These structs store information about index quals that don't have simple
1135 * constant right-hand sides. See comments for ExecIndexBuildScanKeys()
1140 ScanKey scan_key; /* scankey to put value into */
1141 ExprState *key_expr; /* expr to evaluate to get value */
1142 bool key_toastable; /* is expr's result a toastable datatype? */
1143 } IndexRuntimeKeyInfo;
1147 ScanKey scan_key; /* scankey to put value into */
1148 ExprState *array_expr; /* expr to evaluate to get array value */
1149 int next_elem; /* next array element to use */
1150 int num_elems; /* number of elems in current array value */
1151 Datum *elem_values; /* array of num_elems Datums */
1152 bool *elem_nulls; /* array of num_elems is-null flags */
1153 } IndexArrayKeyInfo;
1156 * IndexScanState information
1158 * indexqualorig execution state for indexqualorig expressions
1159 * ScanKeys Skey structures to scan index rel
1160 * NumScanKeys number of Skey structs
1161 * RuntimeKeys info about Skeys that must be evaluated at runtime
1162 * NumRuntimeKeys number of RuntimeKeys structs
1163 * RuntimeKeysReady true if runtime Skeys have been computed
1164 * RuntimeContext expr context for evaling runtime Skeys
1165 * RelationDesc index relation descriptor
1166 * ScanDesc index scan descriptor
1169 typedef struct IndexScanState
1171 ScanState ss; /* its first field is NodeTag */
1172 List *indexqualorig;
1173 ScanKey iss_ScanKeys;
1174 int iss_NumScanKeys;
1175 IndexRuntimeKeyInfo *iss_RuntimeKeys;
1176 int iss_NumRuntimeKeys;
1177 bool iss_RuntimeKeysReady;
1178 ExprContext *iss_RuntimeContext;
1179 Relation iss_RelationDesc;
1180 IndexScanDesc iss_ScanDesc;
1184 * BitmapIndexScanState information
1186 * result bitmap to return output into, or NULL
1187 * ScanKeys Skey structures to scan index rel
1188 * NumScanKeys number of Skey structs
1189 * RuntimeKeys info about Skeys that must be evaluated at runtime
1190 * NumRuntimeKeys number of RuntimeKeys structs
1191 * ArrayKeys info about Skeys that come from ScalarArrayOpExprs
1192 * NumArrayKeys number of ArrayKeys structs
1193 * RuntimeKeysReady true if runtime Skeys have been computed
1194 * RuntimeContext expr context for evaling runtime Skeys
1195 * RelationDesc index relation descriptor
1196 * ScanDesc index scan descriptor
1199 typedef struct BitmapIndexScanState
1201 ScanState ss; /* its first field is NodeTag */
1202 TIDBitmap *biss_result;
1203 ScanKey biss_ScanKeys;
1204 int biss_NumScanKeys;
1205 IndexRuntimeKeyInfo *biss_RuntimeKeys;
1206 int biss_NumRuntimeKeys;
1207 IndexArrayKeyInfo *biss_ArrayKeys;
1208 int biss_NumArrayKeys;
1209 bool biss_RuntimeKeysReady;
1210 ExprContext *biss_RuntimeContext;
1211 Relation biss_RelationDesc;
1212 IndexScanDesc biss_ScanDesc;
1213 } BitmapIndexScanState;
1216 * BitmapHeapScanState information
1218 * bitmapqualorig execution state for bitmapqualorig expressions
1219 * tbm bitmap obtained from child index scan(s)
1220 * tbmiterator iterator for scanning current pages
1221 * tbmres current-page data
1222 * prefetch_iterator iterator for prefetching ahead of current page
1223 * prefetch_pages # pages prefetch iterator is ahead of current
1224 * prefetch_target target prefetch distance
1227 typedef struct BitmapHeapScanState
1229 ScanState ss; /* its first field is NodeTag */
1230 List *bitmapqualorig;
1232 TBMIterator *tbmiterator;
1233 TBMIterateResult *tbmres;
1234 TBMIterator *prefetch_iterator;
1236 int prefetch_target;
1237 } BitmapHeapScanState;
1240 * TidScanState information
1242 * isCurrentOf scan has a CurrentOfExpr qual
1243 * NumTids number of tids in this scan
1244 * TidPtr index of currently fetched tid
1245 * TidList evaluated item pointers (array of size NumTids)
1248 typedef struct TidScanState
1250 ScanState ss; /* its first field is NodeTag */
1251 List *tss_tidquals; /* list of ExprState nodes */
1252 bool tss_isCurrentOf;
1256 ItemPointerData *tss_TidList;
1257 HeapTupleData tss_htup;
1261 * SubqueryScanState information
1263 * SubqueryScanState is used for scanning a sub-query in the range table.
1264 * ScanTupleSlot references the current output tuple of the sub-query.
1267 typedef struct SubqueryScanState
1269 ScanState ss; /* its first field is NodeTag */
1271 } SubqueryScanState;
1274 * FunctionScanState information
1276 * Function nodes are used to scan the results of a
1277 * function appearing in FROM (typically a function returning set).
1279 * eflags node's capability flags
1280 * tupdesc expected return tuple description
1281 * tuplestorestate private state of tuplestore.c
1282 * funcexpr state for function expression being evaluated
1285 typedef struct FunctionScanState
1287 ScanState ss; /* its first field is NodeTag */
1290 Tuplestorestate *tuplestorestate;
1291 ExprState *funcexpr;
1292 } FunctionScanState;
1295 * ValuesScanState information
1297 * ValuesScan nodes are used to scan the results of a VALUES list
1299 * rowcontext per-expression-list context
1300 * exprlists array of expression lists being evaluated
1301 * array_len size of array
1302 * curr_idx current array index (0-based)
1303 * marked_idx marked position (for mark/restore)
1305 * Note: ss.ps.ps_ExprContext is used to evaluate any qual or projection
1306 * expressions attached to the node. We create a second ExprContext,
1307 * rowcontext, in which to build the executor expression state for each
1308 * Values sublist. Resetting this context lets us get rid of expression
1309 * state for each row, avoiding major memory leakage over a long values list.
1312 typedef struct ValuesScanState
1314 ScanState ss; /* its first field is NodeTag */
1315 ExprContext *rowcontext;
1323 * CteScanState information
1325 * CteScan nodes are used to scan a CommonTableExpr query.
1327 * Multiple CteScan nodes can read out from the same CTE query. We use
1328 * a tuplestore to hold rows that have been read from the CTE query but
1329 * not yet consumed by all readers.
1332 typedef struct CteScanState
1334 ScanState ss; /* its first field is NodeTag */
1335 int eflags; /* capability flags to pass to tuplestore */
1336 int readptr; /* index of my tuplestore read pointer */
1337 PlanState *cteplanstate; /* PlanState for the CTE query itself */
1338 /* Link to the "leader" CteScanState (possibly this same node) */
1339 struct CteScanState *leader;
1340 /* The remaining fields are only valid in the "leader" CteScanState */
1341 Tuplestorestate *cte_table; /* rows already read from the CTE query */
1342 bool eof_cte; /* reached end of CTE query? */
1346 * WorkTableScanState information
1348 * WorkTableScan nodes are used to scan the work table created by
1349 * a RecursiveUnion node. We locate the RecursiveUnion node
1350 * during executor startup.
1353 typedef struct WorkTableScanState
1355 ScanState ss; /* its first field is NodeTag */
1356 RecursiveUnionState *rustate;
1357 } WorkTableScanState;
1359 /* ----------------------------------------------------------------
1360 * Join State Information
1361 * ----------------------------------------------------------------
1365 * JoinState information
1367 * Superclass for state nodes of join plans.
1370 typedef struct JoinState
1374 List *joinqual; /* JOIN quals (in addition to ps.qual) */
1378 * NestLoopState information
1380 * NeedNewOuter true if need new outer tuple on next call
1381 * MatchedOuter true if found a join match for current outer tuple
1382 * NullInnerTupleSlot prepared null tuple for left outer joins
1385 typedef struct NestLoopState
1387 JoinState js; /* its first field is NodeTag */
1388 bool nl_NeedNewOuter;
1389 bool nl_MatchedOuter;
1390 TupleTableSlot *nl_NullInnerTupleSlot;
1394 * MergeJoinState information
1396 * NumClauses number of mergejoinable join clauses
1397 * Clauses info for each mergejoinable clause
1398 * JoinState current "state" of join. see execdefs.h
1399 * ExtraMarks true to issue extra Mark operations on inner scan
1400 * ConstFalseJoin true if we have a constant-false joinqual
1401 * FillOuter true if should emit unjoined outer tuples anyway
1402 * FillInner true if should emit unjoined inner tuples anyway
1403 * MatchedOuter true if found a join match for current outer tuple
1404 * MatchedInner true if found a join match for current inner tuple
1405 * OuterTupleSlot slot in tuple table for cur outer tuple
1406 * InnerTupleSlot slot in tuple table for cur inner tuple
1407 * MarkedTupleSlot slot in tuple table for marked tuple
1408 * NullOuterTupleSlot prepared null tuple for right outer joins
1409 * NullInnerTupleSlot prepared null tuple for left outer joins
1410 * OuterEContext workspace for computing outer tuple's join values
1411 * InnerEContext workspace for computing inner tuple's join values
1414 /* private in nodeMergejoin.c: */
1415 typedef struct MergeJoinClauseData *MergeJoinClause;
1417 typedef struct MergeJoinState
1419 JoinState js; /* its first field is NodeTag */
1421 MergeJoinClause mj_Clauses; /* array of length mj_NumClauses */
1424 bool mj_ConstFalseJoin;
1427 bool mj_MatchedOuter;
1428 bool mj_MatchedInner;
1429 TupleTableSlot *mj_OuterTupleSlot;
1430 TupleTableSlot *mj_InnerTupleSlot;
1431 TupleTableSlot *mj_MarkedTupleSlot;
1432 TupleTableSlot *mj_NullOuterTupleSlot;
1433 TupleTableSlot *mj_NullInnerTupleSlot;
1434 ExprContext *mj_OuterEContext;
1435 ExprContext *mj_InnerEContext;
1439 * HashJoinState information
1441 * hj_HashTable hash table for the hashjoin
1442 * (NULL if table not built yet)
1443 * hj_CurHashValue hash value for current outer tuple
1444 * hj_CurBucketNo regular bucket# for current outer tuple
1445 * hj_CurSkewBucketNo skew bucket# for current outer tuple
1446 * hj_CurTuple last inner tuple matched to current outer
1447 * tuple, or NULL if starting search
1448 * (hj_CurXXX variables are undefined if
1449 * OuterTupleSlot is empty!)
1450 * hj_OuterHashKeys the outer hash keys in the hashjoin condition
1451 * hj_InnerHashKeys the inner hash keys in the hashjoin condition
1452 * hj_HashOperators the join operators in the hashjoin condition
1453 * hj_OuterTupleSlot tuple slot for outer tuples
1454 * hj_HashTupleSlot tuple slot for hashed tuples
1455 * hj_NullInnerTupleSlot prepared null tuple for left outer joins
1456 * hj_FirstOuterTupleSlot first tuple retrieved from outer plan
1457 * hj_NeedNewOuter true if need new outer tuple on next call
1458 * hj_MatchedOuter true if found a join match for current outer
1459 * hj_OuterNotEmpty true if outer relation known not empty
1463 /* these structs are defined in executor/hashjoin.h: */
1464 typedef struct HashJoinTupleData *HashJoinTuple;
1465 typedef struct HashJoinTableData *HashJoinTable;
1467 typedef struct HashJoinState
1469 JoinState js; /* its first field is NodeTag */
1470 List *hashclauses; /* list of ExprState nodes */
1471 HashJoinTable hj_HashTable;
1472 uint32 hj_CurHashValue;
1474 int hj_CurSkewBucketNo;
1475 HashJoinTuple hj_CurTuple;
1476 List *hj_OuterHashKeys; /* list of ExprState nodes */
1477 List *hj_InnerHashKeys; /* list of ExprState nodes */
1478 List *hj_HashOperators; /* list of operator OIDs */
1479 TupleTableSlot *hj_OuterTupleSlot;
1480 TupleTableSlot *hj_HashTupleSlot;
1481 TupleTableSlot *hj_NullInnerTupleSlot;
1482 TupleTableSlot *hj_FirstOuterTupleSlot;
1483 bool hj_NeedNewOuter;
1484 bool hj_MatchedOuter;
1485 bool hj_OuterNotEmpty;
1489 /* ----------------------------------------------------------------
1490 * Materialization State Information
1491 * ----------------------------------------------------------------
1495 * MaterialState information
1497 * materialize nodes are used to materialize the results
1498 * of a subplan into a temporary file.
1500 * ss.ss_ScanTupleSlot refers to output of underlying plan.
1503 typedef struct MaterialState
1505 ScanState ss; /* its first field is NodeTag */
1506 int eflags; /* capability flags to pass to tuplestore */
1507 bool eof_underlying; /* reached end of underlying plan? */
1508 Tuplestorestate *tuplestorestate;
1512 * SortState information
1515 typedef struct SortState
1517 ScanState ss; /* its first field is NodeTag */
1518 bool randomAccess; /* need random access to sort output? */
1519 bool bounded; /* is the result set bounded? */
1520 int64 bound; /* if bounded, how many tuples are needed */
1521 bool sort_Done; /* sort completed yet? */
1522 bool bounded_Done; /* value of bounded we did the sort with */
1523 int64 bound_Done; /* value of bound we did the sort with */
1524 void *tuplesortstate; /* private state of tuplesort.c */
1527 /* ---------------------
1528 * GroupState information
1529 * -------------------------
1531 typedef struct GroupState
1533 ScanState ss; /* its first field is NodeTag */
1534 FmgrInfo *eqfunctions; /* per-field lookup data for equality fns */
1535 bool grp_done; /* indicates completion of Group scan */
1538 /* ---------------------
1539 * AggState information
1541 * ss.ss_ScanTupleSlot refers to output of underlying plan.
1543 * Note: ss.ps.ps_ExprContext contains ecxt_aggvalues and
1544 * ecxt_aggnulls arrays, which hold the computed agg values for the current
1545 * input group during evaluation of an Agg node's output tuple(s). We
1546 * create a second ExprContext, tmpcontext, in which to evaluate input
1547 * expressions and run the aggregate transition functions.
1548 * -------------------------
1550 /* these structs are private in nodeAgg.c: */
1551 typedef struct AggStatePerAggData *AggStatePerAgg;
1552 typedef struct AggStatePerGroupData *AggStatePerGroup;
1554 typedef struct AggState
1556 ScanState ss; /* its first field is NodeTag */
1557 List *aggs; /* all Aggref nodes in targetlist & quals */
1558 int numaggs; /* length of list (could be zero!) */
1559 FmgrInfo *eqfunctions; /* per-grouping-field equality fns */
1560 FmgrInfo *hashfunctions; /* per-grouping-field hash fns */
1561 AggStatePerAgg peragg; /* per-Aggref information */
1562 MemoryContext aggcontext; /* memory context for long-lived data */
1563 ExprContext *tmpcontext; /* econtext for input expressions */
1564 bool agg_done; /* indicates completion of Agg scan */
1565 /* these fields are used in AGG_PLAIN and AGG_SORTED modes: */
1566 AggStatePerGroup pergroup; /* per-Aggref-per-group working state */
1567 HeapTuple grp_firstTuple; /* copy of first tuple of current group */
1568 /* these fields are used in AGG_HASHED mode: */
1569 TupleHashTable hashtable; /* hash table with one entry per group */
1570 TupleTableSlot *hashslot; /* slot for loading hash table */
1571 List *hash_needed; /* list of columns needed in hash table */
1572 bool table_filled; /* hash table filled yet? */
1573 TupleHashIterator hashiter; /* for iterating through hash table */
1577 * WindowAggState information
1580 /* these structs are private in nodeWindowAgg.c: */
1581 typedef struct WindowStatePerFuncData *WindowStatePerFunc;
1582 typedef struct WindowStatePerAggData *WindowStatePerAgg;
1584 typedef struct WindowAggState
1586 ScanState ss; /* its first field is NodeTag */
1588 /* these fields are filled in by ExecInitExpr: */
1589 List *funcs; /* all WindowFunc nodes in targetlist */
1590 int numfuncs; /* total number of window functions */
1591 int numaggs; /* number that are plain aggregates */
1593 WindowStatePerFunc perfunc; /* per-window-function information */
1594 WindowStatePerAgg peragg; /* per-plain-aggregate information */
1595 FmgrInfo *partEqfunctions; /* equality funcs for partition columns */
1596 FmgrInfo *ordEqfunctions; /* equality funcs for ordering columns */
1597 Tuplestorestate *buffer; /* stores rows of current partition */
1598 int current_ptr; /* read pointer # for current */
1599 int64 spooled_rows; /* total # of rows in buffer */
1600 int64 currentpos; /* position of current row in partition */
1601 int64 frameheadpos; /* current frame head position */
1602 int64 frametailpos; /* current frame tail position */
1603 /* use struct pointer to avoid including windowapi.h here */
1604 struct WindowObjectData *agg_winobj; /* winobj for aggregate
1606 int64 aggregatedbase; /* start row for current aggregates */
1607 int64 aggregatedupto; /* rows before this one are aggregated */
1609 int frameOptions; /* frame_clause options, see WindowDef */
1610 ExprState *startOffset; /* expression for starting bound offset */
1611 ExprState *endOffset; /* expression for ending bound offset */
1612 Datum startOffsetValue; /* result of startOffset evaluation */
1613 Datum endOffsetValue; /* result of endOffset evaluation */
1615 MemoryContext partcontext; /* context for partition-lifespan data */
1616 MemoryContext aggcontext; /* context for each aggregate data */
1617 ExprContext *tmpcontext; /* short-term evaluation context */
1619 bool all_first; /* true if the scan is starting */
1620 bool all_done; /* true if the scan is finished */
1621 bool partition_spooled; /* true if all tuples in current
1622 * partition have been spooled into
1624 bool more_partitions;/* true if there's more partitions after this
1626 bool framehead_valid;/* true if frameheadpos is known up to date
1627 * for current row */
1628 bool frametail_valid;/* true if frametailpos is known up to date
1629 * for current row */
1631 TupleTableSlot *first_part_slot; /* first tuple of current or next
1634 /* temporary slots for tuples fetched back from tuplestore */
1635 TupleTableSlot *agg_row_slot;
1636 TupleTableSlot *temp_slot_1;
1637 TupleTableSlot *temp_slot_2;
1641 * UniqueState information
1643 * Unique nodes are used "on top of" sort nodes to discard
1644 * duplicate tuples returned from the sort phase. Basically
1645 * all it does is compare the current tuple from the subplan
1646 * with the previously fetched tuple (stored in its result slot).
1647 * If the two are identical in all interesting fields, then
1648 * we just fetch another tuple from the sort and try again.
1651 typedef struct UniqueState
1653 PlanState ps; /* its first field is NodeTag */
1654 FmgrInfo *eqfunctions; /* per-field lookup data for equality fns */
1655 MemoryContext tempContext; /* short-term context for comparisons */
1659 * HashState information
1662 typedef struct HashState
1664 PlanState ps; /* its first field is NodeTag */
1665 HashJoinTable hashtable; /* hash table for the hashjoin */
1666 List *hashkeys; /* list of ExprState nodes */
1667 /* hashkeys is same as parent's hj_InnerHashKeys */
1671 * SetOpState information
1673 * Even in "sorted" mode, SetOp nodes are more complex than a simple
1674 * Unique, since we have to count how many duplicates to return. But
1675 * we also support hashing, so this is really more like a cut-down
1679 /* this struct is private in nodeSetOp.c: */
1680 typedef struct SetOpStatePerGroupData *SetOpStatePerGroup;
1682 typedef struct SetOpState
1684 PlanState ps; /* its first field is NodeTag */
1685 FmgrInfo *eqfunctions; /* per-grouping-field equality fns */
1686 FmgrInfo *hashfunctions; /* per-grouping-field hash fns */
1687 bool setop_done; /* indicates completion of output scan */
1688 long numOutput; /* number of dups left to output */
1689 MemoryContext tempContext; /* short-term context for comparisons */
1690 /* these fields are used in SETOP_SORTED mode: */
1691 SetOpStatePerGroup pergroup; /* per-group working state */
1692 HeapTuple grp_firstTuple; /* copy of first tuple of current group */
1693 /* these fields are used in SETOP_HASHED mode: */
1694 TupleHashTable hashtable; /* hash table with one entry per group */
1695 MemoryContext tableContext; /* memory context containing hash table */
1696 bool table_filled; /* hash table filled yet? */
1697 TupleHashIterator hashiter; /* for iterating through hash table */
1701 * LockRowsState information
1703 * LockRows nodes are used to enforce FOR UPDATE/FOR SHARE locking.
1706 typedef struct LockRowsState
1708 PlanState ps; /* its first field is NodeTag */
1709 List *lr_rowMarks; /* List of ExecRowMarks */
1710 EPQState lr_epqstate; /* for evaluating EvalPlanQual rechecks */
1714 * LimitState information
1716 * Limit nodes are used to enforce LIMIT/OFFSET clauses.
1717 * They just select the desired subrange of their subplan's output.
1719 * offset is the number of initial tuples to skip (0 does nothing).
1720 * count is the number of tuples to return after skipping the offset tuples.
1721 * If no limit count was specified, count is undefined and noCount is true.
1722 * When lstate == LIMIT_INITIAL, offset/count/noCount haven't been set yet.
1727 LIMIT_INITIAL, /* initial state for LIMIT node */
1728 LIMIT_RESCAN, /* rescan after recomputing parameters */
1729 LIMIT_EMPTY, /* there are no returnable rows */
1730 LIMIT_INWINDOW, /* have returned a row in the window */
1731 LIMIT_SUBPLANEOF, /* at EOF of subplan (within window) */
1732 LIMIT_WINDOWEND, /* stepped off end of window */
1733 LIMIT_WINDOWSTART /* stepped off beginning of window */
1736 typedef struct LimitState
1738 PlanState ps; /* its first field is NodeTag */
1739 ExprState *limitOffset; /* OFFSET parameter, or NULL if none */
1740 ExprState *limitCount; /* COUNT parameter, or NULL if none */
1741 int64 offset; /* current OFFSET value */
1742 int64 count; /* current COUNT, if any */
1743 bool noCount; /* if true, ignore count */
1744 LimitStateCond lstate; /* state machine status, as above */
1745 int64 position; /* 1-based index of last tuple returned */
1746 TupleTableSlot *subSlot; /* tuple last obtained from subplan */
1749 #endif /* EXECNODES_H */