PostgreSQL Source Code  git master
execnodes.h
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * execnodes.h
4  * definitions for executor state nodes
5  *
6  * Most plan node types declared in plannodes.h have a corresponding
7  * execution-state node type declared here. An exception is that
8  * expression nodes (subtypes of Expr) are usually represented by steps
9  * of an ExprState, and fully handled within execExpr* - but sometimes
10  * their state needs to be shared with other parts of the executor, as
11  * for example with SubPlanState, which nodeSubplan.c has to modify.
12  *
13  * Node types declared in this file do not have any copy/equal/out/read
14  * support. (That is currently hard-wired in gen_node_support.pl, rather
15  * than being explicitly represented by pg_node_attr decorations here.)
16  * There is no need for copy, equal, or read support for executor trees.
17  * Output support could be useful for debugging; but there are a lot of
18  * specialized fields that would require custom code, so for now it's
19  * not provided.
20  *
21  *
22  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
23  * Portions Copyright (c) 1994, Regents of the University of California
24  *
25  * src/include/nodes/execnodes.h
26  *
27  *-------------------------------------------------------------------------
28  */
29 #ifndef EXECNODES_H
30 #define EXECNODES_H
31 
32 #include "access/tupconvert.h"
33 #include "executor/instrument.h"
34 #include "fmgr.h"
35 #include "lib/ilist.h"
36 #include "lib/pairingheap.h"
37 #include "nodes/params.h"
38 #include "nodes/plannodes.h"
39 #include "nodes/tidbitmap.h"
40 #include "partitioning/partdefs.h"
42 #include "utils/hsearch.h"
43 #include "utils/queryenvironment.h"
44 #include "utils/reltrigger.h"
45 #include "utils/sharedtuplestore.h"
46 #include "utils/snapshot.h"
47 #include "utils/sortsupport.h"
48 #include "utils/tuplesort.h"
49 #include "utils/tuplestore.h"
50 
51 struct PlanState; /* forward references in this file */
53 struct ExecRowMark;
54 struct ExprState;
55 struct ExprContext;
56 struct RangeTblEntry; /* avoid including parsenodes.h here */
57 struct ExprEvalStep; /* avoid including execExpr.h everywhere */
59 struct LogicalTapeSet;
60 
61 
62 /* ----------------
63  * ExprState node
64  *
65  * ExprState represents the evaluation state for a whole expression tree.
66  * It contains instructions (in ->steps) to evaluate the expression.
67  * ----------------
68  */
69 typedef Datum (*ExprStateEvalFunc) (struct ExprState *expression,
70  struct ExprContext *econtext,
71  bool *isNull);
72 
73 /* Bits in ExprState->flags (see also execExpr.h for private flag bits): */
74 /* expression is for use with ExecQual() */
75 #define EEO_FLAG_IS_QUAL (1 << 0)
76 
77 typedef struct ExprState
78 {
80 
81  uint8 flags; /* bitmask of EEO_FLAG_* bits, see above */
82 
83  /*
84  * Storage for result value of a scalar expression, or for individual
85  * column results within expressions built by ExecBuildProjectionInfo().
86  */
87 #define FIELDNO_EXPRSTATE_RESNULL 2
88  bool resnull;
89 #define FIELDNO_EXPRSTATE_RESVALUE 3
91 
92  /*
93  * If projecting a tuple result, this slot holds the result; else NULL.
94  */
95 #define FIELDNO_EXPRSTATE_RESULTSLOT 4
97 
98  /*
99  * Instructions to compute expression's return value.
100  */
102 
103  /*
104  * Function that actually evaluates the expression. This can be set to
105  * different values depending on the complexity of the expression.
106  */
108 
109  /* original expression tree, for debugging only */
111 
112  /* private state for an evalfunc */
114 
115  /*
116  * XXX: following fields only needed during "compilation" (ExecInitExpr);
117  * could be thrown away afterwards.
118  */
119 
120  int steps_len; /* number of steps currently */
121  int steps_alloc; /* allocated length of steps array */
122 
123 #define FIELDNO_EXPRSTATE_PARENT 11
124  struct PlanState *parent; /* parent PlanState node, if any */
125  ParamListInfo ext_params; /* for compiling PARAM_EXTERN nodes */
126 
129 
133 
134 
135 /* ----------------
136  * IndexInfo information
137  *
138  * this struct holds the information needed to construct new index
139  * entries for a particular index. Used for both index_build and
140  * retail creation of index entries.
141  *
142  * NumIndexAttrs total number of columns in this index
143  * NumIndexKeyAttrs number of key columns in index
144  * IndexAttrNumbers underlying-rel attribute numbers used as keys
145  * (zeroes indicate expressions). It also contains
146  * info about included columns.
147  * Expressions expr trees for expression entries, or NIL if none
148  * ExpressionsState exec state for expressions, or NIL if none
149  * Predicate partial-index predicate, or NIL if none
150  * PredicateState exec state for predicate, or NIL if none
151  * ExclusionOps Per-column exclusion operators, or NULL if none
152  * ExclusionProcs Underlying function OIDs for ExclusionOps
153  * ExclusionStrats Opclass strategy numbers for ExclusionOps
154  * UniqueOps These are like Exclusion*, but for unique indexes
155  * UniqueProcs
156  * UniqueStrats
157  * Unique is it a unique index?
158  * OpclassOptions opclass-specific options, or NULL if none
159  * ReadyForInserts is it valid for inserts?
160  * CheckedUnchanged IndexUnchanged status determined yet?
161  * IndexUnchanged aminsert hint, cached for retail inserts
162  * Concurrent are we doing a concurrent index build?
163  * BrokenHotChain did we detect any broken HOT chains?
164  * Summarizing is it a summarizing index?
165  * ParallelWorkers # of workers requested (excludes leader)
166  * Am Oid of index AM
167  * AmCache private cache area for index AM
168  * Context memory context holding this IndexInfo
169  *
170  * ii_Concurrent, ii_BrokenHotChain, and ii_ParallelWorkers are used only
171  * during index build; they're conventionally zeroed otherwise.
172  * ----------------
173  */
174 typedef struct IndexInfo
175 {
177  int ii_NumIndexAttrs; /* total number of columns in index */
178  int ii_NumIndexKeyAttrs; /* number of key columns in index */
180  List *ii_Expressions; /* list of Expr */
181  List *ii_ExpressionsState; /* list of ExprState */
182  List *ii_Predicate; /* list of Expr */
184  Oid *ii_ExclusionOps; /* array with one entry per column */
185  Oid *ii_ExclusionProcs; /* array with one entry per column */
186  uint16 *ii_ExclusionStrats; /* array with one entry per column */
187  Oid *ii_UniqueOps; /* array with one entry per column */
188  Oid *ii_UniqueProcs; /* array with one entry per column */
189  uint16 *ii_UniqueStrats; /* array with one entry per column */
190  Datum *ii_OpclassOptions; /* array with one entry per column */
191  bool ii_Unique;
201  void *ii_AmCache;
204 
205 /* ----------------
206  * ExprContext_CB
207  *
208  * List of callbacks to be called at ExprContext shutdown.
209  * ----------------
210  */
212 
213 typedef struct ExprContext_CB
214 {
219 
220 /* ----------------
221  * ExprContext
222  *
223  * This class holds the "current context" information
224  * needed to evaluate expressions for doing tuple qualifications
225  * and tuple projections. For example, if an expression refers
226  * to an attribute in the current inner tuple then we need to know
227  * what the current inner tuple is and so we look at the expression
228  * context.
229  *
230  * There are two memory contexts associated with an ExprContext:
231  * * ecxt_per_query_memory is a query-lifespan context, typically the same
232  * context the ExprContext node itself is allocated in. This context
233  * can be used for purposes such as storing function call cache info.
234  * * ecxt_per_tuple_memory is a short-term context for expression results.
235  * As the name suggests, it will typically be reset once per tuple,
236  * before we begin to evaluate expressions for that tuple. Each
237  * ExprContext normally has its very own per-tuple memory context.
238  *
239  * CurrentMemoryContext should be set to ecxt_per_tuple_memory before
240  * calling ExecEvalExpr() --- see ExecEvalExprSwitchContext().
241  * ----------------
242  */
243 typedef struct ExprContext
244 {
246 
247  /* Tuples that Var nodes in expression may refer to */
248 #define FIELDNO_EXPRCONTEXT_SCANTUPLE 1
250 #define FIELDNO_EXPRCONTEXT_INNERTUPLE 2
252 #define FIELDNO_EXPRCONTEXT_OUTERTUPLE 3
254 
255  /* Memory contexts for expression evaluation --- see notes above */
258 
259  /* Values to substitute for Param nodes in expression */
260  ParamExecData *ecxt_param_exec_vals; /* for PARAM_EXEC params */
261  ParamListInfo ecxt_param_list_info; /* for other param types */
262 
263  /*
264  * Values to substitute for Aggref nodes in the expressions of an Agg
265  * node, or for WindowFunc nodes within a WindowAgg node.
266  */
267 #define FIELDNO_EXPRCONTEXT_AGGVALUES 8
268  Datum *ecxt_aggvalues; /* precomputed values for aggs/windowfuncs */
269 #define FIELDNO_EXPRCONTEXT_AGGNULLS 9
270  bool *ecxt_aggnulls; /* null flags for aggs/windowfuncs */
271 
272  /* Value to substitute for CaseTestExpr nodes in expression */
273 #define FIELDNO_EXPRCONTEXT_CASEDATUM 10
275 #define FIELDNO_EXPRCONTEXT_CASENULL 11
277 
278  /* Value to substitute for CoerceToDomainValue nodes in expression */
279 #define FIELDNO_EXPRCONTEXT_DOMAINDATUM 12
281 #define FIELDNO_EXPRCONTEXT_DOMAINNULL 13
283 
284  /* Link to containing EState (NULL if a standalone ExprContext) */
286 
287  /* Functions to call back when ExprContext is shut down or rescanned */
290 
291 /*
292  * Set-result status used when evaluating functions potentially returning a
293  * set.
294  */
295 typedef enum
296 {
297  ExprSingleResult, /* expression does not return a set */
298  ExprMultipleResult, /* this result is an element of a set */
299  ExprEndResult /* there are no more elements in the set */
301 
302 /*
303  * Return modes for functions returning sets. Note values must be chosen
304  * as separate bits so that a bitmask can be formed to indicate supported
305  * modes. SFRM_Materialize_Random and SFRM_Materialize_Preferred are
306  * auxiliary flags about SFRM_Materialize mode, rather than separate modes.
307  */
308 typedef enum
309 {
310  SFRM_ValuePerCall = 0x01, /* one value returned per call */
311  SFRM_Materialize = 0x02, /* result set instantiated in Tuplestore */
312  SFRM_Materialize_Random = 0x04, /* Tuplestore needs randomAccess */
313  SFRM_Materialize_Preferred = 0x08 /* caller prefers Tuplestore */
315 
316 /*
317  * When calling a function that might return a set (multiple rows),
318  * a node of this type is passed as fcinfo->resultinfo to allow
319  * return status to be passed back. A function returning set should
320  * raise an error if no such resultinfo is provided.
321  */
322 typedef struct ReturnSetInfo
323 {
325  /* values set by caller: */
326  ExprContext *econtext; /* context function is being called in */
327  TupleDesc expectedDesc; /* tuple descriptor expected by caller */
328  int allowedModes; /* bitmask: return modes caller can handle */
329  /* result status from function (but pre-initialized by caller): */
330  SetFunctionReturnMode returnMode; /* actual return mode */
331  ExprDoneCond isDone; /* status for ValuePerCall mode */
332  /* fields filled by function in Materialize return mode: */
333  Tuplestorestate *setResult; /* holds the complete returned tuple set */
334  TupleDesc setDesc; /* actual descriptor for returned tuples */
336 
337 /* ----------------
338  * ProjectionInfo node information
339  *
340  * This is all the information needed to perform projections ---
341  * that is, form new tuples by evaluation of targetlist expressions.
342  * Nodes which need to do projections create one of these.
343  *
344  * The target tuple slot is kept in ProjectionInfo->pi_state.resultslot.
345  * ExecProject() evaluates the tlist, forms a tuple, and stores it
346  * in the given slot. Note that the result will be a "virtual" tuple
347  * unless ExecMaterializeSlot() is then called to force it to be
348  * converted to a physical tuple. The slot must have a tupledesc
349  * that matches the output of the tlist!
350  * ----------------
351  */
352 typedef struct ProjectionInfo
353 {
355  /* instructions to evaluate projection */
357  /* expression context in which to evaluate expression */
360 
361 /* ----------------
362  * JunkFilter
363  *
364  * This class is used to store information regarding junk attributes.
365  * A junk attribute is an attribute in a tuple that is needed only for
366  * storing intermediate information in the executor, and does not belong
367  * in emitted tuples. For example, when we do an UPDATE query,
368  * the planner adds a "junk" entry to the targetlist so that the tuples
369  * returned to ExecutePlan() contain an extra attribute: the ctid of
370  * the tuple to be updated. This is needed to do the update, but we
371  * don't want the ctid to be part of the stored new tuple! So, we
372  * apply a "junk filter" to remove the junk attributes and form the
373  * real output tuple. The junkfilter code also provides routines to
374  * extract the values of the junk attribute(s) from the input tuple.
375  *
376  * targetList: the original target list (including junk attributes).
377  * cleanTupType: the tuple descriptor for the "clean" tuple (with
378  * junk attributes removed).
379  * cleanMap: A map with the correspondence between the non-junk
380  * attribute numbers of the "original" tuple and the
381  * attribute numbers of the "clean" tuple.
382  * resultSlot: tuple slot used to hold cleaned tuple.
383  * ----------------
384  */
385 typedef struct JunkFilter
386 {
393 
394 /*
395  * OnConflictSetState
396  *
397  * Executor state of an ON CONFLICT DO UPDATE operation.
398  */
399 typedef struct OnConflictSetState
400 {
402 
403  TupleTableSlot *oc_Existing; /* slot to store existing target tuple in */
404  TupleTableSlot *oc_ProjSlot; /* CONFLICT ... SET ... projection target */
405  ProjectionInfo *oc_ProjInfo; /* for ON CONFLICT DO UPDATE SET */
406  ExprState *oc_WhereClause; /* state for the WHERE clause */
408 
409 /* ----------------
410  * MergeActionState information
411  *
412  * Executor state for a MERGE action.
413  * ----------------
414  */
415 typedef struct MergeActionState
416 {
418 
419  MergeAction *mas_action; /* associated MergeAction node */
420  ProjectionInfo *mas_proj; /* projection of the action's targetlist for
421  * this rel */
422  ExprState *mas_whenqual; /* WHEN [NOT] MATCHED AND conditions */
424 
425 /*
426  * ResultRelInfo
427  *
428  * Whenever we update an existing relation, we have to update indexes on the
429  * relation, and perhaps also fire triggers. ResultRelInfo holds all the
430  * information needed about a result relation, including indexes.
431  *
432  * Normally, a ResultRelInfo refers to a table that is in the query's range
433  * table; then ri_RangeTableIndex is the RT index and ri_RelationDesc is
434  * just a copy of the relevant es_relations[] entry. However, in some
435  * situations we create ResultRelInfos for relations that are not in the
436  * range table, namely for targets of tuple routing in a partitioned table,
437  * and when firing triggers in tables other than the target tables (See
438  * ExecGetTriggerResultRel). In these situations, ri_RangeTableIndex is 0
439  * and ri_RelationDesc is a separately-opened relcache pointer that needs to
440  * be separately closed.
441  */
442 typedef struct ResultRelInfo
443 {
445 
446  /* result relation's range table index, or 0 if not in range table */
448 
449  /* relation descriptor for result relation */
451 
452  /* # of indices existing on result relation */
454 
455  /* array of relation descriptors for indices */
457 
458  /* array of key/attr info for indices */
460 
461  /*
462  * For UPDATE/DELETE result relations, the attribute number of the row
463  * identity junk attribute in the source plan's output tuples
464  */
466 
467  /* For UPDATE, attnums of generated columns to be computed */
469 
470  /* Projection to generate new tuple in an INSERT/UPDATE */
472  /* Slot to hold that tuple */
474  /* Slot to hold the old tuple being updated */
476  /* Have the projection and the slots above been initialized? */
478 
479  /* triggers to be fired, if any */
481 
482  /* cached lookup info for trigger functions */
484 
485  /* array of trigger WHEN expr states */
487 
488  /* optional runtime measurements for triggers */
490 
491  /* On-demand created slots for triggers / returning processing */
492  TupleTableSlot *ri_ReturningSlot; /* for trigger output tuples */
493  TupleTableSlot *ri_TrigOldSlot; /* for a trigger's old tuple */
494  TupleTableSlot *ri_TrigNewSlot; /* for a trigger's new tuple */
495 
496  /* FDW callback functions, if foreign table */
498 
499  /* available to save private state of FDW */
500  void *ri_FdwState;
501 
502  /* true when modifying foreign table directly */
504 
505  /* batch insert stuff */
506  int ri_NumSlots; /* number of slots in the array */
507  int ri_NumSlotsInitialized; /* number of initialized slots */
508  int ri_BatchSize; /* max slots inserted in a single batch */
509  TupleTableSlot **ri_Slots; /* input tuples for batch insert */
511 
512  /* list of WithCheckOption's to be checked */
514 
515  /* list of WithCheckOption expr states */
517 
518  /* array of constraint-checking expr states */
520 
521  /* arrays of stored generated columns expr states, for INSERT and UPDATE */
524 
525  /* number of stored generated columns we need to compute */
528 
529  /* list of RETURNING expressions */
531 
532  /* for computing a RETURNING list */
534 
535  /* list of arbiter indexes to use to check conflicts */
537 
538  /* ON CONFLICT evaluation state */
540 
541  /* for MERGE, lists of MergeActionState */
544 
545  /* partition check expression state (NULL if not set up yet) */
547 
548  /*
549  * Map to convert child result relation tuples to the format of the table
550  * actually mentioned in the query (called "root"). Computed only if
551  * needed. A NULL map value indicates that no conversion is needed, so we
552  * must have a separate flag to show if the map has been computed.
553  */
556 
557  /*
558  * As above, but in the other direction.
559  */
562 
563  /*
564  * Information needed by tuple routing target relations
565  *
566  * RootResultRelInfo gives the target relation mentioned in the query, if
567  * it's a partitioned table. It is not set if the target relation
568  * mentioned in the query is an inherited table, nor when tuple routing is
569  * not needed.
570  *
571  * PartitionTupleSlot is non-NULL if RootToChild conversion is needed and
572  * the relation is a partition.
573  */
576 
577  /* for use by copyfrom.c when performing multi-inserts */
579 
580  /*
581  * Used when a leaf partition is involved in a cross-partition update of
582  * one of its ancestors; see ExecCrossPartitionUpdateForeignKey().
583  */
586 
587 /* ----------------
588  * AsyncRequest
589  *
590  * State for an asynchronous tuple request.
591  * ----------------
592  */
593 typedef struct AsyncRequest
594 {
595  struct PlanState *requestor; /* Node that wants a tuple */
596  struct PlanState *requestee; /* Node from which a tuple is wanted */
597  int request_index; /* Scratch space for requestor */
598  bool callback_pending; /* Callback is needed */
599  bool request_complete; /* Request complete, result valid */
600  TupleTableSlot *result; /* Result (NULL or an empty slot if no more
601  * tuples) */
603 
604 /* ----------------
605  * EState information
606  *
607  * Working state for an Executor invocation
608  * ----------------
609  */
610 typedef struct EState
611 {
613 
614  /* Basic state for all query types: */
615  ScanDirection es_direction; /* current scan direction */
616  Snapshot es_snapshot; /* time qual to use */
617  Snapshot es_crosscheck_snapshot; /* crosscheck time qual for RI */
618  List *es_range_table; /* List of RangeTblEntry */
619  Index es_range_table_size; /* size of the range table arrays */
620  Relation *es_relations; /* Array of per-range-table-entry Relation
621  * pointers, or NULL if not yet opened */
622  struct ExecRowMark **es_rowmarks; /* Array of per-range-table-entry
623  * ExecRowMarks, or NULL if none */
624  List *es_rteperminfos; /* List of RTEPermissionInfo */
625  PlannedStmt *es_plannedstmt; /* link to top of plan tree */
626  const char *es_sourceText; /* Source text from QueryDesc */
627 
628  JunkFilter *es_junkFilter; /* top-level junk filter, if any */
629 
630  /* If query can insert/delete tuples, the command ID to mark them with */
632 
633  /* Info about target table(s) for insert/update/delete queries: */
634  ResultRelInfo **es_result_relations; /* Array of per-range-table-entry
635  * ResultRelInfo pointers, or NULL
636  * if not a target table */
637  List *es_opened_result_relations; /* List of non-NULL entries in
638  * es_result_relations in no
639  * specific order */
640 
641  PartitionDirectory es_partition_directory; /* for PartitionDesc lookup */
642 
643  /*
644  * The following list contains ResultRelInfos created by the tuple routing
645  * code for partitions that aren't found in the es_result_relations array.
646  */
648 
649  /* Stuff used for firing triggers: */
650  List *es_trig_target_relations; /* trigger-only ResultRelInfos */
651 
652  /* Parameter info: */
653  ParamListInfo es_param_list_info; /* values of external params */
654  ParamExecData *es_param_exec_vals; /* values of internal params */
655 
656  QueryEnvironment *es_queryEnv; /* query environment */
657 
658  /* Other working state: */
659  MemoryContext es_query_cxt; /* per-query context in which EState lives */
660 
661  List *es_tupleTable; /* List of TupleTableSlots */
662 
663  uint64 es_processed; /* # of tuples processed during one
664  * ExecutorRun() call. */
665  uint64 es_total_processed; /* total # of tuples aggregated across all
666  * ExecutorRun() calls. */
667 
668  int es_top_eflags; /* eflags passed to ExecutorStart */
669  int es_instrument; /* OR of InstrumentOption flags */
670  bool es_finished; /* true when ExecutorFinish is done */
671 
672  List *es_exprcontexts; /* List of ExprContexts within EState */
673 
674  List *es_subplanstates; /* List of PlanState for SubPlans */
675 
676  List *es_auxmodifytables; /* List of secondary ModifyTableStates */
677 
678  /*
679  * this ExprContext is for per-output-tuple operations, such as constraint
680  * checks and index-value computations. It will be reset for each output
681  * tuple. Note that it will be created only if needed.
682  */
684 
685  /*
686  * If not NULL, this is an EPQState's EState. This is a field in EState
687  * both to allow EvalPlanQual aware executor nodes to detect that they
688  * need to perform EPQ related work, and to provide necessary information
689  * to do so.
690  */
692 
693  bool es_use_parallel_mode; /* can we use parallel workers? */
694 
695  /* The per-query shared memory area to use for parallel execution. */
697 
698  /*
699  * JIT information. es_jit_flags indicates whether JIT should be performed
700  * and with which options. es_jit is created on-demand when JITing is
701  * performed.
702  *
703  * es_jit_worker_instr is the combined, on demand allocated,
704  * instrumentation from all workers. The leader's instrumentation is kept
705  * separate, and is combined on demand by ExplainPrintJITSummary().
706  */
710 
711  /*
712  * Lists of ResultRelInfos for foreign tables on which batch-inserts are
713  * to be executed and owning ModifyTableStates, stored in the same order.
714  */
718 
719 
720 /*
721  * ExecRowMark -
722  * runtime representation of FOR [KEY] UPDATE/SHARE clauses
723  *
724  * When doing UPDATE, DELETE, or SELECT FOR [KEY] UPDATE/SHARE, we will have an
725  * ExecRowMark for each non-target relation in the query (except inheritance
726  * parent RTEs, which can be ignored at runtime). Virtual relations such as
727  * subqueries-in-FROM will have an ExecRowMark with relation == NULL. See
728  * PlanRowMark for details about most of the fields. In addition to fields
729  * directly derived from PlanRowMark, we store an activity flag (to denote
730  * inactive children of inheritance trees), curCtid, which is used by the
731  * WHERE CURRENT OF code, and ermExtra, which is available for use by the plan
732  * node that sources the relation (e.g., for a foreign table the FDW can use
733  * ermExtra to hold information).
734  *
735  * EState->es_rowmarks is an array of these structs, indexed by RT index,
736  * with NULLs for irrelevant RT indexes. es_rowmarks itself is NULL if
737  * there are no rowmarks.
738  */
739 typedef struct ExecRowMark
740 {
741  Relation relation; /* opened and suitably locked relation */
742  Oid relid; /* its OID (or InvalidOid, if subquery) */
743  Index rti; /* its range table index */
744  Index prti; /* parent range table index, if child */
745  Index rowmarkId; /* unique identifier for resjunk columns */
746  RowMarkType markType; /* see enum in nodes/plannodes.h */
747  LockClauseStrength strength; /* LockingClause's strength, or LCS_NONE */
748  LockWaitPolicy waitPolicy; /* NOWAIT and SKIP LOCKED */
749  bool ermActive; /* is this mark relevant for current tuple? */
750  ItemPointerData curCtid; /* ctid of currently locked tuple, if any */
751  void *ermExtra; /* available for use by relation source node */
753 
754 /*
755  * ExecAuxRowMark -
756  * additional runtime representation of FOR [KEY] UPDATE/SHARE clauses
757  *
758  * Each LockRows and ModifyTable node keeps a list of the rowmarks it needs to
759  * deal with. In addition to a pointer to the related entry in es_rowmarks,
760  * this struct carries the column number(s) of the resjunk columns associated
761  * with the rowmark (see comments for PlanRowMark for more detail).
762  */
763 typedef struct ExecAuxRowMark
764 {
765  ExecRowMark *rowmark; /* related entry in es_rowmarks */
766  AttrNumber ctidAttNo; /* resno of ctid junk attribute, if any */
767  AttrNumber toidAttNo; /* resno of tableoid junk attribute, if any */
768  AttrNumber wholeAttNo; /* resno of whole-row junk attribute, if any */
770 
771 
772 /* ----------------------------------------------------------------
773  * Tuple Hash Tables
774  *
775  * All-in-memory tuple hash tables are used for a number of purposes.
776  *
777  * Note: tab_hash_funcs are for the key datatype(s) stored in the table,
778  * and tab_eq_funcs are non-cross-type equality operators for those types.
779  * Normally these are the only functions used, but FindTupleHashEntry()
780  * supports searching a hashtable using cross-data-type hashing. For that,
781  * the caller must supply hash functions for the LHS datatype as well as
782  * the cross-type equality operators to use. in_hash_funcs and cur_eq_func
783  * are set to point to the caller's function arrays while doing such a search.
784  * During LookupTupleHashEntry(), they point to tab_hash_funcs and
785  * tab_eq_func respectively.
786  * ----------------------------------------------------------------
787  */
790 
791 typedef struct TupleHashEntryData
792 {
793  MinimalTuple firstTuple; /* copy of first tuple in this group */
794  void *additional; /* user data */
795  uint32 status; /* hash status */
796  uint32 hash; /* hash value (cached) */
798 
799 /* define parameters necessary to generate the tuple hash table interface */
800 #define SH_PREFIX tuplehash
801 #define SH_ELEMENT_TYPE TupleHashEntryData
802 #define SH_KEY_TYPE MinimalTuple
803 #define SH_SCOPE extern
804 #define SH_DECLARE
805 #include "lib/simplehash.h"
806 
807 typedef struct TupleHashTableData
808 {
809  tuplehash_hash *hashtab; /* underlying hash table */
810  int numCols; /* number of columns in lookup key */
811  AttrNumber *keyColIdx; /* attr numbers of key columns */
812  FmgrInfo *tab_hash_funcs; /* hash functions for table datatype(s) */
813  ExprState *tab_eq_func; /* comparator for table datatype(s) */
814  Oid *tab_collations; /* collations for hash and comparison */
815  MemoryContext tablecxt; /* memory context containing table */
816  MemoryContext tempcxt; /* context for function evaluations */
817  Size entrysize; /* actual size to make each hash entry */
818  TupleTableSlot *tableslot; /* slot for referencing table entries */
819  /* The following fields are set transiently for each table search: */
820  TupleTableSlot *inputslot; /* current input tuple's slot */
821  FmgrInfo *in_hash_funcs; /* hash functions for input datatype(s) */
822  ExprState *cur_eq_func; /* comparator for input vs. table */
823  uint32 hash_iv; /* hash-function IV */
824  ExprContext *exprcontext; /* expression context */
826 
827 typedef tuplehash_iterator TupleHashIterator;
828 
829 /*
830  * Use InitTupleHashIterator/TermTupleHashIterator for a read/write scan.
831  * Use ResetTupleHashIterator if the table can be frozen (in this case no
832  * explicit scan termination is needed).
833  */
834 #define InitTupleHashIterator(htable, iter) \
835  tuplehash_start_iterate(htable->hashtab, iter)
836 #define TermTupleHashIterator(iter) \
837  ((void) 0)
838 #define ResetTupleHashIterator(htable, iter) \
839  InitTupleHashIterator(htable, iter)
840 #define ScanTupleHashTable(htable, iter) \
841  tuplehash_iterate(htable->hashtab, iter)
842 
843 
844 /* ----------------------------------------------------------------
845  * Expression State Nodes
846  *
847  * Formerly, there was a separate executor expression state node corresponding
848  * to each node in a planned expression tree. That's no longer the case; for
849  * common expression node types, all the execution info is embedded into
850  * step(s) in a single ExprState node. But we still have a few executor state
851  * node types for selected expression node types, mostly those in which info
852  * has to be shared with other parts of the execution state tree.
853  * ----------------------------------------------------------------
854  */
855 
856 /* ----------------
857  * WindowFuncExprState node
858  * ----------------
859  */
860 typedef struct WindowFuncExprState
861 {
863  WindowFunc *wfunc; /* expression plan node */
864  List *args; /* ExprStates for argument expressions */
865  ExprState *aggfilter; /* FILTER expression */
866  int wfuncno; /* ID number for wfunc within its plan node */
868 
869 
870 /* ----------------
871  * SetExprState node
872  *
873  * State for evaluating a potentially set-returning expression (like FuncExpr
874  * or OpExpr). In some cases, like some of the expressions in ROWS FROM(...)
875  * the expression might not be a SRF, but nonetheless it uses the same
876  * machinery as SRFs; it will be treated as a SRF returning a single row.
877  * ----------------
878  */
879 typedef struct SetExprState
880 {
882  Expr *expr; /* expression plan node */
883  List *args; /* ExprStates for argument expressions */
884 
885  /*
886  * In ROWS FROM, functions can be inlined, removing the FuncExpr normally
887  * inside. In such a case this is the compiled expression (which cannot
888  * return a set), which'll be evaluated using regular ExecEvalExpr().
889  */
891 
892  /*
893  * Function manager's lookup info for the target function. If func.fn_oid
894  * is InvalidOid, we haven't initialized it yet (nor any of the following
895  * fields, except funcReturnsSet).
896  */
898 
899  /*
900  * For a set-returning function (SRF) that returns a tuplestore, we keep
901  * the tuplestore here and dole out the result rows one at a time. The
902  * slot holds the row currently being returned.
903  */
906 
907  /*
908  * In some cases we need to compute a tuple descriptor for the function's
909  * output. If so, it's stored here.
910  */
912  bool funcReturnsTuple; /* valid when funcResultDesc isn't NULL */
913 
914  /*
915  * Remember whether the function is declared to return a set. This is set
916  * by ExecInitExpr, and is valid even before the FmgrInfo is set up.
917  */
919 
920  /*
921  * setArgsValid is true when we are evaluating a set-returning function
922  * that uses value-per-call mode and we are in the middle of a call
923  * series; we want to pass the same argument values to the function again
924  * (and again, until it returns ExprEndResult). This indicates that
925  * fcinfo_data already contains valid argument data.
926  */
928 
929  /*
930  * Flag to remember whether we have registered a shutdown callback for
931  * this SetExprState. We do so only if funcResultStore or setArgsValid
932  * has been set at least once (since all the callback is for is to release
933  * the tuplestore or clear setArgsValid).
934  */
935  bool shutdown_reg; /* a shutdown callback is registered */
936 
937  /*
938  * Call parameter structure for the function. This has been initialized
939  * (by InitFunctionCallInfoData) if func.fn_oid is valid. It also saves
940  * argument values between calls, when setArgsValid is true.
941  */
944 
945 /* ----------------
946  * SubPlanState node
947  * ----------------
948  */
949 typedef struct SubPlanState
950 {
952  SubPlan *subplan; /* expression plan node */
953  struct PlanState *planstate; /* subselect plan's state tree */
954  struct PlanState *parent; /* parent plan node's state tree */
955  ExprState *testexpr; /* state of combining expression */
956  List *args; /* states of argument expression(s) */
957  HeapTuple curTuple; /* copy of most recent tuple from subplan */
958  Datum curArray; /* most recent array from ARRAY() subplan */
959  /* these are used when hashing the subselect's output: */
960  TupleDesc descRight; /* subselect desc after projection */
961  ProjectionInfo *projLeft; /* for projecting lefthand exprs */
962  ProjectionInfo *projRight; /* for projecting subselect output */
963  TupleHashTable hashtable; /* hash table for no-nulls subselect rows */
964  TupleHashTable hashnulls; /* hash table for rows with null(s) */
965  bool havehashrows; /* true if hashtable is not empty */
966  bool havenullrows; /* true if hashnulls is not empty */
967  MemoryContext hashtablecxt; /* memory context containing hash tables */
968  MemoryContext hashtempcxt; /* temp memory context for hash tables */
969  ExprContext *innerecontext; /* econtext for computing inner tuples */
970  int numCols; /* number of columns being hashed */
971  /* each of the remaining fields is an array of length numCols: */
972  AttrNumber *keyColIdx; /* control data for hash tables */
973  Oid *tab_eq_funcoids; /* equality func oids for table
974  * datatype(s) */
975  Oid *tab_collations; /* collations for hash and comparison */
976  FmgrInfo *tab_hash_funcs; /* hash functions for table datatype(s) */
977  FmgrInfo *tab_eq_funcs; /* equality functions for table datatype(s) */
978  FmgrInfo *lhs_hash_funcs; /* hash functions for lefthand datatype(s) */
979  FmgrInfo *cur_eq_funcs; /* equality functions for LHS vs. table */
980  ExprState *cur_eq_comp; /* equality comparator for LHS vs. table */
982 
983 /*
984  * DomainConstraintState - one item to check during CoerceToDomain
985  *
986  * Note: we consider this to be part of an ExprState tree, so we give it
987  * a name following the xxxState convention. But there's no directly
988  * associated plan-tree node.
989  */
991 {
995 
996 typedef struct DomainConstraintState
997 {
999  DomainConstraintType constrainttype; /* constraint type */
1000  char *name; /* name of constraint (for error msgs) */
1001  Expr *check_expr; /* for CHECK, a boolean expression */
1002  ExprState *check_exprstate; /* check_expr's eval state, or NULL */
1004 
1005 
1006 /* ----------------------------------------------------------------
1007  * Executor State Trees
1008  *
1009  * An executing query has a PlanState tree paralleling the Plan tree
1010  * that describes the plan.
1011  * ----------------------------------------------------------------
1012  */
1013 
1014 /* ----------------
1015  * ExecProcNodeMtd
1016  *
1017  * This is the method called by ExecProcNode to return the next tuple
1018  * from an executor node. It returns NULL, or an empty TupleTableSlot,
1019  * if no more tuples are available.
1020  * ----------------
1021  */
1022 typedef TupleTableSlot *(*ExecProcNodeMtd) (struct PlanState *pstate);
1023 
1024 /* ----------------
1025  * PlanState node
1026  *
1027  * We never actually instantiate any PlanState nodes; this is just the common
1028  * abstract superclass for all PlanState-type nodes.
1029  * ----------------
1030  */
1031 typedef struct PlanState
1032 {
1033  pg_node_attr(abstract)
1034 
1035  NodeTag type;
1036 
1037  Plan *plan; /* associated Plan node */
1038 
1039  EState *state; /* at execution time, states of individual
1040  * nodes point to one EState for the whole
1041  * top-level plan */
1042 
1043  ExecProcNodeMtd ExecProcNode; /* function to return next tuple */
1044  ExecProcNodeMtd ExecProcNodeReal; /* actual function, if above is a
1045  * wrapper */
1046 
1047  Instrumentation *instrument; /* Optional runtime stats for this node */
1048  WorkerInstrumentation *worker_instrument; /* per-worker instrumentation */
1049 
1050  /* Per-worker JIT instrumentation */
1052 
1053  /*
1054  * Common structural data for all Plan types. These links to subsidiary
1055  * state trees parallel links in the associated plan tree (except for the
1056  * subPlan list, which does not exist in the plan tree).
1057  */
1058  ExprState *qual; /* boolean qual condition */
1059  struct PlanState *lefttree; /* input plan tree(s) */
1061 
1062  List *initPlan; /* Init SubPlanState nodes (un-correlated expr
1063  * subselects) */
1064  List *subPlan; /* SubPlanState nodes in my expressions */
1065 
1066  /*
1067  * State for management of parameter-change-driven rescanning
1068  */
1069  Bitmapset *chgParam; /* set of IDs of changed Params */
1070 
1071  /*
1072  * Other run-time state needed by most if not all node types.
1073  */
1074  TupleDesc ps_ResultTupleDesc; /* node's return type */
1075  TupleTableSlot *ps_ResultTupleSlot; /* slot for my result tuples */
1076  ExprContext *ps_ExprContext; /* node's expression-evaluation context */
1077  ProjectionInfo *ps_ProjInfo; /* info for doing tuple projection */
1078 
1079  bool async_capable; /* true if node is async-capable */
1080 
1081  /*
1082  * Scanslot's descriptor if known. This is a bit of a hack, but otherwise
1083  * it's hard for expression compilation to optimize based on the
1084  * descriptor, without encoding knowledge about all executor nodes.
1085  */
1087 
1088  /*
1089  * Define the slot types for inner, outer and scanslots for expression
1090  * contexts with this state as a parent. If *opsset is set, then
1091  * *opsfixed indicates whether *ops is guaranteed to be the type of slot
1092  * used. That means that every slot in the corresponding
1093  * ExprContext.ecxt_*tuple will point to a slot of that type, while
1094  * evaluating the expression. If *opsfixed is false, but *ops is set,
1095  * that indicates the most likely type of slot.
1096  *
1097  * The scan* fields are set by ExecInitScanTupleSlot(). If that's not
1098  * called, nodes can initialize the fields themselves.
1099  *
1100  * If outer/inneropsset is false, the information is inferred on-demand
1101  * using ExecGetResultSlotOps() on ->righttree/lefttree, using the
1102  * corresponding node's resultops* fields.
1103  *
1104  * The result* fields are automatically set when ExecInitResultSlot is
1105  * used (be it directly or when the slot is created by
1106  * ExecAssignScanProjectionInfo() /
1107  * ExecConditionalAssignProjectionInfo()). If no projection is necessary
1108  * ExecConditionalAssignProjectionInfo() defaults those fields to the scan
1109  * operations.
1110  */
1124 
1125 /* ----------------
1126  * these are defined to avoid confusion problems with "left"
1127  * and "right" and "inner" and "outer". The convention is that
1128  * the "left" plan is the "outer" plan and the "right" plan is
1129  * the inner plan, but these make the code more readable.
1130  * ----------------
1131  */
1132 #define innerPlanState(node) (((PlanState *)(node))->righttree)
1133 #define outerPlanState(node) (((PlanState *)(node))->lefttree)
1134 
1135 /* Macros for inline access to certain instrumentation counters */
1136 #define InstrCountTuples2(node, delta) \
1137  do { \
1138  if (((PlanState *)(node))->instrument) \
1139  ((PlanState *)(node))->instrument->ntuples2 += (delta); \
1140  } while (0)
1141 #define InstrCountFiltered1(node, delta) \
1142  do { \
1143  if (((PlanState *)(node))->instrument) \
1144  ((PlanState *)(node))->instrument->nfiltered1 += (delta); \
1145  } while(0)
1146 #define InstrCountFiltered2(node, delta) \
1147  do { \
1148  if (((PlanState *)(node))->instrument) \
1149  ((PlanState *)(node))->instrument->nfiltered2 += (delta); \
1150  } while(0)
1151 
1152 /*
1153  * EPQState is state for executing an EvalPlanQual recheck on a candidate
1154  * tuples e.g. in ModifyTable or LockRows.
1155  *
1156  * To execute EPQ a separate EState is created (stored in ->recheckestate),
1157  * which shares some resources, like the rangetable, with the main query's
1158  * EState (stored in ->parentestate). The (sub-)tree of the plan that needs to
1159  * be rechecked (in ->plan), is separately initialized (into
1160  * ->recheckplanstate), but shares plan nodes with the corresponding nodes in
1161  * the main query. The scan nodes in that separate executor tree are changed
1162  * to return only the current tuple of interest for the respective
1163  * table. Those tuples are either provided by the caller (using
1164  * EvalPlanQualSlot), and/or found using the rowmark mechanism (non-locking
1165  * rowmarks by the EPQ machinery itself, locking ones by the caller).
1166  *
1167  * While the plan to be checked may be changed using EvalPlanQualSetPlan(),
1168  * all such plans need to share the same EState.
1169  */
1170 typedef struct EPQState
1171 {
1172  /* These are initialized by EvalPlanQualInit() and do not change later: */
1173  EState *parentestate; /* main query's EState */
1174  int epqParam; /* ID of Param to force scan node re-eval */
1175  List *resultRelations; /* integer list of RT indexes, or NIL */
1176 
1177  /*
1178  * relsubs_slot[scanrelid - 1] holds the EPQ test tuple to be returned by
1179  * the scan node for the scanrelid'th RT index, in place of performing an
1180  * actual table scan. Callers should use EvalPlanQualSlot() to fetch
1181  * these slots.
1182  */
1183  List *tuple_table; /* tuple table for relsubs_slot */
1185 
1186  /*
1187  * Initialized by EvalPlanQualInit(), may be changed later with
1188  * EvalPlanQualSetPlan():
1189  */
1190 
1191  Plan *plan; /* plan tree to be executed */
1192  List *arowMarks; /* ExecAuxRowMarks (non-locking only) */
1193 
1194 
1195  /*
1196  * The original output tuple to be rechecked. Set by
1197  * EvalPlanQualSetSlot(), before EvalPlanQualNext() or EvalPlanQual() may
1198  * be called.
1199  */
1201 
1202 
1203  /* Initialized or reset by EvalPlanQualBegin(): */
1204 
1205  EState *recheckestate; /* EState for EPQ execution, see above */
1206 
1207  /*
1208  * Rowmarks that can be fetched on-demand using
1209  * EvalPlanQualFetchRowMark(), indexed by scanrelid - 1. Only non-locking
1210  * rowmarks.
1211  */
1213 
1214  /*
1215  * relsubs_done[scanrelid - 1] is true if there is no EPQ tuple for this
1216  * target relation or it has already been fetched in the current scan of
1217  * this target relation within the current EvalPlanQual test.
1218  */
1220 
1221  /*
1222  * relsubs_blocked[scanrelid - 1] is true if there is no EPQ tuple for
1223  * this target relation during the current EvalPlanQual test. We keep
1224  * these flags set for all relids listed in resultRelations, but
1225  * transiently clear the one for the relation whose tuple is actually
1226  * passed to EvalPlanQual().
1227  */
1229 
1230  PlanState *recheckplanstate; /* EPQ specific exec nodes, for ->plan */
1232 
1233 
1234 /* ----------------
1235  * ResultState information
1236  * ----------------
1237  */
1238 typedef struct ResultState
1239 {
1240  PlanState ps; /* its first field is NodeTag */
1242  bool rs_done; /* are we done? */
1243  bool rs_checkqual; /* do we need to check the qual? */
1245 
1246 /* ----------------
1247  * ProjectSetState information
1248  *
1249  * Note: at least one of the "elems" will be a SetExprState; the rest are
1250  * regular ExprStates.
1251  * ----------------
1252  */
1253 typedef struct ProjectSetState
1254 {
1255  PlanState ps; /* its first field is NodeTag */
1256  Node **elems; /* array of expression states */
1257  ExprDoneCond *elemdone; /* array of per-SRF is-done states */
1258  int nelems; /* length of elemdone[] array */
1259  bool pending_srf_tuples; /* still evaluating srfs in tlist? */
1260  MemoryContext argcontext; /* context for SRF arguments */
1262 
1263 
1264 /* flags for mt_merge_subcommands */
1265 #define MERGE_INSERT 0x01
1266 #define MERGE_UPDATE 0x02
1267 #define MERGE_DELETE 0x04
1268 
1269 /* ----------------
1270  * ModifyTableState information
1271  * ----------------
1272  */
1273 typedef struct ModifyTableState
1274 {
1275  PlanState ps; /* its first field is NodeTag */
1276  CmdType operation; /* INSERT, UPDATE, DELETE, or MERGE */
1277  bool canSetTag; /* do we set the command tag/es_processed? */
1278  bool mt_done; /* are we done? */
1279  int mt_nrels; /* number of entries in resultRelInfo[] */
1280  ResultRelInfo *resultRelInfo; /* info about target relation(s) */
1281 
1282  /*
1283  * Target relation mentioned in the original statement, used to fire
1284  * statement-level triggers and as the root for tuple routing. (This
1285  * might point to one of the resultRelInfo[] entries, but it can also be a
1286  * distinct struct.)
1287  */
1289 
1290  EPQState mt_epqstate; /* for evaluating EvalPlanQual rechecks */
1291  bool fireBSTriggers; /* do we need to fire stmt triggers? */
1292 
1293  /*
1294  * These fields are used for inherited UPDATE and DELETE, to track which
1295  * target relation a given tuple is from. If there are a lot of target
1296  * relations, we use a hash table to translate table OIDs to
1297  * resultRelInfo[] indexes; otherwise mt_resultOidHash is NULL.
1298  */
1299  int mt_resultOidAttno; /* resno of "tableoid" junk attr */
1300  Oid mt_lastResultOid; /* last-seen value of tableoid */
1301  int mt_lastResultIndex; /* corresponding index in resultRelInfo[] */
1302  HTAB *mt_resultOidHash; /* optional hash table to speed lookups */
1303 
1304  /*
1305  * Slot for storing tuples in the root partitioned table's rowtype during
1306  * an UPDATE of a partitioned table.
1307  */
1309 
1310  /* Tuple-routing support info */
1312 
1313  /* controls transition table population for specified operation */
1315 
1316  /* controls transition table population for INSERT...ON CONFLICT UPDATE */
1318 
1319  /* Flags showing which subcommands are present INS/UPD/DEL/DO NOTHING */
1321 
1322  /* tuple counters for MERGE */
1327 
1328 /* ----------------
1329  * AppendState information
1330  *
1331  * nplans how many plans are in the array
1332  * whichplan which synchronous plan is being executed (0 .. n-1)
1333  * or a special negative value. See nodeAppend.c.
1334  * prune_state details required to allow partitions to be
1335  * eliminated from the scan, or NULL if not possible.
1336  * valid_subplans for runtime pruning, valid synchronous appendplans
1337  * indexes to scan.
1338  * ----------------
1339  */
1340 
1341 struct AppendState;
1342 typedef struct AppendState AppendState;
1343 struct ParallelAppendState;
1345 struct PartitionPruneState;
1346 
1348 {
1349  PlanState ps; /* its first field is NodeTag */
1350  PlanState **appendplans; /* array of PlanStates for my inputs */
1353  bool as_begun; /* false means need to initialize */
1354  Bitmapset *as_asyncplans; /* asynchronous plans indexes */
1355  int as_nasyncplans; /* # of asynchronous plans */
1356  AsyncRequest **as_asyncrequests; /* array of AsyncRequests */
1357  TupleTableSlot **as_asyncresults; /* unreturned results of async plans */
1358  int as_nasyncresults; /* # of valid entries in as_asyncresults */
1359  bool as_syncdone; /* true if all synchronous plans done in
1360  * asynchronous mode, else false */
1361  int as_nasyncremain; /* # of remaining asynchronous plans */
1362  Bitmapset *as_needrequest; /* asynchronous plans needing a new request */
1363  struct WaitEventSet *as_eventset; /* WaitEventSet used to configure file
1364  * descriptor wait events */
1365  int as_first_partial_plan; /* Index of 'appendplans' containing
1366  * the first partial plan */
1367  ParallelAppendState *as_pstate; /* parallel coordination info */
1368  Size pstate_len; /* size of parallel coordination info */
1370  bool as_valid_subplans_identified; /* is as_valid_subplans valid? */
1372  Bitmapset *as_valid_asyncplans; /* valid asynchronous plans indexes */
1373  bool (*choose_next_subplan) (AppendState *);
1374 };
1375 
1376 /* ----------------
1377  * MergeAppendState information
1378  *
1379  * nplans how many plans are in the array
1380  * nkeys number of sort key columns
1381  * sortkeys sort keys in SortSupport representation
1382  * slots current output tuple of each subplan
1383  * heap heap of active tuples
1384  * initialized true if we have fetched first tuple from each subplan
1385  * prune_state details required to allow partitions to be
1386  * eliminated from the scan, or NULL if not possible.
1387  * valid_subplans for runtime pruning, valid mergeplans indexes to
1388  * scan.
1389  * ----------------
1390  */
1391 typedef struct MergeAppendState
1392 {
1393  PlanState ps; /* its first field is NodeTag */
1394  PlanState **mergeplans; /* array of PlanStates for my inputs */
1397  SortSupport ms_sortkeys; /* array of length ms_nkeys */
1398  TupleTableSlot **ms_slots; /* array of length ms_nplans */
1399  struct binaryheap *ms_heap; /* binary heap of slot indices */
1400  bool ms_initialized; /* are subplans started? */
1404 
1405 /* ----------------
1406  * RecursiveUnionState information
1407  *
1408  * RecursiveUnionState is used for performing a recursive union.
1409  *
1410  * recursing T when we're done scanning the non-recursive term
1411  * intermediate_empty T if intermediate_table is currently empty
1412  * working_table working table (to be scanned by recursive term)
1413  * intermediate_table current recursive output (next generation of WT)
1414  * ----------------
1415  */
1416 typedef struct RecursiveUnionState
1417 {
1418  PlanState ps; /* its first field is NodeTag */
1423  /* Remaining fields are unused in UNION ALL case */
1424  Oid *eqfuncoids; /* per-grouping-field equality fns */
1425  FmgrInfo *hashfunctions; /* per-grouping-field hash fns */
1426  MemoryContext tempContext; /* short-term context for comparisons */
1427  TupleHashTable hashtable; /* hash table for tuples already seen */
1428  MemoryContext tableContext; /* memory context containing hash table */
1430 
1431 /* ----------------
1432  * BitmapAndState information
1433  * ----------------
1434  */
1435 typedef struct BitmapAndState
1436 {
1437  PlanState ps; /* its first field is NodeTag */
1438  PlanState **bitmapplans; /* array of PlanStates for my inputs */
1439  int nplans; /* number of input plans */
1441 
1442 /* ----------------
1443  * BitmapOrState information
1444  * ----------------
1445  */
1446 typedef struct BitmapOrState
1447 {
1448  PlanState ps; /* its first field is NodeTag */
1449  PlanState **bitmapplans; /* array of PlanStates for my inputs */
1450  int nplans; /* number of input plans */
1452 
1453 /* ----------------------------------------------------------------
1454  * Scan State Information
1455  * ----------------------------------------------------------------
1456  */
1457 
1458 /* ----------------
1459  * ScanState information
1460  *
1461  * ScanState extends PlanState for node types that represent
1462  * scans of an underlying relation. It can also be used for nodes
1463  * that scan the output of an underlying plan node --- in that case,
1464  * only ScanTupleSlot is actually useful, and it refers to the tuple
1465  * retrieved from the subplan.
1466  *
1467  * currentRelation relation being scanned (NULL if none)
1468  * currentScanDesc current scan descriptor for scan (NULL if none)
1469  * ScanTupleSlot pointer to slot in tuple table holding scan tuple
1470  * ----------------
1471  */
1472 typedef struct ScanState
1473 {
1474  PlanState ps; /* its first field is NodeTag */
1479 
1480 /* ----------------
1481  * SeqScanState information
1482  * ----------------
1483  */
1484 typedef struct SeqScanState
1485 {
1486  ScanState ss; /* its first field is NodeTag */
1487  Size pscan_len; /* size of parallel heap scan descriptor */
1489 
1490 /* ----------------
1491  * SampleScanState information
1492  * ----------------
1493  */
1494 typedef struct SampleScanState
1495 {
1497  List *args; /* expr states for TABLESAMPLE params */
1498  ExprState *repeatable; /* expr state for REPEATABLE expr */
1499  /* use struct pointer to avoid including tsmapi.h here */
1500  struct TsmRoutine *tsmroutine; /* descriptor for tablesample method */
1501  void *tsm_state; /* tablesample method can keep state here */
1502  bool use_bulkread; /* use bulkread buffer access strategy? */
1503  bool use_pagemode; /* use page-at-a-time visibility checking? */
1504  bool begun; /* false means need to call BeginSampleScan */
1505  uint32 seed; /* random seed */
1506  int64 donetuples; /* number of tuples already returned */
1507  bool haveblock; /* has a block for sampling been determined */
1508  bool done; /* exhausted all tuples? */
1510 
1511 /*
1512  * These structs store information about index quals that don't have simple
1513  * constant right-hand sides. See comments for ExecIndexBuildScanKeys()
1514  * for discussion.
1515  */
1516 typedef struct
1517 {
1518  struct ScanKeyData *scan_key; /* scankey to put value into */
1519  ExprState *key_expr; /* expr to evaluate to get value */
1520  bool key_toastable; /* is expr's result a toastable datatype? */
1522 
1523 typedef struct
1524 {
1525  struct ScanKeyData *scan_key; /* scankey to put value into */
1526  ExprState *array_expr; /* expr to evaluate to get array value */
1527  int next_elem; /* next array element to use */
1528  int num_elems; /* number of elems in current array value */
1529  Datum *elem_values; /* array of num_elems Datums */
1530  bool *elem_nulls; /* array of num_elems is-null flags */
1532 
1533 /* ----------------
1534  * IndexScanState information
1535  *
1536  * indexqualorig execution state for indexqualorig expressions
1537  * indexorderbyorig execution state for indexorderbyorig expressions
1538  * ScanKeys Skey structures for index quals
1539  * NumScanKeys number of ScanKeys
1540  * OrderByKeys Skey structures for index ordering operators
1541  * NumOrderByKeys number of OrderByKeys
1542  * RuntimeKeys info about Skeys that must be evaluated at runtime
1543  * NumRuntimeKeys number of RuntimeKeys
1544  * RuntimeKeysReady true if runtime Skeys have been computed
1545  * RuntimeContext expr context for evaling runtime Skeys
1546  * RelationDesc index relation descriptor
1547  * ScanDesc index scan descriptor
1548  *
1549  * ReorderQueue tuples that need reordering due to re-check
1550  * ReachedEnd have we fetched all tuples from index already?
1551  * OrderByValues values of ORDER BY exprs of last fetched tuple
1552  * OrderByNulls null flags for OrderByValues
1553  * SortSupport for reordering ORDER BY exprs
1554  * OrderByTypByVals is the datatype of order by expression pass-by-value?
1555  * OrderByTypLens typlens of the datatypes of order by expressions
1556  * PscanLen size of parallel index scan descriptor
1557  * ----------------
1558  */
1559 typedef struct IndexScanState
1560 {
1561  ScanState ss; /* its first field is NodeTag */
1574 
1575  /* These are needed for re-checking ORDER BY expr ordering */
1585 
1586 /* ----------------
1587  * IndexOnlyScanState information
1588  *
1589  * recheckqual execution state for recheckqual expressions
1590  * ScanKeys Skey structures for index quals
1591  * NumScanKeys number of ScanKeys
1592  * OrderByKeys Skey structures for index ordering operators
1593  * NumOrderByKeys number of OrderByKeys
1594  * RuntimeKeys info about Skeys that must be evaluated at runtime
1595  * NumRuntimeKeys number of RuntimeKeys
1596  * RuntimeKeysReady true if runtime Skeys have been computed
1597  * RuntimeContext expr context for evaling runtime Skeys
1598  * RelationDesc index relation descriptor
1599  * ScanDesc index scan descriptor
1600  * TableSlot slot for holding tuples fetched from the table
1601  * VMBuffer buffer in use for visibility map testing, if any
1602  * PscanLen size of parallel index-only scan descriptor
1603  * ----------------
1604  */
1605 typedef struct IndexOnlyScanState
1606 {
1607  ScanState ss; /* its first field is NodeTag */
1623 
1624 /* ----------------
1625  * BitmapIndexScanState information
1626  *
1627  * result bitmap to return output into, or NULL
1628  * ScanKeys Skey structures for index quals
1629  * NumScanKeys number of ScanKeys
1630  * RuntimeKeys info about Skeys that must be evaluated at runtime
1631  * NumRuntimeKeys number of RuntimeKeys
1632  * ArrayKeys info about Skeys that come from ScalarArrayOpExprs
1633  * NumArrayKeys number of ArrayKeys
1634  * RuntimeKeysReady true if runtime Skeys have been computed
1635  * RuntimeContext expr context for evaling runtime Skeys
1636  * RelationDesc index relation descriptor
1637  * ScanDesc index scan descriptor
1638  * ----------------
1639  */
1640 typedef struct BitmapIndexScanState
1641 {
1642  ScanState ss; /* its first field is NodeTag */
1655 
1656 /* ----------------
1657  * SharedBitmapState information
1658  *
1659  * BM_INITIAL TIDBitmap creation is not yet started, so first worker
1660  * to see this state will set the state to BM_INPROGRESS
1661  * and that process will be responsible for creating
1662  * TIDBitmap.
1663  * BM_INPROGRESS TIDBitmap creation is in progress; workers need to
1664  * sleep until it's finished.
1665  * BM_FINISHED TIDBitmap creation is done, so now all workers can
1666  * proceed to iterate over TIDBitmap.
1667  * ----------------
1668  */
1669 typedef enum
1670 {
1673  BM_FINISHED
1675 
1676 /* ----------------
1677  * ParallelBitmapHeapState information
1678  * tbmiterator iterator for scanning current pages
1679  * prefetch_iterator iterator for prefetching ahead of current page
1680  * mutex mutual exclusion for the prefetching variable
1681  * and state
1682  * prefetch_pages # pages prefetch iterator is ahead of current
1683  * prefetch_target current target prefetch distance
1684  * state current state of the TIDBitmap
1685  * cv conditional wait variable
1686  * phs_snapshot_data snapshot data shared to workers
1687  * ----------------
1688  */
1690 {
1698  char phs_snapshot_data[FLEXIBLE_ARRAY_MEMBER];
1700 
1701 /* ----------------
1702  * BitmapHeapScanState information
1703  *
1704  * bitmapqualorig execution state for bitmapqualorig expressions
1705  * tbm bitmap obtained from child index scan(s)
1706  * tbmiterator iterator for scanning current pages
1707  * tbmres current-page data
1708  * can_skip_fetch can we potentially skip tuple fetches in this scan?
1709  * return_empty_tuples number of empty tuples to return
1710  * vmbuffer buffer for visibility-map lookups
1711  * pvmbuffer ditto, for prefetched pages
1712  * exact_pages total number of exact pages retrieved
1713  * lossy_pages total number of lossy pages retrieved
1714  * prefetch_iterator iterator for prefetching ahead of current page
1715  * prefetch_pages # pages prefetch iterator is ahead of current
1716  * prefetch_target current target prefetch distance
1717  * prefetch_maximum maximum value for prefetch_target
1718  * pscan_len size of the shared memory for parallel bitmap
1719  * initialized is node is ready to iterate
1720  * shared_tbmiterator shared iterator
1721  * shared_prefetch_iterator shared iterator for prefetching
1722  * pstate shared state for parallel bitmap scan
1723  * ----------------
1724  */
1725 typedef struct BitmapHeapScanState
1726 {
1727  ScanState ss; /* its first field is NodeTag */
1748 
1749 /* ----------------
1750  * TidScanState information
1751  *
1752  * tidexprs list of TidExpr structs (see nodeTidscan.c)
1753  * isCurrentOf scan has a CurrentOfExpr qual
1754  * NumTids number of tids in this scan
1755  * TidPtr index of currently fetched tid
1756  * TidList evaluated item pointers (array of size NumTids)
1757  * htup currently-fetched tuple, if any
1758  * ----------------
1759  */
1760 typedef struct TidScanState
1761 {
1762  ScanState ss; /* its first field is NodeTag */
1770 
1771 /* ----------------
1772  * TidRangeScanState information
1773  *
1774  * trss_tidexprs list of TidOpExpr structs (see nodeTidrangescan.c)
1775  * trss_mintid the lowest TID in the scan range
1776  * trss_maxtid the highest TID in the scan range
1777  * trss_inScan is a scan currently in progress?
1778  * ----------------
1779  */
1780 typedef struct TidRangeScanState
1781 {
1782  ScanState ss; /* its first field is NodeTag */
1788 
1789 /* ----------------
1790  * SubqueryScanState information
1791  *
1792  * SubqueryScanState is used for scanning a sub-query in the range table.
1793  * ScanTupleSlot references the current output tuple of the sub-query.
1794  * ----------------
1795  */
1796 typedef struct SubqueryScanState
1797 {
1798  ScanState ss; /* its first field is NodeTag */
1801 
1802 /* ----------------
1803  * FunctionScanState information
1804  *
1805  * Function nodes are used to scan the results of a
1806  * function appearing in FROM (typically a function returning set).
1807  *
1808  * eflags node's capability flags
1809  * ordinality is this scan WITH ORDINALITY?
1810  * simple true if we have 1 function and no ordinality
1811  * ordinal current ordinal column value
1812  * nfuncs number of functions being executed
1813  * funcstates per-function execution states (private in
1814  * nodeFunctionscan.c)
1815  * argcontext memory context to evaluate function arguments in
1816  * ----------------
1817  */
1819 
1820 typedef struct FunctionScanState
1821 {
1822  ScanState ss; /* its first field is NodeTag */
1823  int eflags;
1825  bool simple;
1826  int64 ordinal;
1827  int nfuncs;
1828  struct FunctionScanPerFuncState *funcstates; /* array of length nfuncs */
1831 
1832 /* ----------------
1833  * ValuesScanState information
1834  *
1835  * ValuesScan nodes are used to scan the results of a VALUES list
1836  *
1837  * rowcontext per-expression-list context
1838  * exprlists array of expression lists being evaluated
1839  * exprstatelists array of expression state lists, for SubPlans only
1840  * array_len size of above arrays
1841  * curr_idx current array index (0-based)
1842  *
1843  * Note: ss.ps.ps_ExprContext is used to evaluate any qual or projection
1844  * expressions attached to the node. We create a second ExprContext,
1845  * rowcontext, in which to build the executor expression state for each
1846  * Values sublist. Resetting this context lets us get rid of expression
1847  * state for each row, avoiding major memory leakage over a long values list.
1848  * However, that doesn't work for sublists containing SubPlans, because a
1849  * SubPlan has to be connected up to the outer plan tree to work properly.
1850  * Therefore, for only those sublists containing SubPlans, we do expression
1851  * state construction at executor start, and store those pointers in
1852  * exprstatelists[]. NULL entries in that array correspond to simple
1853  * subexpressions that are handled as described above.
1854  * ----------------
1855  */
1856 typedef struct ValuesScanState
1857 {
1858  ScanState ss; /* its first field is NodeTag */
1865 
1866 /* ----------------
1867  * TableFuncScanState node
1868  *
1869  * Used in table-expression functions like XMLTABLE.
1870  * ----------------
1871  */
1872 typedef struct TableFuncScanState
1873 {
1874  ScanState ss; /* its first field is NodeTag */
1875  ExprState *docexpr; /* state for document expression */
1876  ExprState *rowexpr; /* state for row-generating expression */
1877  List *colexprs; /* state for column-generating expression */
1878  List *coldefexprs; /* state for column default expressions */
1879  List *ns_names; /* same as TableFunc.ns_names */
1880  List *ns_uris; /* list of states of namespace URI exprs */
1881  Bitmapset *notnulls; /* nullability flag for each output column */
1882  void *opaque; /* table builder private space */
1883  const struct TableFuncRoutine *routine; /* table builder methods */
1884  FmgrInfo *in_functions; /* input function for each column */
1885  Oid *typioparams; /* typioparam for each column */
1886  int64 ordinal; /* row number to be output next */
1887  MemoryContext perTableCxt; /* per-table context */
1888  Tuplestorestate *tupstore; /* output tuple store */
1890 
1891 /* ----------------
1892  * CteScanState information
1893  *
1894  * CteScan nodes are used to scan a CommonTableExpr query.
1895  *
1896  * Multiple CteScan nodes can read out from the same CTE query. We use
1897  * a tuplestore to hold rows that have been read from the CTE query but
1898  * not yet consumed by all readers.
1899  * ----------------
1900  */
1901 typedef struct CteScanState
1902 {
1903  ScanState ss; /* its first field is NodeTag */
1904  int eflags; /* capability flags to pass to tuplestore */
1905  int readptr; /* index of my tuplestore read pointer */
1906  PlanState *cteplanstate; /* PlanState for the CTE query itself */
1907  /* Link to the "leader" CteScanState (possibly this same node) */
1909  /* The remaining fields are only valid in the "leader" CteScanState */
1910  Tuplestorestate *cte_table; /* rows already read from the CTE query */
1911  bool eof_cte; /* reached end of CTE query? */
1913 
1914 /* ----------------
1915  * NamedTuplestoreScanState information
1916  *
1917  * NamedTuplestoreScan nodes are used to scan a Tuplestore created and
1918  * named prior to execution of the query. An example is a transition
1919  * table for an AFTER trigger.
1920  *
1921  * Multiple NamedTuplestoreScan nodes can read out from the same Tuplestore.
1922  * ----------------
1923  */
1925 {
1926  ScanState ss; /* its first field is NodeTag */
1927  int readptr; /* index of my tuplestore read pointer */
1928  TupleDesc tupdesc; /* format of the tuples in the tuplestore */
1929  Tuplestorestate *relation; /* the rows */
1931 
1932 /* ----------------
1933  * WorkTableScanState information
1934  *
1935  * WorkTableScan nodes are used to scan the work table created by
1936  * a RecursiveUnion node. We locate the RecursiveUnion node
1937  * during executor startup.
1938  * ----------------
1939  */
1940 typedef struct WorkTableScanState
1941 {
1942  ScanState ss; /* its first field is NodeTag */
1945 
1946 /* ----------------
1947  * ForeignScanState information
1948  *
1949  * ForeignScan nodes are used to scan foreign-data tables.
1950  * ----------------
1951  */
1952 typedef struct ForeignScanState
1953 {
1954  ScanState ss; /* its first field is NodeTag */
1955  ExprState *fdw_recheck_quals; /* original quals not in ss.ps.qual */
1956  Size pscan_len; /* size of parallel coordination information */
1957  ResultRelInfo *resultRelInfo; /* result rel info, if UPDATE or DELETE */
1958  /* use struct pointer to avoid including fdwapi.h here */
1960  void *fdw_state; /* foreign-data wrapper can keep state here */
1962 
1963 /* ----------------
1964  * CustomScanState information
1965  *
1966  * CustomScan nodes are used to execute custom code within executor.
1967  *
1968  * Core code must avoid assuming that the CustomScanState is only as large as
1969  * the structure declared here; providers are allowed to make it the first
1970  * element in a larger structure, and typically would need to do so. The
1971  * struct is actually allocated by the CreateCustomScanState method associated
1972  * with the plan node. Any additional fields can be initialized there, or in
1973  * the BeginCustomScan method.
1974  * ----------------
1975  */
1976 struct CustomExecMethods;
1977 
1978 typedef struct CustomScanState
1979 {
1981  uint32 flags; /* mask of CUSTOMPATH_* flags, see
1982  * nodes/extensible.h */
1983  List *custom_ps; /* list of child PlanState nodes, if any */
1984  Size pscan_len; /* size of parallel coordination information */
1988 
1989 /* ----------------------------------------------------------------
1990  * Join State Information
1991  * ----------------------------------------------------------------
1992  */
1993 
1994 /* ----------------
1995  * JoinState information
1996  *
1997  * Superclass for state nodes of join plans.
1998  * ----------------
1999  */
2000 typedef struct JoinState
2001 {
2004  bool single_match; /* True if we should skip to next outer tuple
2005  * after finding one inner match */
2006  ExprState *joinqual; /* JOIN quals (in addition to ps.qual) */
2008 
2009 /* ----------------
2010  * NestLoopState information
2011  *
2012  * NeedNewOuter true if need new outer tuple on next call
2013  * MatchedOuter true if found a join match for current outer tuple
2014  * NullInnerTupleSlot prepared null tuple for left outer joins
2015  * ----------------
2016  */
2017 typedef struct NestLoopState
2018 {
2019  JoinState js; /* its first field is NodeTag */
2024 
2025 /* ----------------
2026  * MergeJoinState information
2027  *
2028  * NumClauses number of mergejoinable join clauses
2029  * Clauses info for each mergejoinable clause
2030  * JoinState current state of ExecMergeJoin state machine
2031  * SkipMarkRestore true if we may skip Mark and Restore operations
2032  * ExtraMarks true to issue extra Mark operations on inner scan
2033  * ConstFalseJoin true if we have a constant-false joinqual
2034  * FillOuter true if should emit unjoined outer tuples anyway
2035  * FillInner true if should emit unjoined inner tuples anyway
2036  * MatchedOuter true if found a join match for current outer tuple
2037  * MatchedInner true if found a join match for current inner tuple
2038  * OuterTupleSlot slot in tuple table for cur outer tuple
2039  * InnerTupleSlot slot in tuple table for cur inner tuple
2040  * MarkedTupleSlot slot in tuple table for marked tuple
2041  * NullOuterTupleSlot prepared null tuple for right outer joins
2042  * NullInnerTupleSlot prepared null tuple for left outer joins
2043  * OuterEContext workspace for computing outer tuple's join values
2044  * InnerEContext workspace for computing inner tuple's join values
2045  * ----------------
2046  */
2047 /* private in nodeMergejoin.c: */
2049 
2050 typedef struct MergeJoinState
2051 {
2052  JoinState js; /* its first field is NodeTag */
2054  MergeJoinClause mj_Clauses; /* array of length mj_NumClauses */
2071 
2072 /* ----------------
2073  * HashJoinState information
2074  *
2075  * hashclauses original form of the hashjoin condition
2076  * hj_OuterHashKeys the outer hash keys in the hashjoin condition
2077  * hj_HashOperators the join operators in the hashjoin condition
2078  * hj_HashTable hash table for the hashjoin
2079  * (NULL if table not built yet)
2080  * hj_CurHashValue hash value for current outer tuple
2081  * hj_CurBucketNo regular bucket# for current outer tuple
2082  * hj_CurSkewBucketNo skew bucket# for current outer tuple
2083  * hj_CurTuple last inner tuple matched to current outer
2084  * tuple, or NULL if starting search
2085  * (hj_CurXXX variables are undefined if
2086  * OuterTupleSlot is empty!)
2087  * hj_OuterTupleSlot tuple slot for outer tuples
2088  * hj_HashTupleSlot tuple slot for inner (hashed) tuples
2089  * hj_NullOuterTupleSlot prepared null tuple for right/right-anti/full
2090  * outer joins
2091  * hj_NullInnerTupleSlot prepared null tuple for left/full outer joins
2092  * hj_FirstOuterTupleSlot first tuple retrieved from outer plan
2093  * hj_JoinState current state of ExecHashJoin state machine
2094  * hj_MatchedOuter true if found a join match for current outer
2095  * hj_OuterNotEmpty true if outer relation known not empty
2096  * ----------------
2097  */
2098 
2099 /* these structs are defined in executor/hashjoin.h: */
2102 
2103 typedef struct HashJoinState
2104 {
2105  JoinState js; /* its first field is NodeTag */
2107  List *hj_OuterHashKeys; /* list of ExprState nodes */
2108  List *hj_HashOperators; /* list of operator OIDs */
2124 
2125 
2126 /* ----------------------------------------------------------------
2127  * Materialization State Information
2128  * ----------------------------------------------------------------
2129  */
2130 
2131 /* ----------------
2132  * MaterialState information
2133  *
2134  * materialize nodes are used to materialize the results
2135  * of a subplan into a temporary file.
2136  *
2137  * ss.ss_ScanTupleSlot refers to output of underlying plan.
2138  * ----------------
2139  */
2140 typedef struct MaterialState
2141 {
2142  ScanState ss; /* its first field is NodeTag */
2143  int eflags; /* capability flags to pass to tuplestore */
2144  bool eof_underlying; /* reached end of underlying plan? */
2147 
2148 struct MemoizeEntry;
2149 struct MemoizeTuple;
2150 struct MemoizeKey;
2151 
2153 {
2154  uint64 cache_hits; /* number of rescans where we've found the
2155  * scan parameter values to be cached */
2156  uint64 cache_misses; /* number of rescans where we've not found the
2157  * scan parameter values to be cached. */
2158  uint64 cache_evictions; /* number of cache entries removed due to
2159  * the need to free memory */
2160  uint64 cache_overflows; /* number of times we've had to bypass the
2161  * cache when filling it due to not being
2162  * able to free enough space to store the
2163  * current scan's tuples. */
2164  uint64 mem_peak; /* peak memory usage in bytes */
2166 
2167 /* ----------------
2168  * Shared memory container for per-worker memoize information
2169  * ----------------
2170  */
2171 typedef struct SharedMemoizeInfo
2172 {
2176 
2177 /* ----------------
2178  * MemoizeState information
2179  *
2180  * memoize nodes are used to cache recent and commonly seen results from
2181  * a parameterized scan.
2182  * ----------------
2183  */
2184 typedef struct MemoizeState
2185 {
2186  ScanState ss; /* its first field is NodeTag */
2187  int mstatus; /* value of ExecMemoize state machine */
2188  int nkeys; /* number of cache keys */
2189  struct memoize_hash *hashtable; /* hash table for cache entries */
2190  TupleDesc hashkeydesc; /* tuple descriptor for cache keys */
2191  TupleTableSlot *tableslot; /* min tuple slot for existing cache entries */
2192  TupleTableSlot *probeslot; /* virtual slot used for hash lookups */
2193  ExprState *cache_eq_expr; /* Compare exec params to hash key */
2194  ExprState **param_exprs; /* exprs containing the parameters to this
2195  * node */
2196  FmgrInfo *hashfunctions; /* lookup data for hash funcs nkeys in size */
2197  Oid *collations; /* collation for comparisons nkeys in size */
2198  uint64 mem_used; /* bytes of memory used by cache */
2199  uint64 mem_limit; /* memory limit in bytes for the cache */
2200  MemoryContext tableContext; /* memory context to store cache data */
2201  dlist_head lru_list; /* least recently used entry list */
2202  struct MemoizeTuple *last_tuple; /* Used to point to the last tuple
2203  * returned during a cache hit and the
2204  * tuple we last stored when
2205  * populating the cache. */
2206  struct MemoizeEntry *entry; /* the entry that 'last_tuple' belongs to or
2207  * NULL if 'last_tuple' is NULL. */
2208  bool singlerow; /* true if the cache entry is to be marked as
2209  * complete after caching the first tuple. */
2210  bool binary_mode; /* true when cache key should be compared bit
2211  * by bit, false when using hash equality ops */
2212  MemoizeInstrumentation stats; /* execution statistics */
2213  SharedMemoizeInfo *shared_info; /* statistics for parallel workers */
2214  Bitmapset *keyparamids; /* Param->paramids of expressions belonging to
2215  * param_exprs */
2217 
2218 /* ----------------
2219  * When performing sorting by multiple keys, it's possible that the input
2220  * dataset is already sorted on a prefix of those keys. We call these
2221  * "presorted keys".
2222  * PresortedKeyData represents information about one such key.
2223  * ----------------
2224  */
2225 typedef struct PresortedKeyData
2226 {
2227  FmgrInfo flinfo; /* comparison function info */
2228  FunctionCallInfo fcinfo; /* comparison function call info */
2229  OffsetNumber attno; /* attribute number in tuple */
2231 
2232 /* ----------------
2233  * Shared memory container for per-worker sort information
2234  * ----------------
2235  */
2236 typedef struct SharedSortInfo
2237 {
2241 
2242 /* ----------------
2243  * SortState information
2244  * ----------------
2245  */
2246 typedef struct SortState
2247 {
2248  ScanState ss; /* its first field is NodeTag */
2249  bool randomAccess; /* need random access to sort output? */
2250  bool bounded; /* is the result set bounded? */
2251  int64 bound; /* if bounded, how many tuples are needed */
2252  bool sort_Done; /* sort completed yet? */
2253  bool bounded_Done; /* value of bounded we did the sort with */
2254  int64 bound_Done; /* value of bound we did the sort with */
2255  void *tuplesortstate; /* private state of tuplesort.c */
2256  bool am_worker; /* are we a worker? */
2257  bool datumSort; /* Datum sort instead of tuple sort? */
2258  SharedSortInfo *shared_info; /* one entry per worker */
2260 
2261 /* ----------------
2262  * Instrumentation information for IncrementalSort
2263  * ----------------
2264  */
2266 {
2267  int64 groupCount;
2272  bits32 sortMethods; /* bitmask of TuplesortMethod */
2274 
2275 typedef struct IncrementalSortInfo
2276 {
2280 
2281 /* ----------------
2282  * Shared memory container for per-worker incremental sort information
2283  * ----------------
2284  */
2286 {
2290 
2291 /* ----------------
2292  * IncrementalSortState information
2293  * ----------------
2294  */
2295 typedef enum
2296 {
2302 
2303 typedef struct IncrementalSortState
2304 {
2305  ScanState ss; /* its first field is NodeTag */
2306  bool bounded; /* is the result set bounded? */
2307  int64 bound; /* if bounded, how many tuples are needed */
2308  bool outerNodeDone; /* finished fetching tuples from outer node */
2309  int64 bound_Done; /* value of bound we did the sort with */
2312  Tuplesortstate *fullsort_state; /* private state of tuplesort.c */
2313  Tuplesortstate *prefixsort_state; /* private state of tuplesort.c */
2314  /* the keys by which the input path is already sorted */
2316 
2318 
2319  /* slot for pivot tuple defining values of presorted keys within group */
2322  bool am_worker; /* are we a worker? */
2323  SharedIncrementalSortInfo *shared_info; /* one entry per worker */
2325 
2326 /* ---------------------
2327  * GroupState information
2328  * ---------------------
2329  */
2330 typedef struct GroupState
2331 {
2332  ScanState ss; /* its first field is NodeTag */
2333  ExprState *eqfunction; /* equality function */
2334  bool grp_done; /* indicates completion of Group scan */
2336 
2337 /* ---------------------
2338  * per-worker aggregate information
2339  * ---------------------
2340  */
2342 {
2343  Size hash_mem_peak; /* peak hash table memory usage */
2344  uint64 hash_disk_used; /* kB of disk space used */
2345  int hash_batches_used; /* batches used during entire execution */
2347 
2348 /* ----------------
2349  * Shared memory container for per-worker aggregate information
2350  * ----------------
2351  */
2352 typedef struct SharedAggInfo
2353 {
2357 
2358 /* ---------------------
2359  * AggState information
2360  *
2361  * ss.ss_ScanTupleSlot refers to output of underlying plan.
2362  *
2363  * Note: ss.ps.ps_ExprContext contains ecxt_aggvalues and
2364  * ecxt_aggnulls arrays, which hold the computed agg values for the current
2365  * input group during evaluation of an Agg node's output tuple(s). We
2366  * create a second ExprContext, tmpcontext, in which to evaluate input
2367  * expressions and run the aggregate transition functions.
2368  * ---------------------
2369  */
2370 /* these structs are private in nodeAgg.c: */
2376 
2377 typedef struct AggState
2378 {
2379  ScanState ss; /* its first field is NodeTag */
2380  List *aggs; /* all Aggref nodes in targetlist & quals */
2381  int numaggs; /* length of list (could be zero!) */
2382  int numtrans; /* number of pertrans items */
2383  AggStrategy aggstrategy; /* strategy mode */
2384  AggSplit aggsplit; /* agg-splitting mode, see nodes.h */
2385  AggStatePerPhase phase; /* pointer to current phase data */
2386  int numphases; /* number of phases (including phase 0) */
2387  int current_phase; /* current phase number */
2388  AggStatePerAgg peragg; /* per-Aggref information */
2389  AggStatePerTrans pertrans; /* per-Trans state information */
2390  ExprContext *hashcontext; /* econtexts for long-lived data (hashtable) */
2391  ExprContext **aggcontexts; /* econtexts for long-lived data (per GS) */
2392  ExprContext *tmpcontext; /* econtext for input expressions */
2393 #define FIELDNO_AGGSTATE_CURAGGCONTEXT 14
2394  ExprContext *curaggcontext; /* currently active aggcontext */
2395  AggStatePerAgg curperagg; /* currently active aggregate, if any */
2396 #define FIELDNO_AGGSTATE_CURPERTRANS 16
2397  AggStatePerTrans curpertrans; /* currently active trans state, if any */
2398  bool input_done; /* indicates end of input */
2399  bool agg_done; /* indicates completion of Agg scan */
2400  int projected_set; /* The last projected grouping set */
2401 #define FIELDNO_AGGSTATE_CURRENT_SET 20
2402  int current_set; /* The current grouping set being evaluated */
2403  Bitmapset *grouped_cols; /* grouped cols in current projection */
2404  List *all_grouped_cols; /* list of all grouped cols in DESC order */
2405  Bitmapset *colnos_needed; /* all columns needed from the outer plan */
2406  int max_colno_needed; /* highest colno needed from outer plan */
2407  bool all_cols_needed; /* are all cols from outer plan needed? */
2408  /* These fields are for grouping set phase data */
2409  int maxsets; /* The max number of sets in any phase */
2410  AggStatePerPhase phases; /* array of all phases */
2411  Tuplesortstate *sort_in; /* sorted input to phases > 1 */
2412  Tuplesortstate *sort_out; /* input is copied here for next phase */
2413  TupleTableSlot *sort_slot; /* slot for sort results */
2414  /* these fields are used in AGG_PLAIN and AGG_SORTED modes: */
2415  AggStatePerGroup *pergroups; /* grouping set indexed array of per-group
2416  * pointers */
2417  HeapTuple grp_firstTuple; /* copy of first tuple of current group */
2418  /* these fields are used in AGG_HASHED and AGG_MIXED modes: */
2419  bool table_filled; /* hash table filled yet? */
2421  MemoryContext hash_metacxt; /* memory for hash table itself */
2422  struct LogicalTapeSet *hash_tapeset; /* tape set for hash spill tapes */
2423  struct HashAggSpill *hash_spills; /* HashAggSpill for each grouping set,
2424  * exists only during first pass */
2425  TupleTableSlot *hash_spill_rslot; /* for reading spill files */
2426  TupleTableSlot *hash_spill_wslot; /* for writing spill files */
2427  List *hash_batches; /* hash batches remaining to be processed */
2428  bool hash_ever_spilled; /* ever spilled during this execution? */
2429  bool hash_spill_mode; /* we hit a limit during the current batch
2430  * and we must not create new groups */
2431  Size hash_mem_limit; /* limit before spilling hash table */
2432  uint64 hash_ngroups_limit; /* limit before spilling hash table */
2433  int hash_planned_partitions; /* number of partitions planned
2434  * for first pass */
2435  double hashentrysize; /* estimate revised during execution */
2436  Size hash_mem_peak; /* peak hash table memory usage */
2437  uint64 hash_ngroups_current; /* number of groups currently in
2438  * memory in all hash tables */
2439  uint64 hash_disk_used; /* kB of disk space used */
2440  int hash_batches_used; /* batches used during entire execution */
2441 
2442  AggStatePerHash perhash; /* array of per-hashtable data */
2443  AggStatePerGroup *hash_pergroup; /* grouping set indexed array of
2444  * per-group pointers */
2445 
2446  /* support for evaluation of agg input expressions: */
2447 #define FIELDNO_AGGSTATE_ALL_PERGROUPS 53
2448  AggStatePerGroup *all_pergroups; /* array of first ->pergroups, than
2449  * ->hash_pergroup */
2450  ProjectionInfo *combinedproj; /* projection machinery */
2451  SharedAggInfo *shared_info; /* one entry per worker */
2453 
2454 /* ----------------
2455  * WindowAggState information
2456  * ----------------
2457  */
2458 /* these structs are private in nodeWindowAgg.c: */
2461 
2462 /*
2463  * WindowAggStatus -- Used to track the status of WindowAggState
2464  */
2465 typedef enum WindowAggStatus
2466 {
2467  WINDOWAGG_DONE, /* No more processing to do */
2468  WINDOWAGG_RUN, /* Normal processing of window funcs */
2469  WINDOWAGG_PASSTHROUGH, /* Don't eval window funcs */
2470  WINDOWAGG_PASSTHROUGH_STRICT /* Pass-through plus don't store new
2471  * tuples during spool */
2473 
2474 typedef struct WindowAggState
2475 {
2476  ScanState ss; /* its first field is NodeTag */
2477 
2478  /* these fields are filled in by ExecInitExpr: */
2479  List *funcs; /* all WindowFunc nodes in targetlist */
2480  int numfuncs; /* total number of window functions */
2481  int numaggs; /* number that are plain aggregates */
2482 
2483  WindowStatePerFunc perfunc; /* per-window-function information */
2484  WindowStatePerAgg peragg; /* per-plain-aggregate information */
2485  ExprState *partEqfunction; /* equality funcs for partition columns */
2486  ExprState *ordEqfunction; /* equality funcs for ordering columns */
2487  Tuplestorestate *buffer; /* stores rows of current partition */
2488  int current_ptr; /* read pointer # for current row */
2489  int framehead_ptr; /* read pointer # for frame head, if used */
2490  int frametail_ptr; /* read pointer # for frame tail, if used */
2491  int grouptail_ptr; /* read pointer # for group tail, if used */
2492  int64 spooled_rows; /* total # of rows in buffer */
2493  int64 currentpos; /* position of current row in partition */
2494  int64 frameheadpos; /* current frame head position */
2495  int64 frametailpos; /* current frame tail position (frame end+1) */
2496  /* use struct pointer to avoid including windowapi.h here */
2497  struct WindowObjectData *agg_winobj; /* winobj for aggregate fetches */
2498  int64 aggregatedbase; /* start row for current aggregates */
2499  int64 aggregatedupto; /* rows before this one are aggregated */
2500  WindowAggStatus status; /* run status of WindowAggState */
2501 
2502  int frameOptions; /* frame_clause options, see WindowDef */
2503  ExprState *startOffset; /* expression for starting bound offset */
2504  ExprState *endOffset; /* expression for ending bound offset */
2505  Datum startOffsetValue; /* result of startOffset evaluation */
2506  Datum endOffsetValue; /* result of endOffset evaluation */
2507 
2508  /* these fields are used with RANGE offset PRECEDING/FOLLOWING: */
2509  FmgrInfo startInRangeFunc; /* in_range function for startOffset */
2510  FmgrInfo endInRangeFunc; /* in_range function for endOffset */
2511  Oid inRangeColl; /* collation for in_range tests */
2512  bool inRangeAsc; /* use ASC sort order for in_range tests? */
2513  bool inRangeNullsFirst; /* nulls sort first for in_range tests? */
2514 
2515  /* these fields are used in GROUPS mode: */
2516  int64 currentgroup; /* peer group # of current row in partition */
2517  int64 frameheadgroup; /* peer group # of frame head row */
2518  int64 frametailgroup; /* peer group # of frame tail row */
2519  int64 groupheadpos; /* current row's peer group head position */
2520  int64 grouptailpos; /* " " " " tail position (group end+1) */
2521 
2522  MemoryContext partcontext; /* context for partition-lifespan data */
2523  MemoryContext aggcontext; /* shared context for aggregate working data */
2524  MemoryContext curaggcontext; /* current aggregate's working data */
2525  ExprContext *tmpcontext; /* short-term evaluation context */
2526 
2527  ExprState *runcondition; /* Condition which must remain true otherwise
2528  * execution of the WindowAgg will finish or
2529  * go into pass-through mode. NULL when there
2530  * is no such condition. */
2531 
2532  bool use_pass_through; /* When false, stop execution when
2533  * runcondition is no longer true. Else
2534  * just stop evaluating window funcs. */
2535  bool top_window; /* true if this is the top-most WindowAgg or
2536  * the only WindowAgg in this query level */
2537  bool all_first; /* true if the scan is starting */
2538  bool partition_spooled; /* true if all tuples in current partition
2539  * have been spooled into tuplestore */
2540  bool more_partitions; /* true if there's more partitions after
2541  * this one */
2542  bool framehead_valid; /* true if frameheadpos is known up to
2543  * date for current row */
2544  bool frametail_valid; /* true if frametailpos is known up to
2545  * date for current row */
2546  bool grouptail_valid; /* true if grouptailpos is known up to
2547  * date for current row */
2548 
2549  TupleTableSlot *first_part_slot; /* first tuple of current or next
2550  * partition */
2551  TupleTableSlot *framehead_slot; /* first tuple of current frame */
2552  TupleTableSlot *frametail_slot; /* first tuple after current frame */
2553 
2554  /* temporary slots for tuples fetched back from tuplestore */
2559 
2560 /* ----------------
2561  * UniqueState information
2562  *
2563  * Unique nodes are used "on top of" sort nodes to discard
2564  * duplicate tuples returned from the sort phase. Basically
2565  * all it does is compare the current tuple from the subplan
2566  * with the previously fetched tuple (stored in its result slot).
2567  * If the two are identical in all interesting fields, then
2568  * we just fetch another tuple from the sort and try again.
2569  * ----------------
2570  */
2571 typedef struct UniqueState
2572 {
2573  PlanState ps; /* its first field is NodeTag */
2574  ExprState *eqfunction; /* tuple equality qual */
2576 
2577 /* ----------------
2578  * GatherState information
2579  *
2580  * Gather nodes launch 1 or more parallel workers, run a subplan
2581  * in those workers, and collect the results.
2582  * ----------------
2583  */
2584 typedef struct GatherState
2585 {
2586  PlanState ps; /* its first field is NodeTag */
2587  bool initialized; /* workers launched? */
2588  bool need_to_scan_locally; /* need to read from local plan? */
2589  int64 tuples_needed; /* tuple bound, see ExecSetTupleBound */
2590  /* these fields are set up once: */
2593  /* all remaining fields are reinitialized during a rescan: */
2594  int nworkers_launched; /* original number of workers */
2595  int nreaders; /* number of still-active workers */
2596  int nextreader; /* next one to try to read from */
2597  struct TupleQueueReader **reader; /* array with nreaders active entries */
2599 
2600 /* ----------------
2601  * GatherMergeState information
2602  *
2603  * Gather merge nodes launch 1 or more parallel workers, run a
2604  * subplan which produces sorted output in each worker, and then
2605  * merge the results into a single sorted stream.
2606  * ----------------
2607  */
2608 struct GMReaderTupleBuffer; /* private in nodeGatherMerge.c */
2609 
2610 typedef struct GatherMergeState
2611 {
2612  PlanState ps; /* its first field is NodeTag */
2613  bool initialized; /* workers launched? */
2614  bool gm_initialized; /* gather_merge_init() done? */
2615  bool need_to_scan_locally; /* need to read from local plan? */
2616  int64 tuples_needed; /* tuple bound, see ExecSetTupleBound */
2617  /* these fields are set up once: */
2618  TupleDesc tupDesc; /* descriptor for subplan result tuples */
2619  int gm_nkeys; /* number of sort columns */
2620  SortSupport gm_sortkeys; /* array of length gm_nkeys */
2622  /* all remaining fields are reinitialized during a rescan */
2623  /* (but the arrays are not reallocated, just cleared) */
2624  int nworkers_launched; /* original number of workers */
2625  int nreaders; /* number of active workers */
2626  TupleTableSlot **gm_slots; /* array with nreaders+1 entries */
2627  struct TupleQueueReader **reader; /* array with nreaders active entries */
2628  struct GMReaderTupleBuffer *gm_tuple_buffers; /* nreaders tuple buffers */
2629  struct binaryheap *gm_heap; /* binary heap of slot indices */
2631 
2632 /* ----------------
2633  * Values displayed by EXPLAIN ANALYZE
2634  * ----------------
2635  */
2636 typedef struct HashInstrumentation
2637 {
2638  int nbuckets; /* number of buckets at end of execution */
2639  int nbuckets_original; /* planned number of buckets */
2640  int nbatch; /* number of batches at end of execution */
2641  int nbatch_original; /* planned number of batches */
2642  Size space_peak; /* peak memory usage in bytes */
2644 
2645 /* ----------------
2646  * Shared memory container for per-worker hash information
2647  * ----------------
2648  */
2649 typedef struct SharedHashInfo
2650 {
2654 
2655 /* ----------------
2656  * HashState information
2657  * ----------------
2658  */
2659 typedef struct HashState
2660 {
2661  PlanState ps; /* its first field is NodeTag */
2662  HashJoinTable hashtable; /* hash table for the hashjoin */
2663  List *hashkeys; /* list of ExprState nodes */
2664 
2665  /*
2666  * In a parallelized hash join, the leader retains a pointer to the
2667  * shared-memory stats area in its shared_info field, and then copies the
2668  * shared-memory info back to local storage before DSM shutdown. The
2669  * shared_info field remains NULL in workers, or in non-parallel joins.
2670  */
2672 
2673  /*
2674  * If we are collecting hash stats, this points to an initially-zeroed
2675  * collection area, which could be either local storage or in shared
2676  * memory; either way it's for just one process.
2677  */
2679 
2680  /* Parallel hash state. */
2683 
2684 /* ----------------
2685  * SetOpState information
2686  *
2687  * Even in "sorted" mode, SetOp nodes are more complex than a simple
2688  * Unique, since we have to count how many duplicates to return. But
2689  * we also support hashing, so this is really more like a cut-down
2690  * form of Agg.
2691  * ----------------
2692  */
2693 /* this struct is private in nodeSetOp.c: */
2695 
2696 typedef struct SetOpState
2697 {
2698  PlanState ps; /* its first field is NodeTag */
2699  ExprState *eqfunction; /* equality comparator */
2700  Oid *eqfuncoids; /* per-grouping-field equality fns */
2701  FmgrInfo *hashfunctions; /* per-grouping-field hash fns */
2702  bool setop_done; /* indicates completion of output scan */
2703  long numOutput; /* number of dups left to output */
2704  /* these fields are used in SETOP_SORTED mode: */
2705  SetOpStatePerGroup pergroup; /* per-group working state */
2706  HeapTuple grp_firstTuple; /* copy of first tuple of current group */
2707  /* these fields are used in SETOP_HASHED mode: */
2708  TupleHashTable hashtable; /* hash table with one entry per group */
2709  MemoryContext tableContext; /* memory context containing hash table */
2710  bool table_filled; /* hash table filled yet? */
2711  TupleHashIterator hashiter; /* for iterating through hash table */
2713 
2714 /* ----------------
2715  * LockRowsState information
2716  *
2717  * LockRows nodes are used to enforce FOR [KEY] UPDATE/SHARE locking.
2718  * ----------------
2719  */
2720 typedef struct LockRowsState
2721 {
2722  PlanState ps; /* its first field is NodeTag */
2723  List *lr_arowMarks; /* List of ExecAuxRowMarks */
2724  EPQState lr_epqstate; /* for evaluating EvalPlanQual rechecks */
2726 
2727 /* ----------------
2728  * LimitState information
2729  *
2730  * Limit nodes are used to enforce LIMIT/OFFSET clauses.
2731  * They just select the desired subrange of their subplan's output.
2732  *
2733  * offset is the number of initial tuples to skip (0 does nothing).
2734  * count is the number of tuples to return after skipping the offset tuples.
2735  * If no limit count was specified, count is undefined and noCount is true.
2736  * When lstate == LIMIT_INITIAL, offset/count/noCount haven't been set yet.
2737  * ----------------
2738  */
2739 typedef enum
2740 {
2741  LIMIT_INITIAL, /* initial state for LIMIT node */
2742  LIMIT_RESCAN, /* rescan after recomputing parameters */
2743  LIMIT_EMPTY, /* there are no returnable rows */
2744  LIMIT_INWINDOW, /* have returned a row in the window */
2745  LIMIT_WINDOWEND_TIES, /* have returned a tied row */
2746  LIMIT_SUBPLANEOF, /* at EOF of subplan (within window) */
2747  LIMIT_WINDOWEND, /* stepped off end of window */
2748  LIMIT_WINDOWSTART /* stepped off beginning of window */
2750 
2751 typedef struct LimitState
2752 {
2753  PlanState ps; /* its first field is NodeTag */
2754  ExprState *limitOffset; /* OFFSET parameter, or NULL if none */
2755  ExprState *limitCount; /* COUNT parameter, or NULL if none */
2756  LimitOption limitOption; /* limit specification type */
2757  int64 offset; /* current OFFSET value */
2758  int64 count; /* current COUNT, if any */
2759  bool noCount; /* if true, ignore count */
2760  LimitStateCond lstate; /* state machine status, as above */
2761  int64 position; /* 1-based index of last tuple returned */
2762  TupleTableSlot *subSlot; /* tuple last obtained from subplan */
2763  ExprState *eqfunction; /* tuple equality qual in case of WITH TIES
2764  * option */
2765  TupleTableSlot *last_slot; /* slot for evaluation of ties */
2767 
2768 #endif /* EXECNODES_H */
int16 AttrNumber
Definition: attnum.h:21
int Buffer
Definition: buf.h:23
unsigned short uint16
Definition: c.h:494
unsigned int uint32
Definition: c.h:495
signed short int16
Definition: c.h:482
#define FLEXIBLE_ARRAY_MEMBER
Definition: c.h:387
unsigned char bool
Definition: c.h:445
uint32 bits32
Definition: c.h:504
unsigned int Index
Definition: c.h:603
unsigned char uint8
Definition: c.h:493
uint32 CommandId
Definition: c.h:655
size_t Size
Definition: c.h:594
uint64 dsa_pointer
Definition: dsa.h:62
void(* ExprContextCallbackFunction)(Datum arg)
Definition: execnodes.h:211
struct WindowStatePerAggData * WindowStatePerAgg
Definition: execnodes.h:2460
struct IndexScanState IndexScanState
struct ExprContext ExprContext
struct ModifyTableState ModifyTableState
struct ResultState ResultState
struct SubPlanState SubPlanState
struct SharedIncrementalSortInfo SharedIncrementalSortInfo
struct CteScanState CteScanState
TupleTableSlot *(* ExecProcNodeMtd)(struct PlanState *pstate)
Definition: execnodes.h:1022
struct UniqueState UniqueState
struct SetOpState SetOpState
struct SharedMemoizeInfo SharedMemoizeInfo
struct HashState HashState
struct MemoizeState MemoizeState
struct IndexOnlyScanState IndexOnlyScanState
IncrementalSortExecutionStatus
Definition: execnodes.h:2296
@ INCSORT_READFULLSORT
Definition: execnodes.h:2299
@ INCSORT_LOADPREFIXSORT
Definition: execnodes.h:2298
@ INCSORT_READPREFIXSORT
Definition: execnodes.h:2300
@ INCSORT_LOADFULLSORT
Definition: execnodes.h:2297
struct EPQState EPQState
struct GatherMergeState GatherMergeState
struct LimitState LimitState
struct ExprState ExprState
WindowAggStatus
Definition: execnodes.h:2466
@ WINDOWAGG_PASSTHROUGH
Definition: execnodes.h:2469
@ WINDOWAGG_RUN
Definition: execnodes.h:2468
@ WINDOWAGG_DONE
Definition: execnodes.h:2467
@ WINDOWAGG_PASSTHROUGH_STRICT
Definition: execnodes.h:2470
struct JunkFilter JunkFilter
struct ResultRelInfo ResultRelInfo
struct CustomScanState CustomScanState
struct OnConflictSetState OnConflictSetState
struct BitmapOrState BitmapOrState
struct IncrementalSortInfo IncrementalSortInfo
struct WindowFuncExprState WindowFuncExprState
struct HashJoinState HashJoinState
struct HashJoinTableData * HashJoinTable
Definition: execnodes.h:2101
struct SeqScanState SeqScanState
struct HashJoinTupleData * HashJoinTuple
Definition: execnodes.h:2100
struct TupleHashEntryData * TupleHashEntry
Definition: execnodes.h:788
struct SortState SortState
struct BitmapAndState BitmapAndState
struct AggState AggState
SharedBitmapState
Definition: execnodes.h:1670
@ BM_INITIAL
Definition: execnodes.h:1671
@ BM_FINISHED
Definition: execnodes.h:1673
@ BM_INPROGRESS
Definition: execnodes.h:1672
struct NestLoopState NestLoopState
struct MemoizeInstrumentation MemoizeInstrumentation
struct SetExprState SetExprState
struct GroupState GroupState
struct MaterialState MaterialState
struct WindowStatePerFuncData * WindowStatePerFunc
Definition: execnodes.h:2459
struct ExprContext_CB ExprContext_CB
struct TidRangeScanState TidRangeScanState
struct AggStatePerHashData * AggStatePerHash
Definition: execnodes.h:2375
struct TupleHashTableData * TupleHashTable
Definition: execnodes.h:789
struct SampleScanState SampleScanState
LimitStateCond
Definition: execnodes.h:2740
@ LIMIT_WINDOWEND_TIES
Definition: execnodes.h:2745
@ LIMIT_WINDOWEND
Definition: execnodes.h:2747
@ LIMIT_INWINDOW
Definition: execnodes.h:2744
@ LIMIT_SUBPLANEOF
Definition: execnodes.h:2746
@ LIMIT_WINDOWSTART
Definition: execnodes.h:2748
@ LIMIT_EMPTY
Definition: execnodes.h:2743
@ LIMIT_INITIAL
Definition: execnodes.h:2741
@ LIMIT_RESCAN
Definition: execnodes.h:2742
struct GatherState GatherState
struct MergeJoinClauseData * MergeJoinClause
Definition: execnodes.h:2048
struct ParallelBitmapHeapState ParallelBitmapHeapState
struct MergeJoinState MergeJoinState
struct SetOpStatePerGroupData * SetOpStatePerGroup
Definition: execnodes.h:2694
ExprDoneCond
Definition: execnodes.h:296
@ ExprSingleResult
Definition: execnodes.h:297
@ ExprMultipleResult
Definition: execnodes.h:298
@ ExprEndResult
Definition: execnodes.h:299
struct AggStatePerGroupData * AggStatePerGroup
Definition: execnodes.h:2373
struct ForeignScanState ForeignScanState
struct FunctionScanState FunctionScanState
struct AggStatePerPhaseData * AggStatePerPhase
Definition: execnodes.h:2374
struct WindowAggState WindowAggState
struct AggStatePerTransData * AggStatePerTrans
Definition: execnodes.h:2372
struct NamedTuplestoreScanState NamedTuplestoreScanState
struct SubqueryScanState SubqueryScanState
DomainConstraintType
Definition: execnodes.h:991
@ DOM_CONSTRAINT_CHECK
Definition: execnodes.h:993
@ DOM_CONSTRAINT_NOTNULL
Definition: execnodes.h:992
struct TableFuncScanState TableFuncScanState
struct RecursiveUnionState RecursiveUnionState
struct TupleHashEntryData TupleHashEntryData
struct SharedSortInfo SharedSortInfo
struct ScanState ScanState
tuplehash_iterator TupleHashIterator
Definition: execnodes.h:827
struct MergeActionState MergeActionState
struct AggregateInstrumentation AggregateInstrumentation
struct TidScanState TidScanState
struct SharedHashInfo SharedHashInfo
struct ProjectSetState ProjectSetState
struct IncrementalSortState IncrementalSortState
struct ReturnSetInfo ReturnSetInfo
struct AggStatePerAggData * AggStatePerAgg
Definition: execnodes.h:2371
SetFunctionReturnMode
Definition: execnodes.h:309
@ SFRM_Materialize_Preferred
Definition: execnodes.h:313
@ SFRM_ValuePerCall
Definition: execnodes.h:310
@ SFRM_Materialize_Random
Definition: execnodes.h:312
@ SFRM_Materialize
Definition: execnodes.h:311
struct IndexInfo IndexInfo
struct ProjectionInfo ProjectionInfo
struct EState EState
struct DomainConstraintState DomainConstraintState
struct PresortedKeyData PresortedKeyData
struct HashInstrumentation HashInstrumentation
struct AsyncRequest AsyncRequest
struct IncrementalSortGroupInfo IncrementalSortGroupInfo
struct TupleHashTableData TupleHashTableData
struct JoinState JoinState
struct WorkTableScanState WorkTableScanState
struct BitmapHeapScanState BitmapHeapScanState
struct BitmapIndexScanState BitmapIndexScanState
struct SharedAggInfo SharedAggInfo
struct LockRowsState LockRowsState
struct ExecRowMark ExecRowMark
struct MergeAppendState MergeAppendState
Datum(* ExprStateEvalFunc)(struct ExprState *expression, struct ExprContext *econtext, bool *isNull)
Definition: execnodes.h:69
struct ExecAuxRowMark ExecAuxRowMark
struct ValuesScanState ValuesScanState
LockWaitPolicy
Definition: lockoptions.h:37
LockClauseStrength
Definition: lockoptions.h:22
CmdType
Definition: nodes.h:274
AggStrategy
Definition: nodes.h:363
NodeTag
Definition: nodes.h:27
AggSplit
Definition: nodes.h:385
LimitOption
Definition: nodes.h:440
JoinType
Definition: nodes.h:299
uint16 OffsetNumber
Definition: off.h:24
void * arg
#define INDEX_MAX_KEYS
RowMarkType
Definition: plannodes.h:1326
uintptr_t Datum
Definition: postgres.h:64
unsigned int Oid
Definition: postgres_ext.h:31
int slock_t
Definition: s_lock.h:754
ScanDirection
Definition: sdir.h:25
MemoryContext hash_metacxt
Definition: execnodes.h:2421
ScanState ss
Definition: execnodes.h:2379
Tuplesortstate * sort_out
Definition: execnodes.h:2412
uint64 hash_disk_used
Definition: execnodes.h:2439
AggStatePerGroup * all_pergroups
Definition: execnodes.h:2448
AggStatePerGroup * hash_pergroup
Definition: execnodes.h:2443
AggStatePerPhase phase
Definition: execnodes.h:2385
List * aggs
Definition: execnodes.h:2380
ExprContext * tmpcontext
Definition: execnodes.h:2392
int max_colno_needed
Definition: execnodes.h:2406
int hash_planned_partitions
Definition: execnodes.h:2433
HeapTuple grp_firstTuple
Definition: execnodes.h:2417
Size hash_mem_limit
Definition: execnodes.h:2431
ExprContext * curaggcontext
Definition: execnodes.h:2394
AggStatePerTrans curpertrans
Definition: execnodes.h:2397
bool table_filled
Definition: execnodes.h:2419
AggStatePerTrans pertrans
Definition: execnodes.h:2389
int current_set
Definition: execnodes.h:2402
struct LogicalTapeSet * hash_tapeset
Definition: execnodes.h:2422
AggStrategy aggstrategy
Definition: execnodes.h:2383
int numtrans
Definition: execnodes.h:2382
ExprContext * hashcontext
Definition: execnodes.h:2390
AggSplit aggsplit
Definition: execnodes.h:2384
int projected_set
Definition: execnodes.h:2400
SharedAggInfo * shared_info
Definition: execnodes.h:2451
uint64 hash_ngroups_limit
Definition: execnodes.h:2432
bool input_done
Definition: execnodes.h:2398
AggStatePerPhase phases
Definition: execnodes.h:2410
List * all_grouped_cols
Definition: execnodes.h:2404
bool hash_spill_mode
Definition: execnodes.h:2429
AggStatePerGroup * pergroups
Definition: execnodes.h:2415
AggStatePerHash perhash
Definition: execnodes.h:2442
Size hash_mem_peak
Definition: execnodes.h:2436
double hashentrysize
Definition: execnodes.h:2435
int numphases
Definition: execnodes.h:2386
uint64 hash_ngroups_current
Definition: execnodes.h:2437
int hash_batches_used
Definition: execnodes.h:2440
Tuplesortstate * sort_in
Definition: execnodes.h:2411
TupleTableSlot * hash_spill_wslot
Definition: execnodes.h:2426
AggStatePerAgg curperagg
Definition: execnodes.h:2395
struct HashAggSpill * hash_spills
Definition: execnodes.h:2423
TupleTableSlot * sort_slot
Definition: execnodes.h:2413
bool hash_ever_spilled
Definition: execnodes.h:2428
int numaggs
Definition: execnodes.h:2381
ProjectionInfo * combinedproj
Definition: execnodes.h:2450
int num_hashes
Definition: execnodes.h:2420
AggStatePerAgg peragg
Definition: execnodes.h:2388
List * hash_batches
Definition: execnodes.h:2427
TupleTableSlot * hash_spill_rslot
Definition: execnodes.h:2425
int maxsets
Definition: execnodes.h:2409
ExprContext ** aggcontexts
Definition: execnodes.h:2391
Bitmapset * colnos_needed
Definition: execnodes.h:2405
int current_phase
Definition: execnodes.h:2387
bool all_cols_needed
Definition: execnodes.h:2407
bool agg_done
Definition: execnodes.h:2399
Bitmapset * grouped_cols
Definition: execnodes.h:2403
struct PartitionPruneState * as_prune_state
Definition: execnodes.h:1369
Bitmapset * as_valid_asyncplans
Definition: execnodes.h:1372
Bitmapset * as_needrequest
Definition: execnodes.h:1362
bool as_syncdone
Definition: execnodes.h:1359
AsyncRequest ** as_asyncrequests
Definition: execnodes.h:1356
bool as_begun
Definition: execnodes.h:1353
Bitmapset * as_asyncplans
Definition: execnodes.h:1354
int as_whichplan
Definition: execnodes.h:1352
int as_nasyncresults
Definition: execnodes.h:1358
struct WaitEventSet * as_eventset
Definition: execnodes.h:1363
PlanState ** appendplans
Definition: execnodes.h:1350
int as_first_partial_plan
Definition: execnodes.h:1365
PlanState ps
Definition: execnodes.h:1349
int as_nasyncremain
Definition: execnodes.h:1361
ParallelAppendState * as_pstate
Definition: execnodes.h:1367
Bitmapset * as_valid_subplans
Definition: execnodes.h:1371
Size pstate_len
Definition: execnodes.h:1368
TupleTableSlot ** as_asyncresults
Definition: execnodes.h:1357
int as_nasyncplans
Definition: execnodes.h:1355
bool as_valid_subplans_identified
Definition: execnodes.h:1370
struct PlanState * requestor
Definition: execnodes.h:595
TupleTableSlot * result
Definition: execnodes.h:600
bool request_complete
Definition: execnodes.h:599
int request_index
Definition: execnodes.h:597
bool callback_pending
Definition: execnodes.h:598
struct PlanState * requestee
Definition: execnodes.h:596
PlanState ps
Definition: execnodes.h:1437
PlanState ** bitmapplans
Definition: execnodes.h:1438
ParallelBitmapHeapState * pstate
Definition: execnodes.h:1746
ExprState * bitmapqualorig
Definition: execnodes.h:1728
TBMIterateResult * tbmres
Definition: execnodes.h:1731
TBMIterator * tbmiterator
Definition: execnodes.h:1730
TIDBitmap * tbm
Definition: execnodes.h:1729
TBMIterator * prefetch_iterator
Definition: execnodes.h:1738
TBMSharedIterator * shared_prefetch_iterator
Definition: execnodes.h:1745
TBMSharedIterator * shared_tbmiterator
Definition: execnodes.h:1744
ExprContext * biss_RuntimeContext
Definition: execnodes.h:1651
IndexArrayKeyInfo * biss_ArrayKeys
Definition: execnodes.h:1648
IndexRuntimeKeyInfo * biss_RuntimeKeys
Definition: execnodes.h:1646
TIDBitmap * biss_result
Definition: execnodes.h:1643
struct ScanKeyData * biss_ScanKeys
Definition: execnodes.h:1644
struct IndexScanDescData * biss_ScanDesc
Definition: execnodes.h:1653
Relation biss_RelationDesc
Definition: execnodes.h:1652
PlanState ps
Definition: execnodes.h:1448
PlanState ** bitmapplans
Definition: execnodes.h:1449
Tuplestorestate * cte_table
Definition: execnodes.h:1910
ScanState ss
Definition: execnodes.h:1903
PlanState * cteplanstate
Definition: execnodes.h:1906
struct CteScanState * leader
Definition: execnodes.h:1908
const struct TupleTableSlotOps * slotOps
Definition: execnodes.h:1986
const struct CustomExecMethods * methods
Definition: execnodes.h:1985
List * custom_ps
Definition: execnodes.h:1983
ScanState ss
Definition: execnodes.h:1980
DomainConstraintType constrainttype
Definition: execnodes.h:999
ExprState * check_exprstate
Definition: execnodes.h:1002
ExecAuxRowMark ** relsubs_rowmark
Definition: execnodes.h:1212
TupleTableSlot * origslot
Definition: execnodes.h:1200
TupleTableSlot ** relsubs_slot
Definition: execnodes.h:1184
Plan * plan
Definition: execnodes.h:1191
int epqParam
Definition: execnodes.h:1174
bool * relsubs_blocked
Definition: execnodes.h:1228
EState * parentestate
Definition: execnodes.h:1173
EState * recheckestate
Definition: execnodes.h:1205
PlanState * recheckplanstate
Definition: execnodes.h:1230
List * resultRelations
Definition: execnodes.h:1175
List * arowMarks
Definition: execnodes.h:1192
List * tuple_table
Definition: execnodes.h:1183
bool * relsubs_done
Definition: execnodes.h:1219
uint64 es_processed
Definition: execnodes.h:663
struct dsa_area * es_query_dsa
Definition: execnodes.h:696
NodeTag type
Definition: execnodes.h:612
struct ExecRowMark ** es_rowmarks
Definition: execnodes.h:622
List * es_tuple_routing_result_relations
Definition: execnodes.h:647
int es_top_eflags
Definition: execnodes.h:668
struct JitContext * es_jit
Definition: execnodes.h:708
int es_instrument
Definition: execnodes.h:669
PlannedStmt * es_plannedstmt
Definition: execnodes.h:625
QueryEnvironment * es_queryEnv
Definition: execnodes.h:656
ResultRelInfo ** es_result_relations
Definition: execnodes.h:634
struct JitInstrumentation * es_jit_worker_instr
Definition: execnodes.h:709
ParamExecData * es_param_exec_vals
Definition: execnodes.h:654
uint64 es_total_processed
Definition: execnodes.h:665
List * es_range_table
Definition: execnodes.h:618
List * es_rteperminfos
Definition: execnodes.h:624
List * es_exprcontexts
Definition: execnodes.h:672
ParamListInfo es_param_list_info
Definition: execnodes.h:653
bool es_finished
Definition: execnodes.h:670
List * es_insert_pending_result_relations
Definition: execnodes.h:715
MemoryContext es_query_cxt
Definition: execnodes.h:659
List * es_tupleTable
Definition: execnodes.h:661
ScanDirection es_direction
Definition: execnodes.h:615
struct EPQState * es_epq_active
Definition: execnodes.h:691
PartitionDirectory es_partition_directory
Definition: execnodes.h:641
List * es_trig_target_relations
Definition: execnodes.h:650
int es_jit_flags
Definition: execnodes.h:707
List * es_opened_result_relations
Definition: execnodes.h:637
bool es_use_parallel_mode
Definition: execnodes.h:693
Relation * es_relations
Definition: execnodes.h:620
List * es_subplanstates
Definition: execnodes.h:674
ExprContext * es_per_tuple_exprcontext
Definition: execnodes.h:683
CommandId es_output_cid
Definition: execnodes.h:631
Index es_range_table_size
Definition: execnodes.h:619
List * es_insert_pending_modifytables
Definition: execnodes.h:716
const char * es_sourceText
Definition: execnodes.h:626
Snapshot es_snapshot
Definition: execnodes.h:616
List * es_auxmodifytables
Definition: execnodes.h:676
JunkFilter * es_junkFilter
Definition: execnodes.h:628
Snapshot es_crosscheck_snapshot
Definition: execnodes.h:617
AttrNumber wholeAttNo
Definition: execnodes.h:768
ExecRowMark * rowmark
Definition: execnodes.h:765
AttrNumber toidAttNo
Definition: execnodes.h:767
AttrNumber ctidAttNo
Definition: execnodes.h:766
Index rowmarkId
Definition: execnodes.h:745
ItemPointerData curCtid
Definition: execnodes.h:750
LockClauseStrength strength
Definition: execnodes.h:747
Index rti
Definition: execnodes.h:743
bool ermActive
Definition: execnodes.h:749
Index prti
Definition: execnodes.h:744
Relation relation
Definition: execnodes.h:741
LockWaitPolicy waitPolicy
Definition: execnodes.h:748
void * ermExtra
Definition: execnodes.h:751
RowMarkType markType
Definition: execnodes.h:746
struct ExprContext_CB * next
Definition: execnodes.h:215
Datum domainValue_datum
Definition: execnodes.h:280
ParamListInfo ecxt_param_list_info
Definition: execnodes.h:261
MemoryContext ecxt_per_tuple_memory
Definition: execnodes.h:257
TupleTableSlot * ecxt_innertuple
Definition: execnodes.h:251
ParamExecData * ecxt_param_exec_vals
Definition: execnodes.h:260
Datum * ecxt_aggvalues
Definition: execnodes.h:268
bool caseValue_isNull
Definition: execnodes.h:276
TupleTableSlot * ecxt_scantuple
Definition: execnodes.h:249
Datum caseValue_datum
Definition: execnodes.h:274
bool * ecxt_aggnulls
Definition: execnodes.h:270
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:256
ExprContext_CB * ecxt_callbacks
Definition: execnodes.h:288
bool domainValue_isNull
Definition: execnodes.h:282
NodeTag type
Definition: execnodes.h:245
struct EState * ecxt_estate
Definition: execnodes.h:285
TupleTableSlot * ecxt_outertuple
Definition: execnodes.h:253
Expr * expr
Definition: execnodes.h:110
NodeTag type
Definition: execnodes.h:79
Datum resvalue
Definition: execnodes.h:90
struct ExprEvalStep * steps
Definition: execnodes.h:101
int steps_alloc
Definition: execnodes.h:121
bool resnull
Definition: execnodes.h:88
ExprStateEvalFunc evalfunc
Definition: execnodes.h:107
Datum * innermost_domainval
Definition: execnodes.h:130
bool * innermost_domainnull
Definition: execnodes.h:131
TupleTableSlot * resultslot
Definition: execnodes.h:96
ParamListInfo ext_params
Definition: execnodes.h:125
void * evalfunc_private
Definition: execnodes.h:113
uint8 flags
Definition: execnodes.h:81
struct PlanState * parent
Definition: execnodes.h:124
bool * innermost_casenull
Definition: execnodes.h:128
Datum * innermost_caseval
Definition: execnodes.h:127
int steps_len
Definition: execnodes.h:120
Definition: fmgr.h:57
struct FdwRoutine * fdwroutine
Definition: execnodes.h:1959
ExprState * fdw_recheck_quals
Definition: execnodes.h:1955
ResultRelInfo * resultRelInfo
Definition: execnodes.h:1957
ScanState ss
Definition: execnodes.h:1954
struct FunctionScanPerFuncState * funcstates
Definition: execnodes.h:1828
MemoryContext argcontext
Definition: execnodes.h:1829
struct ParallelExecutorInfo * pei
Definition: execnodes.h:2621
TupleDesc tupDesc
Definition: execnodes.h:2618
struct TupleQueueReader ** reader
Definition: execnodes.h:2627
SortSupport gm_sortkeys
Definition: execnodes.h:2620
struct GMReaderTupleBuffer * gm_tuple_buffers
Definition: execnodes.h:2628
TupleTableSlot ** gm_slots
Definition: execnodes.h:2626
bool need_to_scan_locally
Definition: execnodes.h:2615
struct binaryheap * gm_heap
Definition: execnodes.h:2629
PlanState ps
Definition: execnodes.h:2612
bool initialized
Definition: execnodes.h:2587
TupleTableSlot * funnel_slot
Definition: execnodes.h:2591
struct ParallelExecutorInfo * pei
Definition: execnodes.h:2592
int nextreader
Definition: execnodes.h:2596
int nworkers_launched
Definition: execnodes.h:2594
PlanState ps
Definition: execnodes.h:2586
struct TupleQueueReader ** reader
Definition: execnodes.h:2597
int64 tuples_needed
Definition: execnodes.h:2589
bool need_to_scan_locally
Definition: execnodes.h:2588
ExprState * eqfunction
Definition: execnodes.h:2333
ScanState ss
Definition: execnodes.h:2332
bool grp_done
Definition: execnodes.h:2334
Definition: dynahash.c:220
HashJoinTuple hj_CurTuple
Definition: execnodes.h:2114
int hj_CurSkewBucketNo
Definition: execnodes.h:2113
List * hj_OuterHashKeys
Definition: execnodes.h:2107
TupleTableSlot * hj_NullOuterTupleSlot
Definition: execnodes.h:2117
TupleTableSlot * hj_OuterTupleSlot
Definition: execnodes.h:2115
bool hj_OuterNotEmpty
Definition: execnodes.h:2122
TupleTableSlot * hj_NullInnerTupleSlot
Definition: execnodes.h:2118
List * hj_HashOperators
Definition: execnodes.h:2108
ExprState * hashclauses
Definition: execnodes.h:2106
JoinState js
Definition: execnodes.h:2105
TupleTableSlot * hj_FirstOuterTupleSlot
Definition: execnodes.h:2119
bool hj_MatchedOuter
Definition: execnodes.h:2121
uint32 hj_CurHashValue
Definition: execnodes.h:2111
List * hj_Collations
Definition: execnodes.h:2109
int hj_CurBucketNo
Definition: execnodes.h:2112
HashJoinTable hj_HashTable
Definition: execnodes.h:2110
TupleTableSlot * hj_HashTupleSlot
Definition: execnodes.h:2116
struct ParallelHashJoinState * parallel_state
Definition: execnodes.h:2681
HashJoinTable hashtable
Definition: execnodes.h:2662
List * hashkeys
Definition: execnodes.h:2663
SharedHashInfo * shared_info
Definition: execnodes.h:2671
PlanState ps
Definition: execnodes.h:2661
HashInstrumentation * hinstrument
Definition: execnodes.h:2678
IncrementalSortGroupInfo prefixsortGroupInfo
Definition: execnodes.h:2278
IncrementalSortGroupInfo fullsortGroupInfo
Definition: execnodes.h:2277
Tuplesortstate * prefixsort_state
Definition: execnodes.h:2313
TupleTableSlot * group_pivot
Definition: execnodes.h:2320
TupleTableSlot * transfer_tuple
Definition: execnodes.h:2321
Tuplesortstate * fullsort_state
Definition: execnodes.h:2312
SharedIncrementalSortInfo * shared_info
Definition: execnodes.h:2323
IncrementalSortExecutionStatus execution_status
Definition: execnodes.h:2310
PresortedKeyData * presorted_keys
Definition: execnodes.h:2315
IncrementalSortInfo incsort_info
Definition: execnodes.h:2317
Datum * elem_values
Definition: execnodes.h:1529
ExprState * array_expr
Definition: execnodes.h:1526
struct ScanKeyData * scan_key
Definition: execnodes.h:1525
bool ii_Unique
Definition: execnodes.h:191
uint16 * ii_ExclusionStrats
Definition: execnodes.h:186
bool ii_BrokenHotChain
Definition: execnodes.h:197
NodeTag type
Definition: execnodes.h:176
int ii_NumIndexAttrs
Definition: execnodes.h:177
void * ii_AmCache
Definition: execnodes.h:201
bool ii_CheckedUnchanged
Definition: execnodes.h:194
Datum * ii_OpclassOptions
Definition: execnodes.h:190
Oid * ii_UniqueOps
Definition: execnodes.h:187
ExprState * ii_PredicateState
Definition: execnodes.h:183
Oid * ii_ExclusionOps
Definition: execnodes.h:184
bool ii_NullsNotDistinct
Definition: execnodes.h:192
int ii_ParallelWorkers
Definition: execnodes.h:199
bool ii_Concurrent
Definition: execnodes.h:196
uint16 * ii_UniqueStrats
Definition: execnodes.h:189
int ii_NumIndexKeyAttrs
Definition: execnodes.h:178
List * ii_ExpressionsState
Definition: execnodes.h:181
List * ii_Expressions
Definition: execnodes.h:180
bool ii_IndexUnchanged
Definition: execnodes.h:195
Oid * ii_ExclusionProcs
Definition: execnodes.h:185
Oid ii_Am
Definition: execnodes.h:200
AttrNumber ii_IndexAttrNumbers[INDEX_MAX_KEYS]
Definition: execnodes.h:179
bool ii_Summarizing
Definition: execnodes.h:198
Oid * ii_UniqueProcs
Definition: execnodes.h:188
MemoryContext ii_Context
Definition: execnodes.h:202
bool ii_ReadyForInserts
Definition: execnodes.h:193
List * ii_Predicate
Definition: execnodes.h:182
TupleTableSlot * ioss_TableSlot
Definition: execnodes.h:1619
bool ioss_RuntimeKeysReady
Definition: execnodes.h:1615
struct ScanKeyData * ioss_ScanKeys
Definition: execnodes.h:1609
ExprState * recheckqual
Definition: execnodes.h:1608
struct ScanKeyData * ioss_OrderByKeys
Definition: execnodes.h:1611
struct IndexScanDescData * ioss_ScanDesc
Definition: execnodes.h:1618
ExprContext * ioss_RuntimeContext
Definition: execnodes.h:1616
Relation ioss_RelationDesc
Definition: execnodes.h:1617
IndexRuntimeKeyInfo * ioss_RuntimeKeys
Definition: execnodes.h:1613
ExprState * key_expr
Definition: execnodes.h:1519
struct ScanKeyData * scan_key
Definition: execnodes.h:1518
bool iss_ReachedEnd
Definition: execnodes.h:1577
List * indexorderbyorig
Definition: execnodes.h:1563
bool * iss_OrderByTypByVals
Definition: execnodes.h:1581
int iss_NumRuntimeKeys
Definition: execnodes.h:1569
struct IndexScanDescData * iss_ScanDesc
Definition: execnodes.h:1573
ExprState * indexqualorig
Definition: execnodes.h:1562
Relation iss_RelationDesc
Definition: execnodes.h:1572
pairingheap * iss_ReorderQueue
Definition: execnodes.h:1576
ScanState ss
Definition: execnodes.h:1561
bool * iss_OrderByNulls
Definition: execnodes.h:1579
bool iss_RuntimeKeysReady
Definition: execnodes.h:1570
SortSupport iss_SortSupport
Definition: execnodes.h:1580
struct ScanKeyData * iss_ScanKeys
Definition: execnodes.h:1564
int iss_NumOrderByKeys
Definition: execnodes.h:1567
ExprContext * iss_RuntimeContext
Definition: execnodes.h:1571
struct ScanKeyData * iss_OrderByKeys
Definition: execnodes.h:1566
Datum * iss_OrderByValues
Definition: execnodes.h:1578
int16 * iss_OrderByTypLens
Definition: execnodes.h:1582
IndexRuntimeKeyInfo * iss_RuntimeKeys
Definition: execnodes.h:1568
Definition: jit.h:58
JoinType jointype
Definition: execnodes.h:2003
PlanState ps
Definition: execnodes.h:2002
ExprState * joinqual
Definition: execnodes.h:2006
bool single_match
Definition: execnodes.h:2004
TupleDesc jf_cleanTupType
Definition: execnodes.h:389
TupleTableSlot * jf_resultSlot
Definition: execnodes.h:391
AttrNumber * jf_cleanMap
Definition: execnodes.h:390
List * jf_targetList
Definition: execnodes.h:388
NodeTag type
Definition: execnodes.h:387
PlanState ps
Definition: execnodes.h:2753
ExprState * limitOffset
Definition: execnodes.h:2754
ExprState * limitCount
Definition: execnodes.h:2755
LimitOption limitOption
Definition: execnodes.h:2756
bool noCount
Definition: execnodes.h:2759
int64 position
Definition: execnodes.h:2761
TupleTableSlot * last_slot
Definition: execnodes.h:2765
int64 offset
Definition: execnodes.h:2757
ExprState * eqfunction
Definition: execnodes.h:2763
int64 count
Definition: execnodes.h:2758
LimitStateCond lstate
Definition: execnodes.h:2760
TupleTableSlot * subSlot
Definition: execnodes.h:2762
Definition: pg_list.h:54
PlanState ps
Definition: execnodes.h:2722
List * lr_arowMarks
Definition: execnodes.h:2723
EPQState lr_epqstate
Definition: execnodes.h:2724
bool eof_underlying
Definition: execnodes.h:2144
Tuplestorestate * tuplestorestate
Definition: execnodes.h:2145
ScanState ss
Definition: execnodes.h:2142
TupleDesc hashkeydesc
Definition: execnodes.h:2190
uint64 mem_used
Definition: execnodes.h:2198
FmgrInfo * hashfunctions
Definition: execnodes.h:2196
Oid * collations
Definition: execnodes.h:2197
TupleTableSlot * probeslot
Definition: execnodes.h:2192
SharedMemoizeInfo * shared_info
Definition: execnodes.h:2213
struct MemoizeEntry * entry
Definition: execnodes.h:2206
ExprState * cache_eq_expr
Definition: execnodes.h:2193
MemoizeInstrumentation stats
Definition: execnodes.h:2212
bool singlerow
Definition: execnodes.h:2208
dlist_head lru_list
Definition: execnodes.h:2201
MemoryContext tableContext
Definition: execnodes.h:2200
bool binary_mode
Definition: execnodes.h:2210
Bitmapset * keyparamids
Definition: execnodes.h:2214
ScanState ss
Definition: execnodes.h:2186
uint64 mem_limit
Definition: execnodes.h:2199
ExprState ** param_exprs
Definition: execnodes.h:2194
struct memoize_hash * hashtable
Definition: execnodes.h:2189
TupleTableSlot * tableslot
Definition: execnodes.h:2191
struct MemoizeTuple * last_tuple
Definition: execnodes.h:2202
MergeAction * mas_action
Definition: execnodes.h:419
ProjectionInfo * mas_proj
Definition: execnodes.h:420
ExprState * mas_whenqual
Definition: execnodes.h:422
PlanState ** mergeplans
Definition: execnodes.h:1394
SortSupport ms_sortkeys
Definition: execnodes.h:1397
Bitmapset * ms_valid_subplans
Definition: execnodes.h:1402
PlanState ps
Definition: execnodes.h:1393
struct binaryheap * ms_heap
Definition: execnodes.h:1399
TupleTableSlot ** ms_slots
Definition: execnodes.h:1398
struct PartitionPruneState * ms_prune_state
Definition: execnodes.h:1401
bool mj_MatchedOuter
Definition: execnodes.h:2061
bool mj_SkipMarkRestore
Definition: execnodes.h:2056
bool mj_ConstFalseJoin
Definition: execnodes.h:2058
TupleTableSlot * mj_MarkedTupleSlot
Definition: execnodes.h:2065
TupleTableSlot * mj_NullInnerTupleSlot
Definition: execnodes.h:2067
ExprContext * mj_InnerEContext
Definition: execnodes.h:2069
TupleTableSlot * mj_NullOuterTupleSlot
Definition: execnodes.h:2066
bool mj_ExtraMarks
Definition: execnodes.h:2057
MergeJoinClause mj_Clauses
Definition: execnodes.h:2054
bool mj_MatchedInner
Definition: execnodes.h:2062
TupleTableSlot * mj_InnerTupleSlot
Definition: execnodes.h:2064
ExprContext * mj_OuterEContext
Definition: execnodes.h:2068
JoinState js
Definition: execnodes.h:2052
TupleTableSlot * mj_OuterTupleSlot
Definition: execnodes.h:2063
CmdType operation
Definition: execnodes.h:1276
ResultRelInfo * resultRelInfo
Definition: execnodes.h:1280
double mt_merge_deleted
Definition: execnodes.h:1325
struct PartitionTupleRouting * mt_partition_tuple_routing
Definition: execnodes.h:1311
double mt_merge_inserted
Definition: execnodes.h:1323
TupleTableSlot * mt_root_tuple_slot
Definition: execnodes.h:1308
EPQState mt_epqstate
Definition: execnodes.h:1290
int mt_merge_subcommands
Definition: execnodes.h:1320
double mt_merge_updated
Definition: execnodes.h:1324
PlanState ps
Definition: execnodes.h:1275
HTAB * mt_resultOidHash
Definition: execnodes.h:1302
ResultRelInfo * rootResultRelInfo
Definition: execnodes.h:1288
struct TransitionCaptureState * mt_transition_capture
Definition: execnodes.h:1314
struct TransitionCaptureState * mt_oc_transition_capture
Definition: execnodes.h:1317
Tuplestorestate * relation
Definition: execnodes.h:1929
TupleTableSlot * nl_NullInnerTupleSlot
Definition: execnodes.h:2022
bool nl_NeedNewOuter
Definition: execnodes.h:2020
JoinState js
Definition: execnodes.h:2019
bool nl_MatchedOuter
Definition: execnodes.h:2021
Definition: nodes.h:129
TupleTableSlot * oc_ProjSlot
Definition: execnodes.h:404
TupleTableSlot * oc_Existing
Definition: execnodes.h:403
ExprState * oc_WhereClause
Definition: execnodes.h:406
ProjectionInfo * oc_ProjInfo
Definition: execnodes.h:405
SharedBitmapState state
Definition: execnodes.h:1696
dsa_pointer tbmiterator
Definition: execnodes.h:1691
ConditionVariable cv
Definition: execnodes.h:1697
dsa_pointer prefetch_iterator
Definition: execnodes.h:1692
bool inneropsset
Definition: execnodes.h:1121
const TupleTableSlotOps * resultops
Definition: execnodes.h:1114
bool outeropsset
Definition: execnodes.h:1120
struct SharedJitInstrumentation * worker_jit_instrument
Definition: execnodes.h:1051
Instrumentation * instrument
Definition: execnodes.h:1047
ExecProcNodeMtd ExecProcNodeReal
Definition: execnodes.h:1044
const TupleTableSlotOps * outerops
Definition: execnodes.h:1112
const TupleTableSlotOps * innerops
Definition: execnodes.h:1113
bool resultopsset
Definition: execnodes.h:1122
struct PlanState * righttree
Definition: execnodes.h:1060
ExprState * qual
Definition: execnodes.h:1058
const TupleTableSlotOps * scanops
Definition: execnodes.h:1111
Plan * plan
Definition: execnodes.h:1037
bool outeropsfixed
Definition: execnodes.h:1116
List * subPlan
Definition: execnodes.h:1064
TupleDesc ps_ResultTupleDesc
Definition: execnodes.h:1074
WorkerInstrumentation * worker_instrument
Definition: execnodes.h:1048
pg_node_attr(abstract) NodeTag type
List * initPlan
Definition: execnodes.h:1062
Bitmapset * chgParam
Definition: execnodes.h:1069
bool scanopsset
Definition: execnodes.h:1119
ExprContext * ps_ExprContext
Definition: execnodes.h:1076
TupleTableSlot * ps_ResultTupleSlot
Definition: execnodes.h:1075
TupleDesc scandesc
Definition: execnodes.h:1086
ProjectionInfo * ps_ProjInfo
Definition: execnodes.h:1077
bool scanopsfixed
Definition: execnodes.h:1115
bool async_capable
Definition: execnodes.h:1079
bool resultopsfixed
Definition: execnodes.h:1118
struct PlanState * lefttree
Definition: execnodes.h:1059
bool inneropsfixed
Definition: execnodes.h:1117
ExecProcNodeMtd ExecProcNode
Definition: execnodes.h:1043
OffsetNumber attno
Definition: execnodes.h:2229
FmgrInfo flinfo
Definition: execnodes.h:2227
FunctionCallInfo fcinfo
Definition: execnodes.h:2228
PlanState ps
Definition: execnodes.h:1255
MemoryContext argcontext
Definition: execnodes.h:1260
bool pending_srf_tuples
Definition: execnodes.h:1259
ExprDoneCond * elemdone
Definition: execnodes.h:1257
ExprState pi_state
Definition: execnodes.h:356
ExprContext * pi_exprContext
Definition: execnodes.h:358
NodeTag type
Definition: execnodes.h:354
MemoryContext tempContext
Definition: execnodes.h:1426
MemoryContext tableContext
Definition: execnodes.h:1428
Tuplestorestate * working_table
Definition: execnodes.h:1421
FmgrInfo * hashfunctions
Definition: execnodes.h:1425
Tuplestorestate * intermediate_table
Definition: execnodes.h:1422
TupleHashTable hashtable
Definition: execnodes.h:1427
TupleConversionMap * ri_RootToChildMap
Definition: execnodes.h:560
List * ri_matchedMergeAction
Definition: execnodes.h:542
TupleTableSlot * ri_PartitionTupleSlot
Definition: execnodes.h:575
List * ri_notMatchedMergeAction
Definition: execnodes.h:543
bool ri_projectNewInfoValid
Definition: execnodes.h:477
OnConflictSetState * ri_onConflict
Definition: execnodes.h:539
int ri_NumIndices
Definition: execnodes.h:453
List * ri_onConflictArbiterIndexes
Definition: execnodes.h:536
struct ResultRelInfo * ri_RootResultRelInfo
Definition: execnodes.h:574
ExprState ** ri_ConstraintExprs
Definition: execnodes.h:519
ExprState * ri_PartitionCheckExpr
Definition: execnodes.h:546
Instrumentation * ri_TrigInstrument
Definition: execnodes.h:489
TupleTableSlot ** ri_Slots
Definition: execnodes.h:509
Relation ri_RelationDesc
Definition: execnodes.h:450
RelationPtr ri_IndexRelationDescs
Definition: execnodes.h:456
TupleTableSlot * ri_ReturningSlot
Definition: execnodes.h:492
int ri_NumSlotsInitialized
Definition: execnodes.h:507
List * ri_WithCheckOptions
Definition: execnodes.h:513
TupleTableSlot * ri_oldTupleSlot
Definition: execnodes.h:475
bool ri_RootToChildMapValid
Definition: execnodes.h:561
struct CopyMultiInsertBuffer * ri_CopyMultiInsertBuffer
Definition: execnodes.h:578
TriggerDesc * ri_TrigDesc
Definition: execnodes.h:480
Bitmapset * ri_extraUpdatedCols
Definition: execnodes.h:468
Index ri_RangeTableIndex
Definition: execnodes.h:447
ExprState ** ri_GeneratedExprsI
Definition: execnodes.h:522
TupleConversionMap * ri_ChildToRootMap
Definition: execnodes.h:554
void * ri_FdwState
Definition: execnodes.h:500
bool ri_ChildToRootMapValid
Definition: execnodes.h:555
int ri_NumGeneratedNeededU
Definition: execnodes.h:527
List * ri_ancestorResultRels
Definition: execnodes.h:584
TupleTableSlot * ri_newTupleSlot
Definition: execnodes.h:473
List * ri_WithCheckOptionExprs
Definition: execnodes.h:516
ProjectionInfo * ri_projectNew
Definition: execnodes.h:471
NodeTag type
Definition: execnodes.h:444
ProjectionInfo * ri_projectReturning
Definition: execnodes.h:533
ExprState ** ri_GeneratedExprsU
Definition: execnodes.h:523
struct FdwRoutine * ri_FdwRoutine
Definition: execnodes.h:497
ExprState ** ri_TrigWhenExprs
Definition: execnodes.h:486
List * ri_returningList
Definition: execnodes.h:530
FmgrInfo * ri_TrigFunctions
Definition: execnodes.h:483
TupleTableSlot ** ri_PlanSlots
Definition: execnodes.h:510
bool ri_usesFdwDirectModify
Definition: execnodes.h:503
AttrNumber ri_RowIdAttNo
Definition: execnodes.h:465
IndexInfo ** ri_IndexRelationInfo
Definition: execnodes.h:459
TupleTableSlot * ri_TrigNewSlot
Definition: execnodes.h:494
int ri_NumGeneratedNeededI
Definition: execnodes.h:526
int ri_BatchSize
Definition: execnodes.h:508
TupleTableSlot * ri_TrigOldSlot
Definition: execnodes.h:493
ExprState * resconstantqual
Definition: execnodes.h:1241
bool rs_done
Definition: execnodes.h:1242
PlanState ps
Definition: execnodes.h:1240
bool rs_checkqual
Definition: execnodes.h:1243
NodeTag type
Definition: execnodes.h:324
SetFunctionReturnMode returnMode
Definition: execnodes.h:330
ExprContext * econtext
Definition: execnodes.h:326
TupleDesc setDesc
Definition: execnodes.h:334
Tuplestorestate * setResult
Definition: execnodes.h:333
TupleDesc expectedDesc
Definition: execnodes.h:327
int allowedModes
Definition: execnodes.h:328
ExprDoneCond isDone
Definition: execnodes.h:331
ExprState * repeatable
Definition: execnodes.h:1498
void * tsm_state
Definition: execnodes.h:1501
ScanState ss
Definition: execnodes.h:1496
struct TsmRoutine * tsmroutine
Definition: execnodes.h:1500
Relation ss_currentRelation
Definition: execnodes.h:1475
TupleTableSlot * ss_ScanTupleSlot
Definition: execnodes.h:1477
PlanState ps
Definition: execnodes.h:1474
struct TableScanDescData * ss_currentScanDesc
Definition: execnodes.h:1476
ScanState ss
Definition: execnodes.h:1486
Size pscan_len
Definition: execnodes.h:1487
Expr * expr
Definition: execnodes.h:882
FunctionCallInfo fcinfo
Definition: execnodes.h:942
TupleTableSlot * funcResultSlot
Definition: execnodes.h:905
Tuplestorestate * funcResultStore
Definition: execnodes.h:904
bool funcReturnsSet
Definition: execnodes.h:918
bool shutdown_reg
Definition: execnodes.h:935
bool funcReturnsTuple
Definition: execnodes.h:912
ExprState * elidedFuncState
Definition: execnodes.h:890
TupleDesc funcResultDesc
Definition: execnodes.h:911
FmgrInfo func
Definition: execnodes.h:897
List * args
Definition: execnodes.h:883
NodeTag type
Definition: execnodes.h:881
bool setArgsValid
Definition: execnodes.h:927
long numOutput
Definition: execnodes.h:2703
HeapTuple grp_firstTuple
Definition: execnodes.h:2706
SetOpStatePerGroup pergroup
Definition: execnodes.h:2705
ExprState * eqfunction
Definition: execnodes.h:2699
TupleHashIterator hashiter
Definition: execnodes.h:2711
bool table_filled
Definition: execnodes.h:2710
MemoryContext tableContext
Definition: execnodes.h:2709
PlanState ps
Definition: execnodes.h:2698
Oid * eqfuncoids
Definition: execnodes.h:2700
TupleHashTable hashtable
Definition: execnodes.h:2708
FmgrInfo * hashfunctions
Definition: execnodes.h:2701
bool setop_done
Definition: execnodes.h:2702
bool sort_Done
Definition: execnodes.h:2252
bool am_worker
Definition: execnodes.h:2256
int64 bound_Done
Definition: execnodes.h:2254
bool bounded_Done
Definition: execnodes.h:2253
void * tuplesortstate
Definition: execnodes.h:2255
bool randomAccess
Definition: execnodes.h:2249
SharedSortInfo * shared_info
Definition: execnodes.h:2258
bool datumSort
Definition: execnodes.h:2257
ScanState ss
Definition: execnodes.h:2248
bool bounded
Definition: execnodes.h:2250
int64 bound
Definition: execnodes.h:2251
TupleHashTable hashtable
Definition: execnodes.h:963
ExprState * cur_eq_comp
Definition: execnodes.h:980
FmgrInfo * tab_eq_funcs
Definition: execnodes.h:977
MemoryContext hashtablecxt
Definition: execnodes.h:967
Oid * tab_eq_funcoids
Definition: execnodes.h:973
NodeTag type
Definition: execnodes.h:951
ExprContext * innerecontext
Definition: execnodes.h:969
FmgrInfo * tab_hash_funcs
Definition: execnodes.h:976
FmgrInfo * cur_eq_funcs
Definition: execnodes.h:979
List * args
Definition: execnodes.h:956
MemoryContext hashtempcxt
Definition: execnodes.h:968
HeapTuple curTuple
Definition: execnodes.h:957
FmgrInfo * lhs_hash_funcs
Definition: execnodes.h:978
AttrNumber * keyColIdx
Definition: execnodes.h:972
struct PlanState * planstate
Definition: execnodes.h:953
TupleDesc descRight
Definition: execnodes.h:960
SubPlan * subplan
Definition: execnodes.h:952
ProjectionInfo * projLeft
Definition: execnodes.h:961
ProjectionInfo * projRight
Definition: execnodes.h:962
bool havenullrows
Definition: execnodes.h:966
ExprState * testexpr
Definition: execnodes.h:955
struct PlanState * parent
Definition: execnodes.h:954
Oid * tab_collations
Definition: execnodes.h:975
TupleHashTable hashnulls
Definition: execnodes.h:964
bool havehashrows
Definition: execnodes.h:965
Datum curArray
Definition: execnodes.h:958
PlanState * subplan
Definition: execnodes.h:1799
MemoryContext perTableCxt
Definition: execnodes.h:1887
Tuplestorestate * tupstore
Definition: execnodes.h:1888
Bitmapset * notnulls
Definition: execnodes.h:1881
const struct TableFuncRoutine * routine
Definition: execnodes.h:1883
ExprState * rowexpr
Definition: execnodes.h:1876
FmgrInfo * in_functions
Definition: execnodes.h:1884
ExprState * docexpr
Definition: execnodes.h:1875
ItemPointerData trss_maxtid
Definition: execnodes.h:1785
List * trss_tidexprs
Definition: execnodes.h:1783
ItemPointerData trss_mintid
Definition: execnodes.h:1784
ScanState ss
Definition: execnodes.h:1762
HeapTupleData tss_htup
Definition: execnodes.h:1768
bool tss_isCurrentOf
Definition: execnodes.h:1764
ItemPointerData * tss_TidList
Definition: execnodes.h:1767
List * tss_tidexprs
Definition: execnodes.h:1763
MinimalTuple firstTuple
Definition: execnodes.h:793
AttrNumber * keyColIdx
Definition: execnodes.h:811
FmgrInfo * tab_hash_funcs
Definition: execnodes.h:812
tuplehash_hash * hashtab
Definition: execnodes.h:809
MemoryContext tempcxt
Definition: execnodes.h:816
ExprState * tab_eq_func
Definition: execnodes.h:813
TupleTableSlot * tableslot
Definition: execnodes.h:818
ExprContext * exprcontext
Definition: execnodes.h:824
MemoryContext tablecxt
Definition: execnodes.h:815
TupleTableSlot * inputslot
Definition: execnodes.h:820
ExprState * cur_eq_func
Definition: execnodes.h:822
FmgrInfo * in_hash_funcs
Definition: execnodes.h:821
PlanState ps
Definition: execnodes.h:2573
ExprState * eqfunction
Definition: execnodes.h:2574
ScanState ss
Definition: execnodes.h:1858
List ** exprlists
Definition: execnodes.h:1860
List ** exprstatelists
Definition: execnodes.h:1861
ExprContext * rowcontext
Definition: execnodes.h:1859
ExprState * endOffset
Definition: execnodes.h:2504
MemoryContext aggcontext
Definition: execnodes.h:2523
ScanState ss
Definition: execnodes.h:2476
int64 aggregatedbase
Definition: execnodes.h:2498
int64 frametailgroup
Definition: execnodes.h:2518
int64 frameheadgroup
Definition: execnodes.h:2517
WindowStatePerAgg peragg
Definition: execnodes.h:2484
MemoryContext partcontext
Definition: execnodes.h:2522
FmgrInfo endInRangeFunc
Definition: execnodes.h:2510
TupleTableSlot * framehead_slot
Definition: execnodes.h:2551
bool frametail_valid
Definition: execnodes.h:2544
bool partition_spooled
Definition: execnodes.h:2538
FmgrInfo startInRangeFunc
Definition: execnodes.h:2509
int64 spooled_rows
Definition: execnodes.h:2492
int64 frameheadpos
Definition: execnodes.h:2494
bool more_partitions
Definition: execnodes.h:2540
Datum startOffsetValue
Definition: execnodes.h:2505
int64 grouptailpos
Definition: execnodes.h:2520
int64 currentgroup
Definition: execnodes.h:2516
TupleTableSlot * frametail_slot
Definition: execnodes.h:2552
ExprState * ordEqfunction
Definition: execnodes.h:2486
ExprState * runcondition
Definition: execnodes.h:2527
TupleTableSlot * temp_slot_2
Definition: execnodes.h:2557
Tuplestorestate * buffer
Definition: execnodes.h:2487
WindowAggStatus status
Definition: execnodes.h:2500
TupleTableSlot * agg_row_slot
Definition: execnodes.h:2555
struct WindowObjectData * agg_winobj
Definition: execnodes.h:2497
WindowStatePerFunc perfunc
Definition: execnodes.h:2483
bool framehead_valid
Definition: execnodes.h:2542
int64 groupheadpos
Definition: execnodes.h:2519
MemoryContext curaggcontext
Definition: execnodes.h:2524
bool inRangeNullsFirst
Definition: execnodes.h:2513
bool grouptail_valid
Definition: execnodes.h:2546
Datum endOffsetValue
Definition: execnodes.h:2506
int64 currentpos
Definition: execnodes.h:2493
ExprState * partEqfunction
Definition: execnodes.h:2485
int64 frametailpos
Definition: execnodes.h:2495
ExprState * startOffset
Definition: execnodes.h:2503
TupleTableSlot * first_part_slot
Definition: execnodes.h:2549
int64 aggregatedupto
Definition: execnodes.h:2499
ExprContext * tmpcontext
Definition: execnodes.h:2525
TupleTableSlot * temp_slot_1
Definition: execnodes.h:2556
bool use_pass_through
Definition: execnodes.h:2532
WindowFunc * wfunc
Definition: execnodes.h:863
ExprState * aggfilter
Definition: execnodes.h:865
RecursiveUnionState * rustate
Definition: execnodes.h:1943
Definition: dsa.c:367
Definition: regguts.h:323
const char * type