execnodes.h File Reference

#include "access/skey.h"
#include "access/tupconvert.h"
#include "executor/instrument.h"
#include "executor/instrument_node.h"
#include "fmgr.h"
#include "lib/ilist.h"
#include "lib/pairingheap.h"
#include "nodes/miscnodes.h"
#include "nodes/params.h"
#include "nodes/plannodes.h"
#include "nodes/tidbitmap.h"
#include "partitioning/partdefs.h"
#include "storage/condition_variable.h"
#include "utils/hsearch.h"
#include "utils/queryenvironment.h"
#include "utils/reltrigger.h"
#include "utils/sharedtuplestore.h"
#include "utils/snapshot.h"
#include "utils/sortsupport.h"
#include "utils/tuplesort.h"
#include "utils/tuplestore.h"
#include "lib/simplehash.h"

Include dependency graph for execnodes.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ExprState
struct	IndexInfo
struct	ExprContext_CB
struct	ExprContext
struct	ReturnSetInfo
struct	ProjectionInfo
struct	JunkFilter
struct	OnConflictActionState
struct	MergeActionState
struct	ResultRelInfo
struct	AsyncRequest
struct	EState
struct	ExecRowMark
struct	ExecAuxRowMark
struct	TupleHashEntryData
struct	TupleHashTableData
struct	WindowFuncExprState
struct	SetExprState
struct	SubPlanState
struct	DomainConstraintState
struct	JsonExprState
struct	PlanState
struct	EPQState
struct	ResultState
struct	ProjectSetState
struct	ModifyTableState
struct	AppendState
struct	MergeAppendState
struct	RecursiveUnionState
struct	BitmapAndState
struct	BitmapOrState
struct	ScanState
struct	SeqScanState
struct	SampleScanState
struct	IndexRuntimeKeyInfo
struct	IndexArrayKeyInfo
struct	IndexScanState
struct	IndexOnlyScanState
struct	BitmapIndexScanState
struct	ParallelBitmapHeapState
struct	BitmapHeapScanState
struct	TidScanState
struct	TidRangeScanState
struct	SubqueryScanState
struct	FunctionScanState
struct	ValuesScanState
struct	TableFuncScanState
struct	CteScanState
struct	NamedTuplestoreScanState
struct	WorkTableScanState
struct	ForeignScanState
struct	CustomScanState
struct	JoinState
struct	NestLoopState
struct	MergeJoinState
struct	HashJoinState
struct	MaterialState
struct	MemoizeState
struct	PresortedKeyData
struct	SortState
struct	IncrementalSortState
struct	GroupState
struct	AggState
struct	WindowAggState
struct	UniqueState
struct	GatherState
struct	GatherMergeState
struct	HashState
struct	SetOpStatePerInput
struct	SetOpState
struct	LockRowsState
struct	LimitState

Macros
#define	EEO_FLAG_IS_QUAL   (1 << 0)
#define	EEO_FLAG_HAS_OLD   (1 << 1)
#define	EEO_FLAG_HAS_NEW   (1 << 2)
#define	EEO_FLAG_OLD_IS_NULL   (1 << 3)
#define	EEO_FLAG_NEW_IS_NULL   (1 << 4)
#define	FIELDNO_EXPRSTATE_FLAGS   1
#define	FIELDNO_EXPRSTATE_RESNULL   2
#define	FIELDNO_EXPRSTATE_RESVALUE   3
#define	FIELDNO_EXPRSTATE_RESULTSLOT   4
#define	FIELDNO_EXPRSTATE_PARENT   11
#define	FIELDNO_EXPRCONTEXT_SCANTUPLE   1
#define	FIELDNO_EXPRCONTEXT_INNERTUPLE   2
#define	FIELDNO_EXPRCONTEXT_OUTERTUPLE   3
#define	FIELDNO_EXPRCONTEXT_AGGVALUES   8
#define	FIELDNO_EXPRCONTEXT_AGGNULLS   9
#define	FIELDNO_EXPRCONTEXT_CASEDATUM   10
#define	FIELDNO_EXPRCONTEXT_CASENULL   11
#define	FIELDNO_EXPRCONTEXT_DOMAINDATUM   12
#define	FIELDNO_EXPRCONTEXT_DOMAINNULL   13
#define	FIELDNO_EXPRCONTEXT_OLDTUPLE   14
#define	FIELDNO_EXPRCONTEXT_NEWTUPLE   15
#define	SH_PREFIX   tuplehash
#define	SH_ELEMENT_TYPE   TupleHashEntryData
#define	SH_KEY_TYPE   MinimalTuple
#define	SH_SCOPE   extern
#define	SH_DECLARE
#define	InitTupleHashIterator(htable, iter)    tuplehash_start_iterate(htable->hashtab, iter)
#define	TermTupleHashIterator(iter)    ((void) 0)
#define	ResetTupleHashIterator(htable, iter)    InitTupleHashIterator(htable, iter)
#define	ScanTupleHashTable(htable, iter)    tuplehash_iterate(htable->hashtab, iter)
#define	innerPlanState(node)   (((PlanState *)(node))->righttree)
#define	outerPlanState(node)   (((PlanState *)(node))->lefttree)
#define	InstrCountTuples2(node, delta)
#define	InstrCountFiltered1(node, delta)
#define	InstrCountFiltered2(node, delta)
#define	MERGE_INSERT   0x01
#define	MERGE_UPDATE   0x02
#define	MERGE_DELETE   0x04
#define	FIELDNO_AGGSTATE_CURAGGCONTEXT   14
#define	FIELDNO_AGGSTATE_CURPERTRANS   16
#define	FIELDNO_AGGSTATE_CURRENT_SET   20
#define	FIELDNO_AGGSTATE_ALL_PERGROUPS   54

Typedefs
typedef struct PlanState	PlanState
typedef struct ExecRowMark	ExecRowMark
typedef struct ExprState	ExprState
typedef struct ExprContext	ExprContext
typedef Datum(*	ExprStateEvalFunc) (ExprState *expression, ExprContext *econtext, bool *isNull)
typedef struct IndexInfo	IndexInfo
typedef void(*	ExprContextCallbackFunction) (Datum arg)
typedef struct ExprContext_CB	ExprContext_CB
typedef struct ReturnSetInfo	ReturnSetInfo
typedef struct ProjectionInfo	ProjectionInfo
typedef struct JunkFilter	JunkFilter
typedef struct OnConflictActionState	OnConflictActionState
typedef struct MergeActionState	MergeActionState
typedef struct ResultRelInfo	ResultRelInfo
typedef struct AsyncRequest	AsyncRequest
typedef struct EState	EState
typedef struct ExecAuxRowMark	ExecAuxRowMark
typedef struct TupleHashEntryData *	TupleHashEntry
typedef struct TupleHashTableData *	TupleHashTable
typedef struct TupleHashEntryData	TupleHashEntryData
typedef struct TupleHashTableData	TupleHashTableData
typedef tuplehash_iterator	TupleHashIterator
typedef struct WindowFuncExprState	WindowFuncExprState
typedef struct SetExprState	SetExprState
typedef struct SubPlanState	SubPlanState
typedef enum DomainConstraintType	DomainConstraintType
typedef struct DomainConstraintState	DomainConstraintState
typedef struct JsonExprState	JsonExprState
typedef TupleTableSlot *(*	ExecProcNodeMtd) (PlanState *pstate)
typedef struct EPQState	EPQState
typedef struct ResultState	ResultState
typedef struct ProjectSetState	ProjectSetState
typedef struct ModifyTableState	ModifyTableState
typedef struct AppendState	AppendState
typedef struct ParallelAppendState	ParallelAppendState
typedef struct MergeAppendState	MergeAppendState
typedef struct RecursiveUnionState	RecursiveUnionState
typedef struct BitmapAndState	BitmapAndState
typedef struct BitmapOrState	BitmapOrState
typedef struct ScanState	ScanState
typedef struct SeqScanState	SeqScanState
typedef struct SampleScanState	SampleScanState
typedef struct IndexScanState	IndexScanState
typedef struct IndexOnlyScanState	IndexOnlyScanState
typedef struct BitmapIndexScanState	BitmapIndexScanState
typedef struct ParallelBitmapHeapState	ParallelBitmapHeapState
typedef struct BitmapHeapScanState	BitmapHeapScanState
typedef struct TidScanState	TidScanState
typedef struct TidRangeScanState	TidRangeScanState
typedef struct SubqueryScanState	SubqueryScanState
typedef struct FunctionScanState	FunctionScanState
typedef struct ValuesScanState	ValuesScanState
typedef struct TableFuncScanState	TableFuncScanState
typedef struct CteScanState	CteScanState
typedef struct NamedTuplestoreScanState	NamedTuplestoreScanState
typedef struct WorkTableScanState	WorkTableScanState
typedef struct ForeignScanState	ForeignScanState
typedef struct CustomScanState	CustomScanState
typedef struct JoinState	JoinState
typedef struct NestLoopState	NestLoopState
typedef struct MergeJoinClauseData *	MergeJoinClause
typedef struct MergeJoinState	MergeJoinState
typedef struct HashJoinTupleData *	HashJoinTuple
typedef struct HashJoinTableData *	HashJoinTable
typedef struct HashJoinState	HashJoinState
typedef struct MaterialState	MaterialState
typedef struct MemoizeState	MemoizeState
typedef struct PresortedKeyData	PresortedKeyData
typedef struct SortState	SortState
typedef struct IncrementalSortState	IncrementalSortState
typedef struct GroupState	GroupState
typedef struct AggStatePerAggData *	AggStatePerAgg
typedef struct AggStatePerTransData *	AggStatePerTrans
typedef struct AggStatePerGroupData *	AggStatePerGroup
typedef struct AggStatePerPhaseData *	AggStatePerPhase
typedef struct AggStatePerHashData *	AggStatePerHash
typedef struct AggState	AggState
typedef struct WindowStatePerFuncData *	WindowStatePerFunc
typedef struct WindowStatePerAggData *	WindowStatePerAgg
typedef enum WindowAggStatus	WindowAggStatus
typedef struct WindowAggState	WindowAggState
typedef struct UniqueState	UniqueState
typedef struct GatherState	GatherState
typedef struct GatherMergeState	GatherMergeState
typedef struct HashState	HashState
typedef struct SetOpStatePerInput	SetOpStatePerInput
typedef struct SetOpState	SetOpState
typedef struct LockRowsState	LockRowsState
typedef struct LimitState	LimitState

Enumerations
enum	ExprDoneCond { ExprSingleResult , ExprMultipleResult , ExprEndResult }
enum	SetFunctionReturnMode { SFRM_ValuePerCall = 0x01 , SFRM_Materialize = 0x02 , SFRM_Materialize_Random = 0x04 , SFRM_Materialize_Preferred = 0x08 }
enum	DomainConstraintType { DOM_CONSTRAINT_NOTNULL , DOM_CONSTRAINT_CHECK }
enum	SharedBitmapState { BM_INITIAL , BM_INPROGRESS , BM_FINISHED }
enum	IncrementalSortExecutionStatus { INCSORT_LOADFULLSORT , INCSORT_LOADPREFIXSORT , INCSORT_READFULLSORT , INCSORT_READPREFIXSORT }
enum	WindowAggStatus { WINDOWAGG_DONE , WINDOWAGG_RUN , WINDOWAGG_PASSTHROUGH , WINDOWAGG_PASSTHROUGH_STRICT }
enum	LimitStateCond {   LIMIT_INITIAL , LIMIT_RESCAN , LIMIT_EMPTY , LIMIT_INWINDOW ,   LIMIT_WINDOWEND_TIES , LIMIT_SUBPLANEOF , LIMIT_WINDOWEND , LIMIT_WINDOWSTART }

Macro Definition Documentation

EEO_FLAG_HAS_NEW

#define EEO_FLAG_HAS_NEW   (1 << 2)

Definition at line 80 of file execnodes.h.

EEO_FLAG_HAS_OLD

#define EEO_FLAG_HAS_OLD   (1 << 1)

Definition at line 78 of file execnodes.h.

EEO_FLAG_IS_QUAL

#define EEO_FLAG_IS_QUAL   (1 << 0)

Definition at line 76 of file execnodes.h.

EEO_FLAG_NEW_IS_NULL

#define EEO_FLAG_NEW_IS_NULL   (1 << 4)

Definition at line 84 of file execnodes.h.

EEO_FLAG_OLD_IS_NULL

#define EEO_FLAG_OLD_IS_NULL   (1 << 3)

Definition at line 82 of file execnodes.h.

FIELDNO_AGGSTATE_ALL_PERGROUPS

#define FIELDNO_AGGSTATE_ALL_PERGROUPS   54

Definition at line 2490 of file execnodes.h.

FIELDNO_AGGSTATE_CURAGGCONTEXT

#define FIELDNO_AGGSTATE_CURAGGCONTEXT   14

Definition at line 2435 of file execnodes.h.

FIELDNO_AGGSTATE_CURPERTRANS

#define FIELDNO_AGGSTATE_CURPERTRANS   16

Definition at line 2438 of file execnodes.h.

FIELDNO_AGGSTATE_CURRENT_SET

#define FIELDNO_AGGSTATE_CURRENT_SET   20

Definition at line 2443 of file execnodes.h.

FIELDNO_EXPRCONTEXT_AGGNULLS

#define FIELDNO_EXPRCONTEXT_AGGNULLS   9

Definition at line 295 of file execnodes.h.

FIELDNO_EXPRCONTEXT_AGGVALUES

#define FIELDNO_EXPRCONTEXT_AGGVALUES   8

Definition at line 293 of file execnodes.h.

FIELDNO_EXPRCONTEXT_CASEDATUM

#define FIELDNO_EXPRCONTEXT_CASEDATUM   10

Definition at line 299 of file execnodes.h.

FIELDNO_EXPRCONTEXT_CASENULL

#define FIELDNO_EXPRCONTEXT_CASENULL   11

Definition at line 301 of file execnodes.h.

FIELDNO_EXPRCONTEXT_DOMAINDATUM

#define FIELDNO_EXPRCONTEXT_DOMAINDATUM   12

Definition at line 305 of file execnodes.h.

FIELDNO_EXPRCONTEXT_DOMAINNULL

#define FIELDNO_EXPRCONTEXT_DOMAINNULL   13

Definition at line 307 of file execnodes.h.

FIELDNO_EXPRCONTEXT_INNERTUPLE

#define FIELDNO_EXPRCONTEXT_INNERTUPLE   2

Definition at line 276 of file execnodes.h.

FIELDNO_EXPRCONTEXT_NEWTUPLE

#define FIELDNO_EXPRCONTEXT_NEWTUPLE   15

Definition at line 313 of file execnodes.h.

FIELDNO_EXPRCONTEXT_OLDTUPLE

#define FIELDNO_EXPRCONTEXT_OLDTUPLE   14

Definition at line 311 of file execnodes.h.

FIELDNO_EXPRCONTEXT_OUTERTUPLE

#define FIELDNO_EXPRCONTEXT_OUTERTUPLE   3

Definition at line 278 of file execnodes.h.

FIELDNO_EXPRCONTEXT_SCANTUPLE

#define FIELDNO_EXPRCONTEXT_SCANTUPLE   1

Definition at line 274 of file execnodes.h.

FIELDNO_EXPRSTATE_FLAGS

#define FIELDNO_EXPRSTATE_FLAGS   1

Definition at line 90 of file execnodes.h.

FIELDNO_EXPRSTATE_PARENT

#define FIELDNO_EXPRSTATE_PARENT   11

Definition at line 133 of file execnodes.h.

FIELDNO_EXPRSTATE_RESNULL

#define FIELDNO_EXPRSTATE_RESNULL   2

Definition at line 97 of file execnodes.h.

FIELDNO_EXPRSTATE_RESULTSLOT

#define FIELDNO_EXPRSTATE_RESULTSLOT   4

Definition at line 105 of file execnodes.h.

FIELDNO_EXPRSTATE_RESVALUE

#define FIELDNO_EXPRSTATE_RESVALUE   3

Definition at line 99 of file execnodes.h.

InitTupleHashIterator

#define InitTupleHashIterator	(		htable,
			iter
	)		tuplehash_start_iterate(htable->hashtab, iter)

Definition at line 897 of file execnodes.h.

{
    NodeTag     type;
    WindowFunc *wfunc;          /* expression plan node */
    List       *args;           /* ExprStates for argument expressions */
    ExprState  *aggfilter;      /* FILTER expression */
    int         wfuncno;        /* ID number for wfunc within its plan node */
} WindowFuncExprState;
 
 
/* ----------------
 *      SetExprState node
 *
 * State for evaluating a potentially set-returning expression (like FuncExpr
 * or OpExpr).  In some cases, like some of the expressions in ROWS FROM(...)
 * the expression might not be a SRF, but nonetheless it uses the same
 * machinery as SRFs; it will be treated as a SRF returning a single row.
 * ----------------
 */
typedef struct SetExprState
{
    NodeTag     type;
    Expr       *expr;           /* expression plan node */
    List       *args;           /* ExprStates for argument expressions */
 
    /*
     * In ROWS FROM, functions can be inlined, removing the FuncExpr normally
     * inside.  In such a case this is the compiled expression (which cannot
     * return a set), which'll be evaluated using regular ExecEvalExpr().
     */
    ExprState  *elidedFuncState;
 
    /*
     * Function manager's lookup info for the target function.  If func.fn_oid
     * is InvalidOid, we haven't initialized it yet (nor any of the following
     * fields, except funcReturnsSet).
     */
    FmgrInfo    func;
 
    /*
     * For a set-returning function (SRF) that returns a tuplestore, we keep
     * the tuplestore here and dole out the result rows one at a time. The
     * slot holds the row currently being returned.
     */
    Tuplestorestate *funcResultStore;
    TupleTableSlot *funcResultSlot;
 
    /*
     * In some cases we need to compute a tuple descriptor for the function's
     * output.  If so, it's stored here.
     */
    TupleDesc   funcResultDesc;
    bool        funcReturnsTuple;   /* valid when funcResultDesc isn't NULL */
 
    /*
     * Remember whether the function is declared to return a set.  This is set
     * by ExecInitExpr, and is valid even before the FmgrInfo is set up.
     */
    bool        funcReturnsSet;
 
    /*
     * setArgsValid is true when we are evaluating a set-returning function
     * that uses value-per-call mode and we are in the middle of a call
     * series; we want to pass the same argument values to the function again
     * (and again, until it returns ExprEndResult).  This indicates that
     * fcinfo_data already contains valid argument data.
     */
    bool        setArgsValid;
 
    /*
     * Flag to remember whether we have registered a shutdown callback for
     * this SetExprState.  We do so only if funcResultStore or setArgsValid
     * has been set at least once (since all the callback is for is to release
     * the tuplestore or clear setArgsValid).
     */
    bool        shutdown_reg;   /* a shutdown callback is registered */
 
    /*
     * Call parameter structure for the function.  This has been initialized
     * (by InitFunctionCallInfoData) if func.fn_oid is valid.  It also saves
     * argument values between calls, when setArgsValid is true.
     */
    FunctionCallInfo fcinfo;
} SetExprState;
 
/* ----------------
 *      SubPlanState node
 * ----------------
 */
typedef struct SubPlanState
{
    NodeTag     type;
    SubPlan    *subplan;        /* expression plan node */
    PlanState  *planstate;      /* subselect plan's state tree */
    PlanState  *parent;         /* parent plan node's state tree */
    ExprState  *testexpr;       /* state of combining expression */
    HeapTuple   curTuple;       /* copy of most recent tuple from subplan */
    Datum       curArray;       /* most recent array from ARRAY() subplan */
    /* these are used when hashing the subselect's output: */
    TupleDesc   descRight;      /* subselect desc after projection */
    ProjectionInfo *projLeft;   /* for projecting lefthand exprs */
    ProjectionInfo *projRight;  /* for projecting subselect output */
    TupleHashTable hashtable;   /* hash table for no-nulls subselect rows */
    TupleHashTable hashnulls;   /* hash table for rows with null(s) */
    bool        havehashrows;   /* true if hashtable is not empty */
    bool        havenullrows;   /* true if hashnulls is not empty */
    MemoryContext tuplesContext;    /* context containing hash tables' tuples */
    ExprContext *innerecontext; /* econtext for computing inner tuples */
    int         numCols;        /* number of columns being hashed */
    /* each of the remaining fields is an array of length numCols: */
    AttrNumber *keyColIdx;      /* control data for hash tables */
    Oid        *tab_eq_funcoids;    /* equality func oids for table
                                     * datatype(s) */
    Oid        *tab_collations; /* collations for hash and comparison */
    FmgrInfo   *tab_hash_funcs; /* hash functions for table datatype(s) */
    ExprState  *lhs_hash_expr;  /* hash expr for lefthand datatype(s) */
    FmgrInfo   *cur_eq_funcs;   /* equality functions for LHS vs. table */
    ExprState  *cur_eq_comp;    /* equality comparator for LHS vs. table */
} SubPlanState;
 
/*
 * DomainConstraintState - one item to check during CoerceToDomain
 *
 * Note: we consider this to be part of an ExprState tree, so we give it
 * a name following the xxxState convention.  But there's no directly
 * associated plan-tree node.
 */
typedef enum DomainConstraintType
{
    DOM_CONSTRAINT_NOTNULL,
    DOM_CONSTRAINT_CHECK,
} DomainConstraintType;
 
typedef struct DomainConstraintState
{
    NodeTag     type;
    DomainConstraintType constrainttype;    /* constraint type */
    char       *name;           /* name of constraint (for error msgs) */
    Expr       *check_expr;     /* for CHECK, a boolean expression */
    ExprState  *check_exprstate;    /* check_expr's eval state, or NULL */
} DomainConstraintState;
 
/*
 * State for JsonExpr evaluation, too big to inline.
 *
 * This contains the information going into and coming out of the
 * EEOP_JSONEXPR_PATH eval step.
 */
typedef struct JsonExprState
{
    /* original expression node */
    JsonExpr   *jsexpr;
 
    /* value/isnull for formatted_expr */
    NullableDatum formatted_expr;
 
    /* value/isnull for pathspec */
    NullableDatum pathspec;
 
    /* JsonPathVariable entries for passing_values */
    List       *args;
 
    /*
     * Output variables that drive the EEOP_JUMP_IF_NOT_TRUE steps that are
     * added for ON ERROR and ON EMPTY expressions, if any.
     *
     * Reset for each evaluation of EEOP_JSONEXPR_PATH.
     */
 
    /* Set to true if jsonpath evaluation cause an error.  */
    NullableDatum error;
 
    /* Set to true if the jsonpath evaluation returned 0 items. */
    NullableDatum empty;
 
    /*
     * Addresses of steps that implement the non-ERROR variant of ON EMPTY and
     * ON ERROR behaviors, respectively.
     */
    int         jump_empty;
    int         jump_error;
 
    /*
     * Address of the step to coerce the result value of jsonpath evaluation
     * to the RETURNING type.  -1 if no coercion if JsonExpr.use_io_coercion
     * is true.
     */
    int         jump_eval_coercion;
 
    /*
     * Address to jump to when skipping all the steps after performing
     * ExecEvalJsonExprPath() so as to return whatever the JsonPath* function
     * returned as is, that is, in the cases where there's no error and no
     * coercion is necessary.
     */
    int         jump_end;
 
    /*
     * RETURNING type input function invocation info when
     * JsonExpr.use_io_coercion is true.
     */
    FunctionCallInfo input_fcinfo;
 
    /*
     * For error-safe evaluation of coercions.  When the ON ERROR behavior is
     * not ERROR, a pointer to this is passed to ExecInitExprRec() when
     * initializing the coercion expressions or to ExecInitJsonCoercion().
     *
     * Reset for each evaluation of EEOP_JSONEXPR_PATH.
     */
    ErrorSaveContext escontext;
} JsonExprState;
 
 
/* ----------------------------------------------------------------
 *               Executor State Trees
 *
 * An executing query has a PlanState tree paralleling the Plan tree
 * that describes the plan.
 * ----------------------------------------------------------------
 */
 
/* ----------------
 *   ExecProcNodeMtd
 *
 * This is the method called by ExecProcNode to return the next tuple
 * from an executor node.  It returns NULL, or an empty TupleTableSlot,
 * if no more tuples are available.
 * ----------------
 */
typedef TupleTableSlot *(*ExecProcNodeMtd) (PlanState *pstate);
 
/* ----------------
 *      PlanState node
 *
 * We never actually instantiate any PlanState nodes; this is just the common
 * abstract superclass for all PlanState-type nodes.
 * ----------------
 */
typedef struct PlanState
{
    pg_node_attr(abstract)
 
    NodeTag     type;
 
    Plan       *plan;           /* associated Plan node */
 
    EState     *state;          /* at execution time, states of individual
                                 * nodes point to one EState for the whole
                                 * top-level plan */
 
    ExecProcNodeMtd ExecProcNode;   /* function to return next tuple */
    ExecProcNodeMtd ExecProcNodeReal;   /* actual function, if above is a
                                         * wrapper */
 
    Instrumentation *instrument;    /* Optional runtime stats for this node */
    WorkerInstrumentation *worker_instrument;   /* per-worker instrumentation */
 
    /* Per-worker JIT instrumentation */
    struct SharedJitInstrumentation *worker_jit_instrument;
 
    /*
     * Common structural data for all Plan types.  These links to subsidiary
     * state trees parallel links in the associated plan tree (except for the
     * subPlan list, which does not exist in the plan tree).
     */
    ExprState  *qual;           /* boolean qual condition */
    PlanState  *lefttree;       /* input plan tree(s) */
    PlanState  *righttree;
 
    List       *initPlan;       /* Init SubPlanState nodes (un-correlated expr
                                 * subselects) */
    List       *subPlan;        /* SubPlanState nodes in my expressions */
 
    /*
     * State for management of parameter-change-driven rescanning
     */
    Bitmapset  *chgParam;       /* set of IDs of changed Params */
 
    /*
     * Other run-time state needed by most if not all node types.
     */
    TupleDesc   ps_ResultTupleDesc; /* node's return type */
    TupleTableSlot *ps_ResultTupleSlot; /* slot for my result tuples */
    ExprContext *ps_ExprContext;    /* node's expression-evaluation context */
    ProjectionInfo *ps_ProjInfo;    /* info for doing tuple projection */
 
    bool        async_capable;  /* true if node is async-capable */
 
    /*
     * Scanslot's descriptor if known. This is a bit of a hack, but otherwise
     * it's hard for expression compilation to optimize based on the
     * descriptor, without encoding knowledge about all executor nodes.
     */
    TupleDesc   scandesc;
 
    /*
     * Define the slot types for inner, outer and scanslots for expression
     * contexts with this state as a parent.  If *opsset is set, then
     * *opsfixed indicates whether *ops is guaranteed to be the type of slot
     * used. That means that every slot in the corresponding
     * ExprContext.ecxt_*tuple will point to a slot of that type, while
     * evaluating the expression.  If *opsfixed is false, but *ops is set,
     * that indicates the most likely type of slot.
     *
     * The scan* fields are set by ExecInitScanTupleSlot(). If that's not
     * called, nodes can initialize the fields themselves.
     *
     * If outer/inneropsset is false, the information is inferred on-demand
     * using ExecGetResultSlotOps() on ->righttree/lefttree, using the
     * corresponding node's resultops* fields.
     *
     * The result* fields are automatically set when ExecInitResultSlot is
     * used (be it directly or when the slot is created by
     * ExecAssignScanProjectionInfo() /
     * ExecConditionalAssignProjectionInfo()).  If no projection is necessary
     * ExecConditionalAssignProjectionInfo() defaults those fields to the scan
     * operations.
     */
    const TupleTableSlotOps *scanops;
    const TupleTableSlotOps *outerops;
    const TupleTableSlotOps *innerops;
    const TupleTableSlotOps *resultops;
    bool        scanopsfixed;
    bool        outeropsfixed;
    bool        inneropsfixed;
    bool        resultopsfixed;
    bool        scanopsset;
    bool        outeropsset;
    bool        inneropsset;
    bool        resultopsset;
} PlanState;
 
/* ----------------
 *  these are defined to avoid confusion problems with "left"
 *  and "right" and "inner" and "outer".  The convention is that
 *  the "left" plan is the "outer" plan and the "right" plan is
 *  the inner plan, but these make the code more readable.
 * ----------------
 */
#define innerPlanState(node)        (((PlanState *)(node))->righttree)
#define outerPlanState(node)        (((PlanState *)(node))->lefttree)
 
/* Macros for inline access to certain instrumentation counters */
#define InstrCountTuples2(node, delta) \
    do { \
        if (((PlanState *)(node))->instrument) \
            ((PlanState *)(node))->instrument->ntuples2 += (delta); \
    } while (0)
#define InstrCountFiltered1(node, delta) \
    do { \
        if (((PlanState *)(node))->instrument) \
            ((PlanState *)(node))->instrument->nfiltered1 += (delta); \
    } while(0)
#define InstrCountFiltered2(node, delta) \
    do { \
        if (((PlanState *)(node))->instrument) \
            ((PlanState *)(node))->instrument->nfiltered2 += (delta); \
    } while(0)
 
/*
 * EPQState is state for executing an EvalPlanQual recheck on a candidate
 * tuples e.g. in ModifyTable or LockRows.
 *
 * To execute EPQ a separate EState is created (stored in ->recheckestate),
 * which shares some resources, like the rangetable, with the main query's
 * EState (stored in ->parentestate). The (sub-)tree of the plan that needs to
 * be rechecked (in ->plan), is separately initialized (into
 * ->recheckplanstate), but shares plan nodes with the corresponding nodes in
 * the main query. The scan nodes in that separate executor tree are changed
 * to return only the current tuple of interest for the respective
 * table. Those tuples are either provided by the caller (using
 * EvalPlanQualSlot), and/or found using the rowmark mechanism (non-locking
 * rowmarks by the EPQ machinery itself, locking ones by the caller).
 *
 * While the plan to be checked may be changed using EvalPlanQualSetPlan(),
 * all such plans need to share the same EState.
 */
typedef struct EPQState
{
    /* These are initialized by EvalPlanQualInit() and do not change later: */
    EState     *parentestate;   /* main query's EState */
    int         epqParam;       /* ID of Param to force scan node re-eval */
    List       *resultRelations;    /* integer list of RT indexes, or NIL */
 
    /*
     * relsubs_slot[scanrelid - 1] holds the EPQ test tuple to be returned by
     * the scan node for the scanrelid'th RT index, in place of performing an
     * actual table scan.  Callers should use EvalPlanQualSlot() to fetch
     * these slots.
     */
    List       *tuple_table;    /* tuple table for relsubs_slot */
    TupleTableSlot **relsubs_slot;
 
    /*
     * Initialized by EvalPlanQualInit(), may be changed later with
     * EvalPlanQualSetPlan():
     */
 
    Plan       *plan;           /* plan tree to be executed */
    List       *arowMarks;      /* ExecAuxRowMarks (non-locking only) */
 
 
    /*
     * The original output tuple to be rechecked.  Set by
     * EvalPlanQualSetSlot(), before EvalPlanQualNext() or EvalPlanQual() may
     * be called.
     */
    TupleTableSlot *origslot;
 
 
    /* Initialized or reset by EvalPlanQualBegin(): */
 
    EState     *recheckestate;  /* EState for EPQ execution, see above */
 
    /*
     * Rowmarks that can be fetched on-demand using
     * EvalPlanQualFetchRowMark(), indexed by scanrelid - 1. Only non-locking
     * rowmarks.
     */
    ExecAuxRowMark **relsubs_rowmark;
 
    /*
     * relsubs_done[scanrelid - 1] is true if there is no EPQ tuple for this
     * target relation or it has already been fetched in the current scan of
     * this target relation within the current EvalPlanQual test.
     */
    bool       *relsubs_done;
 
    /*
     * relsubs_blocked[scanrelid - 1] is true if there is no EPQ tuple for
     * this target relation during the current EvalPlanQual test.  We keep
     * these flags set for all relids listed in resultRelations, but
     * transiently clear the one for the relation whose tuple is actually
     * passed to EvalPlanQual().
     */
    bool       *relsubs_blocked;
 
    PlanState  *recheckplanstate;   /* EPQ specific exec nodes, for ->plan */
} EPQState;
 
 
/* ----------------
 *   ResultState information
 * ----------------
 */
typedef struct ResultState
{
    PlanState   ps;             /* its first field is NodeTag */
    ExprState  *resconstantqual;
    bool        rs_done;        /* are we done? */
    bool        rs_checkqual;   /* do we need to check the qual? */
} ResultState;
 
/* ----------------
 *   ProjectSetState information
 *
 * Note: at least one of the "elems" will be a SetExprState; the rest are
 * regular ExprStates.
 * ----------------
 */
typedef struct ProjectSetState
{
    PlanState   ps;             /* its first field is NodeTag */
    Node      **elems;          /* array of expression states */
    ExprDoneCond *elemdone;     /* array of per-SRF is-done states */
    int         nelems;         /* length of elemdone[] array */
    bool        pending_srf_tuples; /* still evaluating srfs in tlist? */
    MemoryContext argcontext;   /* context for SRF arguments */
} ProjectSetState;
 
 
/* flags for mt_merge_subcommands */
#define MERGE_INSERT    0x01
#define MERGE_UPDATE    0x02
#define MERGE_DELETE    0x04
 
/* ----------------
 *   ModifyTableState information
 * ----------------
 */
typedef struct ModifyTableState
{
    PlanState   ps;             /* its first field is NodeTag */
    CmdType     operation;      /* INSERT, UPDATE, DELETE, or MERGE */
    bool        canSetTag;      /* do we set the command tag/es_processed? */
    bool        mt_done;        /* are we done? */
    int         mt_nrels;       /* number of entries in resultRelInfo[] */
    ResultRelInfo *resultRelInfo;   /* info about target relation(s) */
 
    /*
     * Target relation mentioned in the original statement, used to fire
     * statement-level triggers and as the root for tuple routing.  (This
     * might point to one of the resultRelInfo[] entries, but it can also be a
     * distinct struct.)
     */
    ResultRelInfo *rootResultRelInfo;
 
    EPQState    mt_epqstate;    /* for evaluating EvalPlanQual rechecks */
    bool        fireBSTriggers; /* do we need to fire stmt triggers? */
 
    /*
     * These fields are used for inherited UPDATE and DELETE, to track which
     * target relation a given tuple is from.  If there are a lot of target
     * relations, we use a hash table to translate table OIDs to
     * resultRelInfo[] indexes; otherwise mt_resultOidHash is NULL.
     */
    int         mt_resultOidAttno;  /* resno of "tableoid" junk attr */
    Oid         mt_lastResultOid;   /* last-seen value of tableoid */
    int         mt_lastResultIndex; /* corresponding index in resultRelInfo[] */
    HTAB       *mt_resultOidHash;   /* optional hash table to speed lookups */
 
    /*
     * Slot for storing tuples in the root partitioned table's rowtype during
     * an UPDATE of a partitioned table.
     */
    TupleTableSlot *mt_root_tuple_slot;
 
    /* Tuple-routing support info */
    struct PartitionTupleRouting *mt_partition_tuple_routing;
 
    /* controls transition table population for specified operation */
    struct TransitionCaptureState *mt_transition_capture;
 
    /* controls transition table population for INSERT...ON CONFLICT UPDATE */
    struct TransitionCaptureState *mt_oc_transition_capture;
 
    /* Flags showing which subcommands are present INS/UPD/DEL/DO NOTHING */
    int         mt_merge_subcommands;
 
    /* For MERGE, the action currently being executed */
    MergeActionState *mt_merge_action;
 
    /*
     * For MERGE, if there is a pending NOT MATCHED [BY TARGET] action to be
     * performed, this will be the last tuple read from the subplan; otherwise
     * it will be NULL --- see the comments in ExecMerge().
     */
    TupleTableSlot *mt_merge_pending_not_matched;
 
    /* tuple counters for MERGE */
    double      mt_merge_inserted;
    double      mt_merge_updated;
    double      mt_merge_deleted;
 
    /*
     * Lists of valid updateColnosLists, mergeActionLists, and
     * mergeJoinConditions.  These contain only entries for unpruned
     * relations, filtered from the corresponding lists in ModifyTable.
     */
    List       *mt_updateColnosLists;
    List       *mt_mergeActionLists;
    List       *mt_mergeJoinConditions;
} ModifyTableState;
 
/* ----------------
 *   AppendState information
 *
 *      nplans              how many plans are in the array
 *      whichplan           which synchronous plan is being executed (0 .. n-1)
 *                          or a special negative value. See nodeAppend.c.
 *      prune_state         details required to allow partitions to be
 *                          eliminated from the scan, or NULL if not possible.
 *      valid_subplans      for runtime pruning, valid synchronous appendplans
 *                          indexes to scan.
 * ----------------
 */
 
struct AppendState;
typedef struct AppendState AppendState;
struct ParallelAppendState;
typedef struct ParallelAppendState ParallelAppendState;
struct PartitionPruneState;
 
struct AppendState
{
    PlanState   ps;             /* its first field is NodeTag */
    PlanState **appendplans;    /* array of PlanStates for my inputs */
    int         as_nplans;
    int         as_whichplan;
    bool        as_begun;       /* false means need to initialize */
    Bitmapset  *as_asyncplans;  /* asynchronous plans indexes */
    int         as_nasyncplans; /* # of asynchronous plans */
    AsyncRequest **as_asyncrequests;    /* array of AsyncRequests */
    TupleTableSlot **as_asyncresults;   /* unreturned results of async plans */
    int         as_nasyncresults;   /* # of valid entries in as_asyncresults */
    bool        as_syncdone;    /* true if all synchronous plans done in
                                 * asynchronous mode, else false */
    int         as_nasyncremain;    /* # of remaining asynchronous plans */
    Bitmapset  *as_needrequest; /* asynchronous plans needing a new request */
    struct WaitEventSet *as_eventset;   /* WaitEventSet used to configure file
                                         * descriptor wait events */
    int         as_first_partial_plan;  /* Index of 'appendplans' containing
                                         * the first partial plan */
    ParallelAppendState *as_pstate; /* parallel coordination info */
    Size        pstate_len;     /* size of parallel coordination info */
    struct PartitionPruneState *as_prune_state;
    bool        as_valid_subplans_identified;   /* is as_valid_subplans valid? */
    Bitmapset  *as_valid_subplans;
    Bitmapset  *as_valid_asyncplans;    /* valid asynchronous plans indexes */
    bool        (*choose_next_subplan) (AppendState *);
};
 
/* ----------------
 *   MergeAppendState information
 *
 *      nplans          how many plans are in the array
 *      nkeys           number of sort key columns
 *      sortkeys        sort keys in SortSupport representation
 *      slots           current output tuple of each subplan
 *      heap            heap of active tuples
 *      initialized     true if we have fetched first tuple from each subplan
 *      prune_state     details required to allow partitions to be
 *                      eliminated from the scan, or NULL if not possible.
 *      valid_subplans  for runtime pruning, valid mergeplans indexes to
 *                      scan.
 * ----------------
 */
typedef struct MergeAppendState
{
    PlanState   ps;             /* its first field is NodeTag */
    PlanState **mergeplans;     /* array of PlanStates for my inputs */
    int         ms_nplans;
    int         ms_nkeys;
    SortSupport ms_sortkeys;    /* array of length ms_nkeys */
    TupleTableSlot **ms_slots;  /* array of length ms_nplans */
    struct binaryheap *ms_heap; /* binary heap of slot indices */
    bool        ms_initialized; /* are subplans started? */
    struct PartitionPruneState *ms_prune_state;
    Bitmapset  *ms_valid_subplans;
} MergeAppendState;
 
/* ----------------
 *   RecursiveUnionState information
 *
 *      RecursiveUnionState is used for performing a recursive union.
 *
 *      recursing           T when we're done scanning the non-recursive term
 *      intermediate_empty  T if intermediate_table is currently empty
 *      working_table       working table (to be scanned by recursive term)
 *      intermediate_table  current recursive output (next generation of WT)
 * ----------------
 */
typedef struct RecursiveUnionState
{
    PlanState   ps;             /* its first field is NodeTag */
    bool        recursing;
    bool        intermediate_empty;
    Tuplestorestate *working_table;
    Tuplestorestate *intermediate_table;
    /* Remaining fields are unused in UNION ALL case */
    Oid        *eqfuncoids;     /* per-grouping-field equality fns */
    FmgrInfo   *hashfunctions;  /* per-grouping-field hash fns */
    MemoryContext tempContext;  /* short-term context for comparisons */
    TupleHashTable hashtable;   /* hash table for tuples already seen */
    MemoryContext tuplesContext;    /* context containing hash table's tuples */
} RecursiveUnionState;
 
/* ----------------
 *   BitmapAndState information
 * ----------------
 */
typedef struct BitmapAndState
{
    PlanState   ps;             /* its first field is NodeTag */
    PlanState **bitmapplans;    /* array of PlanStates for my inputs */
    int         nplans;         /* number of input plans */
} BitmapAndState;
 
/* ----------------
 *   BitmapOrState information
 * ----------------
 */
typedef struct BitmapOrState
{
    PlanState   ps;             /* its first field is NodeTag */
    PlanState **bitmapplans;    /* array of PlanStates for my inputs */
    int         nplans;         /* number of input plans */
} BitmapOrState;
 
/* ----------------------------------------------------------------
 *               Scan State Information
 * ----------------------------------------------------------------
 */
 
/* ----------------
 *   ScanState information
 *
 *      ScanState extends PlanState for node types that represent
 *      scans of an underlying relation.  It can also be used for nodes
 *      that scan the output of an underlying plan node --- in that case,
 *      only ScanTupleSlot is actually useful, and it refers to the tuple
 *      retrieved from the subplan.
 *
 *      currentRelation    relation being scanned (NULL if none)
 *      currentScanDesc    current scan descriptor for scan (NULL if none)
 *      ScanTupleSlot      pointer to slot in tuple table holding scan tuple
 * ----------------
 */
typedef struct ScanState
{
    PlanState   ps;             /* its first field is NodeTag */
    Relation    ss_currentRelation;
    struct TableScanDescData *ss_currentScanDesc;
    TupleTableSlot *ss_ScanTupleSlot;
} ScanState;
 
/* ----------------
 *   SeqScanState information
 * ----------------
 */
typedef struct SeqScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    Size        pscan_len;      /* size of parallel heap scan descriptor */
} SeqScanState;
 
/* ----------------
 *   SampleScanState information
 * ----------------
 */
typedef struct SampleScanState
{
    ScanState   ss;
    List       *args;           /* expr states for TABLESAMPLE params */
    ExprState  *repeatable;     /* expr state for REPEATABLE expr */
    /* use struct pointer to avoid including tsmapi.h here */
    struct TsmRoutine *tsmroutine;  /* descriptor for tablesample method */
    void       *tsm_state;      /* tablesample method can keep state here */
    bool        use_bulkread;   /* use bulkread buffer access strategy? */
    bool        use_pagemode;   /* use page-at-a-time visibility checking? */
    bool        begun;          /* false means need to call BeginSampleScan */
    uint32      seed;           /* random seed */
    int64       donetuples;     /* number of tuples already returned */
    bool        haveblock;      /* has a block for sampling been determined */
    bool        done;           /* exhausted all tuples? */
} SampleScanState;
 
/*
 * These structs store information about index quals that don't have simple
 * constant right-hand sides.  See comments for ExecIndexBuildScanKeys()
 * for discussion.
 */
typedef struct
{
    ScanKeyData *scan_key;      /* scankey to put value into */
    ExprState  *key_expr;       /* expr to evaluate to get value */
    bool        key_toastable;  /* is expr's result a toastable datatype? */
} IndexRuntimeKeyInfo;
 
typedef struct
{
    ScanKeyData *scan_key;      /* scankey to put value into */
    ExprState  *array_expr;     /* expr to evaluate to get array value */
    int         next_elem;      /* next array element to use */
    int         num_elems;      /* number of elems in current array value */
    Datum      *elem_values;    /* array of num_elems Datums */
    bool       *elem_nulls;     /* array of num_elems is-null flags */
} IndexArrayKeyInfo;
 
/* ----------------
 *   IndexScanState information
 *
 *      indexqualorig      execution state for indexqualorig expressions
 *      indexorderbyorig   execution state for indexorderbyorig expressions
 *      ScanKeys           Skey structures for index quals
 *      NumScanKeys        number of ScanKeys
 *      OrderByKeys        Skey structures for index ordering operators
 *      NumOrderByKeys     number of OrderByKeys
 *      RuntimeKeys        info about Skeys that must be evaluated at runtime
 *      NumRuntimeKeys     number of RuntimeKeys
 *      RuntimeKeysReady   true if runtime Skeys have been computed
 *      RuntimeContext     expr context for evaling runtime Skeys
 *      RelationDesc       index relation descriptor
 *      ScanDesc           index scan descriptor
 *      Instrument         local index scan instrumentation
 *      SharedInfo         parallel worker instrumentation (no leader entry)
 *
 *      ReorderQueue       tuples that need reordering due to re-check
 *      ReachedEnd         have we fetched all tuples from index already?
 *      OrderByValues      values of ORDER BY exprs of last fetched tuple
 *      OrderByNulls       null flags for OrderByValues
 *      SortSupport        for reordering ORDER BY exprs
 *      OrderByTypByVals   is the datatype of order by expression pass-by-value?
 *      OrderByTypLens     typlens of the datatypes of order by expressions
 *      PscanLen           size of parallel index scan descriptor
 * ----------------
 */
typedef struct IndexScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    ExprState  *indexqualorig;
    List       *indexorderbyorig;
    ScanKeyData *iss_ScanKeys;
    int         iss_NumScanKeys;
    ScanKeyData *iss_OrderByKeys;
    int         iss_NumOrderByKeys;
    IndexRuntimeKeyInfo *iss_RuntimeKeys;
    int         iss_NumRuntimeKeys;
    bool        iss_RuntimeKeysReady;
    ExprContext *iss_RuntimeContext;
    Relation    iss_RelationDesc;
    struct IndexScanDescData *iss_ScanDesc;
    IndexScanInstrumentation iss_Instrument;
    SharedIndexScanInstrumentation *iss_SharedInfo;
 
    /* These are needed for re-checking ORDER BY expr ordering */
    pairingheap *iss_ReorderQueue;
    bool        iss_ReachedEnd;
    Datum      *iss_OrderByValues;
    bool       *iss_OrderByNulls;
    SortSupport iss_SortSupport;
    bool       *iss_OrderByTypByVals;
    int16      *iss_OrderByTypLens;
    Size        iss_PscanLen;
} IndexScanState;
 
/* ----------------
 *   IndexOnlyScanState information
 *
 *      recheckqual        execution state for recheckqual expressions
 *      ScanKeys           Skey structures for index quals
 *      NumScanKeys        number of ScanKeys
 *      OrderByKeys        Skey structures for index ordering operators
 *      NumOrderByKeys     number of OrderByKeys
 *      RuntimeKeys        info about Skeys that must be evaluated at runtime
 *      NumRuntimeKeys     number of RuntimeKeys
 *      RuntimeKeysReady   true if runtime Skeys have been computed
 *      RuntimeContext     expr context for evaling runtime Skeys
 *      RelationDesc       index relation descriptor
 *      ScanDesc           index scan descriptor
 *      Instrument         local index scan instrumentation
 *      SharedInfo         parallel worker instrumentation (no leader entry)
 *      TableSlot          slot for holding tuples fetched from the table
 *      VMBuffer           buffer in use for visibility map testing, if any
 *      PscanLen           size of parallel index-only scan descriptor
 *      NameCStringAttNums attnums of name typed columns to pad to NAMEDATALEN
 *      NameCStringCount   number of elements in the NameCStringAttNums array
 * ----------------
 */
typedef struct IndexOnlyScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    ExprState  *recheckqual;
    ScanKeyData *ioss_ScanKeys;
    int         ioss_NumScanKeys;
    ScanKeyData *ioss_OrderByKeys;
    int         ioss_NumOrderByKeys;
    IndexRuntimeKeyInfo *ioss_RuntimeKeys;
    int         ioss_NumRuntimeKeys;
    bool        ioss_RuntimeKeysReady;
    ExprContext *ioss_RuntimeContext;
    Relation    ioss_RelationDesc;
    struct IndexScanDescData *ioss_ScanDesc;
    IndexScanInstrumentation ioss_Instrument;
    SharedIndexScanInstrumentation *ioss_SharedInfo;
    TupleTableSlot *ioss_TableSlot;
    Buffer      ioss_VMBuffer;
    Size        ioss_PscanLen;
    AttrNumber *ioss_NameCStringAttNums;
    int         ioss_NameCStringCount;
} IndexOnlyScanState;
 
/* ----------------
 *   BitmapIndexScanState information
 *
 *      result             bitmap to return output into, or NULL
 *      ScanKeys           Skey structures for index quals
 *      NumScanKeys        number of ScanKeys
 *      RuntimeKeys        info about Skeys that must be evaluated at runtime
 *      NumRuntimeKeys     number of RuntimeKeys
 *      ArrayKeys          info about Skeys that come from ScalarArrayOpExprs
 *      NumArrayKeys       number of ArrayKeys
 *      RuntimeKeysReady   true if runtime Skeys have been computed
 *      RuntimeContext     expr context for evaling runtime Skeys
 *      RelationDesc       index relation descriptor
 *      ScanDesc           index scan descriptor
 *      Instrument         local index scan instrumentation
 *      SharedInfo         parallel worker instrumentation (no leader entry)
 * ----------------
 */
typedef struct BitmapIndexScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    TIDBitmap  *biss_result;
    ScanKeyData *biss_ScanKeys;
    int         biss_NumScanKeys;
    IndexRuntimeKeyInfo *biss_RuntimeKeys;
    int         biss_NumRuntimeKeys;
    IndexArrayKeyInfo *biss_ArrayKeys;
    int         biss_NumArrayKeys;
    bool        biss_RuntimeKeysReady;
    ExprContext *biss_RuntimeContext;
    Relation    biss_RelationDesc;
    struct IndexScanDescData *biss_ScanDesc;
    IndexScanInstrumentation biss_Instrument;
    SharedIndexScanInstrumentation *biss_SharedInfo;
} BitmapIndexScanState;
 
/* ----------------
 *   SharedBitmapState information
 *
 *      BM_INITIAL      TIDBitmap creation is not yet started, so first worker
 *                      to see this state will set the state to BM_INPROGRESS
 *                      and that process will be responsible for creating
 *                      TIDBitmap.
 *      BM_INPROGRESS   TIDBitmap creation is in progress; workers need to
 *                      sleep until it's finished.
 *      BM_FINISHED     TIDBitmap creation is done, so now all workers can
 *                      proceed to iterate over TIDBitmap.
 * ----------------
 */
typedef enum
{
    BM_INITIAL,
    BM_INPROGRESS,
    BM_FINISHED,
} SharedBitmapState;
 
/* ----------------
 *   ParallelBitmapHeapState information
 *      tbmiterator             iterator for scanning current pages
 *      mutex                   mutual exclusion for state
 *      state                   current state of the TIDBitmap
 *      cv                      conditional wait variable
 * ----------------
 */
typedef struct ParallelBitmapHeapState
{
    dsa_pointer tbmiterator;
    slock_t     mutex;
    SharedBitmapState state;
    ConditionVariable cv;
} ParallelBitmapHeapState;
 
/* ----------------
 *   BitmapHeapScanState information
 *
 *      bitmapqualorig     execution state for bitmapqualorig expressions
 *      tbm                bitmap obtained from child index scan(s)
 *      stats              execution statistics
 *      initialized        is node is ready to iterate
 *      pstate             shared state for parallel bitmap scan
 *      sinstrument        statistics for parallel workers
 *      recheck            do current page's tuples need recheck
 * ----------------
 */
typedef struct BitmapHeapScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    ExprState  *bitmapqualorig;
    TIDBitmap  *tbm;
    BitmapHeapScanInstrumentation stats;
    bool        initialized;
    ParallelBitmapHeapState *pstate;
    SharedBitmapHeapInstrumentation *sinstrument;
    bool        recheck;
} BitmapHeapScanState;
 
/* ----------------
 *   TidScanState information
 *
 *      tidexprs       list of TidExpr structs (see nodeTidscan.c)
 *      isCurrentOf    scan has a CurrentOfExpr qual
 *      NumTids        number of tids in this scan
 *      TidPtr         index of currently fetched tid
 *      TidList        evaluated item pointers (array of size NumTids)
 * ----------------
 */
typedef struct TidScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    List       *tss_tidexprs;
    bool        tss_isCurrentOf;
    int         tss_NumTids;
    int         tss_TidPtr;
    ItemPointerData *tss_TidList;
} TidScanState;
 
/* ----------------
 *   TidRangeScanState information
 *
 *      trss_tidexprs       list of TidOpExpr structs (see nodeTidrangescan.c)
 *      trss_mintid         the lowest TID in the scan range
 *      trss_maxtid         the highest TID in the scan range
 *      trss_inScan         is a scan currently in progress?
 *      trss_pscanlen       size of parallel heap scan descriptor
 * ----------------
 */
typedef struct TidRangeScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    List       *trss_tidexprs;
    ItemPointerData trss_mintid;
    ItemPointerData trss_maxtid;
    bool        trss_inScan;
    Size        trss_pscanlen;
} TidRangeScanState;
 
/* ----------------
 *   SubqueryScanState information
 *
 *      SubqueryScanState is used for scanning a sub-query in the range table.
 *      ScanTupleSlot references the current output tuple of the sub-query.
 * ----------------
 */
typedef struct SubqueryScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    PlanState  *subplan;
} SubqueryScanState;
 
/* ----------------
 *   FunctionScanState information
 *
 *      Function nodes are used to scan the results of a
 *      function appearing in FROM (typically a function returning set).
 *
 *      eflags              node's capability flags
 *      ordinality          is this scan WITH ORDINALITY?
 *      simple              true if we have 1 function and no ordinality
 *      ordinal             current ordinal column value
 *      nfuncs              number of functions being executed
 *      funcstates          per-function execution states (private in
 *                          nodeFunctionscan.c)
 *      argcontext          memory context to evaluate function arguments in
 * ----------------
 */
struct FunctionScanPerFuncState;
 
typedef struct FunctionScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    int         eflags;
    bool        ordinality;
    bool        simple;
    int64       ordinal;
    int         nfuncs;
    struct FunctionScanPerFuncState *funcstates;    /* array of length nfuncs */
    MemoryContext argcontext;
} FunctionScanState;
 
/* ----------------
 *   ValuesScanState information
 *
 *      ValuesScan nodes are used to scan the results of a VALUES list
 *
 *      rowcontext          per-expression-list context
 *      exprlists           array of expression lists being evaluated
 *      exprstatelists      array of expression state lists, for SubPlans only
 *      array_len           size of above arrays
 *      curr_idx            current array index (0-based)
 *
 *  Note: ss.ps.ps_ExprContext is used to evaluate any qual or projection
 *  expressions attached to the node.  We create a second ExprContext,
 *  rowcontext, in which to build the executor expression state for each
 *  Values sublist.  Resetting this context lets us get rid of expression
 *  state for each row, avoiding major memory leakage over a long values list.
 *  However, that doesn't work for sublists containing SubPlans, because a
 *  SubPlan has to be connected up to the outer plan tree to work properly.
 *  Therefore, for only those sublists containing SubPlans, we do expression
 *  state construction at executor start, and store those pointers in
 *  exprstatelists[].  NULL entries in that array correspond to simple
 *  subexpressions that are handled as described above.
 * ----------------
 */
typedef struct ValuesScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    ExprContext *rowcontext;
    List      **exprlists;
    List      **exprstatelists;
    int         array_len;
    int         curr_idx;
} ValuesScanState;
 
/* ----------------
 *      TableFuncScanState node
 *
 * Used in table-expression functions like XMLTABLE.
 * ----------------
 */
typedef struct TableFuncScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    ExprState  *docexpr;        /* state for document expression */
    ExprState  *rowexpr;        /* state for row-generating expression */
    List       *colexprs;       /* state for column-generating expression */
    List       *coldefexprs;    /* state for column default expressions */
    List       *colvalexprs;    /* state for column value expressions */
    List       *passingvalexprs;    /* state for PASSING argument expressions */
    List       *ns_names;       /* same as TableFunc.ns_names */
    List       *ns_uris;        /* list of states of namespace URI exprs */
    Bitmapset  *notnulls;       /* nullability flag for each output column */
    void       *opaque;         /* table builder private space */
    const struct TableFuncRoutine *routine; /* table builder methods */
    FmgrInfo   *in_functions;   /* input function for each column */
    Oid        *typioparams;    /* typioparam for each column */
    int64       ordinal;        /* row number to be output next */
    MemoryContext perTableCxt;  /* per-table context */
    Tuplestorestate *tupstore;  /* output tuple store */
} TableFuncScanState;
 
/* ----------------
 *   CteScanState information
 *
 *      CteScan nodes are used to scan a CommonTableExpr query.
 *
 * Multiple CteScan nodes can read out from the same CTE query.  We use
 * a tuplestore to hold rows that have been read from the CTE query but
 * not yet consumed by all readers.
 * ----------------
 */
typedef struct CteScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    int         eflags;         /* capability flags to pass to tuplestore */
    int         readptr;        /* index of my tuplestore read pointer */
    PlanState  *cteplanstate;   /* PlanState for the CTE query itself */
    /* Link to the "leader" CteScanState (possibly this same node) */
    struct CteScanState *leader;
    /* The remaining fields are only valid in the "leader" CteScanState */
    Tuplestorestate *cte_table; /* rows already read from the CTE query */
    bool        eof_cte;        /* reached end of CTE query? */
} CteScanState;
 
/* ----------------
 *   NamedTuplestoreScanState information
 *
 *      NamedTuplestoreScan nodes are used to scan a Tuplestore created and
 *      named prior to execution of the query.  An example is a transition
 *      table for an AFTER trigger.
 *
 * Multiple NamedTuplestoreScan nodes can read out from the same Tuplestore.
 * ----------------
 */
typedef struct NamedTuplestoreScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    int         readptr;        /* index of my tuplestore read pointer */
    TupleDesc   tupdesc;        /* format of the tuples in the tuplestore */
    Tuplestorestate *relation;  /* the rows */
} NamedTuplestoreScanState;
 
/* ----------------
 *   WorkTableScanState information
 *
 *      WorkTableScan nodes are used to scan the work table created by
 *      a RecursiveUnion node.  We locate the RecursiveUnion node
 *      during executor startup.
 * ----------------
 */
typedef struct WorkTableScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    RecursiveUnionState *rustate;
} WorkTableScanState;
 
/* ----------------
 *   ForeignScanState information
 *
 *      ForeignScan nodes are used to scan foreign-data tables.
 * ----------------
 */
typedef struct ForeignScanState
{
    ScanState   ss;             /* its first field is NodeTag */
    ExprState  *fdw_recheck_quals;  /* original quals not in ss.ps.qual */
    Size        pscan_len;      /* size of parallel coordination information */
    ResultRelInfo *resultRelInfo;   /* result rel info, if UPDATE or DELETE */
    /* use struct pointer to avoid including fdwapi.h here */
    struct FdwRoutine *fdwroutine;
    void       *fdw_state;      /* foreign-data wrapper can keep state here */
} ForeignScanState;
 
/* ----------------
 *   CustomScanState information
 *
 *      CustomScan nodes are used to execute custom code within executor.
 *
 * Core code must avoid assuming that the CustomScanState is only as large as
 * the structure declared here; providers are allowed to make it the first
 * element in a larger structure, and typically would need to do so.  The
 * struct is actually allocated by the CreateCustomScanState method associated
 * with the plan node.  Any additional fields can be initialized there, or in
 * the BeginCustomScan method.
 * ----------------
 */
struct CustomExecMethods;
 
typedef struct CustomScanState
{
    ScanState   ss;
    uint32      flags;          /* mask of CUSTOMPATH_* flags, see
                                 * nodes/extensible.h */
    List       *custom_ps;      /* list of child PlanState nodes, if any */
    Size        pscan_len;      /* size of parallel coordination information */
    const struct CustomExecMethods *methods;
    const struct TupleTableSlotOps *slotOps;
} CustomScanState;
 
/* ----------------------------------------------------------------
 *               Join State Information
 * ----------------------------------------------------------------
 */
 
/* ----------------
 *   JoinState information
 *
 *      Superclass for state nodes of join plans.
 * ----------------
 */
typedef struct JoinState
{
    PlanState   ps;
    JoinType    jointype;
    bool        single_match;   /* True if we should skip to next outer tuple
                                 * after finding one inner match */
    ExprState  *joinqual;       /* JOIN quals (in addition to ps.qual) */
} JoinState;
 
/* ----------------
 *   NestLoopState information
 *
 *      NeedNewOuter       true if need new outer tuple on next call
 *      MatchedOuter       true if found a join match for current outer tuple
 *      NullInnerTupleSlot prepared null tuple for left outer joins
 * ----------------
 */
typedef struct NestLoopState
{
    JoinState   js;             /* its first field is NodeTag */
    bool        nl_NeedNewOuter;
    bool        nl_MatchedOuter;
    TupleTableSlot *nl_NullInnerTupleSlot;
} NestLoopState;
 
/* ----------------
 *   MergeJoinState information
 *
 *      NumClauses         number of mergejoinable join clauses
 *      Clauses            info for each mergejoinable clause
 *      JoinState          current state of ExecMergeJoin state machine
 *      SkipMarkRestore    true if we may skip Mark and Restore operations
 *      ExtraMarks         true to issue extra Mark operations on inner scan
 *      ConstFalseJoin     true if we have a constant-false joinqual
 *      FillOuter          true if should emit unjoined outer tuples anyway
 *      FillInner          true if should emit unjoined inner tuples anyway
 *      MatchedOuter       true if found a join match for current outer tuple
 *      MatchedInner       true if found a join match for current inner tuple
 *      OuterTupleSlot     slot in tuple table for cur outer tuple
 *      InnerTupleSlot     slot in tuple table for cur inner tuple
 *      MarkedTupleSlot    slot in tuple table for marked tuple
 *      NullOuterTupleSlot prepared null tuple for right outer joins
 *      NullInnerTupleSlot prepared null tuple for left outer joins
 *      OuterEContext      workspace for computing outer tuple's join values
 *      InnerEContext      workspace for computing inner tuple's join values
 * ----------------
 */
/* private in nodeMergejoin.c: */
typedef struct MergeJoinClauseData *MergeJoinClause;
 
typedef struct MergeJoinState
{
    JoinState   js;             /* its first field is NodeTag */
    int         mj_NumClauses;
    MergeJoinClause mj_Clauses; /* array of length mj_NumClauses */
    int         mj_JoinState;
    bool        mj_SkipMarkRestore;
    bool        mj_ExtraMarks;
    bool        mj_ConstFalseJoin;
    bool        mj_FillOuter;
    bool        mj_FillInner;
    bool        mj_MatchedOuter;
    bool        mj_MatchedInner;
    TupleTableSlot *mj_OuterTupleSlot;
    TupleTableSlot *mj_InnerTupleSlot;
    TupleTableSlot *mj_MarkedTupleSlot;
    TupleTableSlot *mj_NullOuterTupleSlot;
    TupleTableSlot *mj_NullInnerTupleSlot;
    ExprContext *mj_OuterEContext;
    ExprContext *mj_InnerEContext;
} MergeJoinState;
 
/* ----------------
 *   HashJoinState information
 *
 *      hashclauses             original form of the hashjoin condition
 *      hj_OuterHash            ExprState for hashing outer keys
 *      hj_HashTable            hash table for the hashjoin
 *                              (NULL if table not built yet)
 *      hj_CurHashValue         hash value for current outer tuple
 *      hj_CurBucketNo          regular bucket# for current outer tuple
 *      hj_CurSkewBucketNo      skew bucket# for current outer tuple
 *      hj_CurTuple             last inner tuple matched to current outer
 *                              tuple, or NULL if starting search
 *                              (hj_CurXXX variables are undefined if
 *                              OuterTupleSlot is empty!)
 *      hj_OuterTupleSlot       tuple slot for outer tuples
 *      hj_HashTupleSlot        tuple slot for inner (hashed) tuples
 *      hj_NullOuterTupleSlot   prepared null tuple for right/right-anti/full
 *                              outer joins
 *      hj_NullInnerTupleSlot   prepared null tuple for left/full outer joins
 *      hj_FirstOuterTupleSlot  first tuple retrieved from outer plan
 *      hj_JoinState            current state of ExecHashJoin state machine
 *      hj_MatchedOuter         true if found a join match for current outer
 *      hj_OuterNotEmpty        true if outer relation known not empty
 * ----------------
 */
 
/* these structs are defined in executor/hashjoin.h: */
typedef struct HashJoinTupleData *HashJoinTuple;
typedef struct HashJoinTableData *HashJoinTable;
 
typedef struct HashJoinState
{
    JoinState   js;             /* its first field is NodeTag */
    ExprState  *hashclauses;
    ExprState  *hj_OuterHash;
    HashJoinTable hj_HashTable;
    uint32      hj_CurHashValue;
    int         hj_CurBucketNo;
    int         hj_CurSkewBucketNo;
    HashJoinTuple hj_CurTuple;
    TupleTableSlot *hj_OuterTupleSlot;
    TupleTableSlot *hj_HashTupleSlot;
    TupleTableSlot *hj_NullOuterTupleSlot;
    TupleTableSlot *hj_NullInnerTupleSlot;
    TupleTableSlot *hj_FirstOuterTupleSlot;
    int         hj_JoinState;
    bool        hj_MatchedOuter;
    bool        hj_OuterNotEmpty;
} HashJoinState;
 
 
/* ----------------------------------------------------------------
 *               Materialization State Information
 * ----------------------------------------------------------------
 */
 
/* ----------------
 *   MaterialState information
 *
 *      materialize nodes are used to materialize the results
 *      of a subplan into a temporary file.
 *
 *      ss.ss_ScanTupleSlot refers to output of underlying plan.
 * ----------------
 */
typedef struct MaterialState
{
    ScanState   ss;             /* its first field is NodeTag */
    int         eflags;         /* capability flags to pass to tuplestore */
    bool        eof_underlying; /* reached end of underlying plan? */
    Tuplestorestate *tuplestorestate;
} MaterialState;
 
struct MemoizeEntry;
struct MemoizeTuple;
struct MemoizeKey;
 
/* ----------------
 *   MemoizeState information
 *
 *      memoize nodes are used to cache recent and commonly seen results from
 *      a parameterized scan.
 * ----------------
 */
typedef struct MemoizeState
{
    ScanState   ss;             /* its first field is NodeTag */
    int         mstatus;        /* value of ExecMemoize state machine */
    int         nkeys;          /* number of cache keys */
    struct memoize_hash *hashtable; /* hash table for cache entries */
    TupleDesc   hashkeydesc;    /* tuple descriptor for cache keys */
    TupleTableSlot *tableslot;  /* min tuple slot for existing cache entries */
    TupleTableSlot *probeslot;  /* virtual slot used for hash lookups */
    ExprState  *cache_eq_expr;  /* Compare exec params to hash key */
    ExprState **param_exprs;    /* exprs containing the parameters to this
                                 * node */
    FmgrInfo   *hashfunctions;  /* lookup data for hash funcs nkeys in size */
    Oid        *collations;     /* collation for comparisons nkeys in size */
    uint64      mem_used;       /* bytes of memory used by cache */
    uint64      mem_limit;      /* memory limit in bytes for the cache */
    MemoryContext tableContext; /* memory context to store cache data */
    dlist_head  lru_list;       /* least recently used entry list */
    struct MemoizeTuple *last_tuple;    /* Used to point to the last tuple
                                         * returned during a cache hit and the
                                         * tuple we last stored when
                                         * populating the cache. */
    struct MemoizeEntry *entry; /* the entry that 'last_tuple' belongs to or
                                 * NULL if 'last_tuple' is NULL. */
    bool        singlerow;      /* true if the cache entry is to be marked as
                                 * complete after caching the first tuple. */
    bool        binary_mode;    /* true when cache key should be compared bit
                                 * by bit, false when using hash equality ops */
    MemoizeInstrumentation stats;   /* execution statistics */
    SharedMemoizeInfo *shared_info; /* statistics for parallel workers */
    Bitmapset  *keyparamids;    /* Param->paramids of expressions belonging to
                                 * param_exprs */
} MemoizeState;
 
/* ----------------
 *   When performing sorting by multiple keys, it's possible that the input
 *   dataset is already sorted on a prefix of those keys. We call these
 *   "presorted keys".
 *   PresortedKeyData represents information about one such key.
 * ----------------
 */
typedef struct PresortedKeyData
{
    FmgrInfo    flinfo;         /* comparison function info */
    FunctionCallInfo fcinfo;    /* comparison function call info */
    OffsetNumber attno;         /* attribute number in tuple */
} PresortedKeyData;
 
/* ----------------
 *   SortState information
 * ----------------
 */
typedef struct SortState
{
    ScanState   ss;             /* its first field is NodeTag */
    bool        randomAccess;   /* need random access to sort output? */
    bool        bounded;        /* is the result set bounded? */
    int64       bound;          /* if bounded, how many tuples are needed */
    bool        sort_Done;      /* sort completed yet? */
    bool        bounded_Done;   /* value of bounded we did the sort with */
    int64       bound_Done;     /* value of bound we did the sort with */
    void       *tuplesortstate; /* private state of tuplesort.c */
    bool        am_worker;      /* are we a worker? */
    bool        datumSort;      /* Datum sort instead of tuple sort? */
    SharedSortInfo *shared_info;    /* one entry per worker */
} SortState;
 
typedef enum
{
    INCSORT_LOADFULLSORT,
    INCSORT_LOADPREFIXSORT,
    INCSORT_READFULLSORT,
    INCSORT_READPREFIXSORT,
} IncrementalSortExecutionStatus;
 
typedef struct IncrementalSortState
{
    ScanState   ss;             /* its first field is NodeTag */
    bool        bounded;        /* is the result set bounded? */
    int64       bound;          /* if bounded, how many tuples are needed */
    bool        outerNodeDone;  /* finished fetching tuples from outer node */
    int64       bound_Done;     /* value of bound we did the sort with */
    IncrementalSortExecutionStatus execution_status;
    int64       n_fullsort_remaining;
    Tuplesortstate *fullsort_state; /* private state of tuplesort.c */
    Tuplesortstate *prefixsort_state;   /* private state of tuplesort.c */
    /* the keys by which the input path is already sorted */
    PresortedKeyData *presorted_keys;
 
    IncrementalSortInfo incsort_info;
 
    /* slot for pivot tuple defining values of presorted keys within group */
    TupleTableSlot *group_pivot;
    TupleTableSlot *transfer_tuple;
    bool        am_worker;      /* are we a worker? */
    SharedIncrementalSortInfo *shared_info; /* one entry per worker */
} IncrementalSortState;
 
/* ---------------------
 *  GroupState information
 * ---------------------
 */
typedef struct GroupState
{
    ScanState   ss;             /* its first field is NodeTag */
    ExprState  *eqfunction;     /* equality function */
    bool        grp_done;       /* indicates completion of Group scan */
} GroupState;
 
/* ---------------------
 *  AggState information
 *
 *  ss.ss_ScanTupleSlot refers to output of underlying plan.
 *
 *  Note: ss.ps.ps_ExprContext contains ecxt_aggvalues and
 *  ecxt_aggnulls arrays, which hold the computed agg values for the current
 *  input group during evaluation of an Agg node's output tuple(s).  We
 *  create a second ExprContext, tmpcontext, in which to evaluate input
 *  expressions and run the aggregate transition functions.
 * ---------------------
 */
/* these structs are private in nodeAgg.c: */
typedef struct AggStatePerAggData *AggStatePerAgg;
typedef struct AggStatePerTransData *AggStatePerTrans;
typedef struct AggStatePerGroupData *AggStatePerGroup;
typedef struct AggStatePerPhaseData *AggStatePerPhase;
typedef struct AggStatePerHashData *AggStatePerHash;
 
typedef struct AggState
{
    ScanState   ss;             /* its first field is NodeTag */
    List       *aggs;           /* all Aggref nodes in targetlist & quals */
    int         numaggs;        /* length of list (could be zero!) */
    int         numtrans;       /* number of pertrans items */
    AggStrategy aggstrategy;    /* strategy mode */
    AggSplit    aggsplit;       /* agg-splitting mode, see nodes.h */
    AggStatePerPhase phase;     /* pointer to current phase data */
    int         numphases;      /* number of phases (including phase 0) */
    int         current_phase;  /* current phase number */
    AggStatePerAgg peragg;      /* per-Aggref information */
    AggStatePerTrans pertrans;  /* per-Trans state information */
    ExprContext *hashcontext;   /* econtexts for long-lived data (hashtable) */
    ExprContext **aggcontexts;  /* econtexts for long-lived data (per GS) */
    ExprContext *tmpcontext;    /* econtext for input expressions */
#define FIELDNO_AGGSTATE_CURAGGCONTEXT 14
    ExprContext *curaggcontext; /* currently active aggcontext */
    AggStatePerAgg curperagg;   /* currently active aggregate, if any */
#define FIELDNO_AGGSTATE_CURPERTRANS 16
    AggStatePerTrans curpertrans;   /* currently active trans state, if any */
    bool        input_done;     /* indicates end of input */
    bool        agg_done;       /* indicates completion of Agg scan */
    int         projected_set;  /* The last projected grouping set */
#define FIELDNO_AGGSTATE_CURRENT_SET 20
    int         current_set;    /* The current grouping set being evaluated */
    Bitmapset  *grouped_cols;   /* grouped cols in current projection */
    List       *all_grouped_cols;   /* list of all grouped cols in DESC order */
    Bitmapset  *colnos_needed;  /* all columns needed from the outer plan */
    int         max_colno_needed;   /* highest colno needed from outer plan */
    bool        all_cols_needed;    /* are all cols from outer plan needed? */
    /* These fields are for grouping set phase data */
    int         maxsets;        /* The max number of sets in any phase */
    AggStatePerPhase phases;    /* array of all phases */
    Tuplesortstate *sort_in;    /* sorted input to phases > 1 */
    Tuplesortstate *sort_out;   /* input is copied here for next phase */
    TupleTableSlot *sort_slot;  /* slot for sort results */
    /* these fields are used in AGG_PLAIN and AGG_SORTED modes: */
    AggStatePerGroup *pergroups;    /* grouping set indexed array of per-group
                                     * pointers */
    HeapTuple   grp_firstTuple; /* copy of first tuple of current group */
    /* these fields are used in AGG_HASHED and AGG_MIXED modes: */
    bool        table_filled;   /* hash table filled yet? */
    int         num_hashes;
    MemoryContext hash_metacxt; /* memory for hash table bucket array */
    MemoryContext hash_tuplescxt;   /* memory for hash table tuples */
    struct LogicalTapeSet *hash_tapeset;    /* tape set for hash spill tapes */
    struct HashAggSpill *hash_spills;   /* HashAggSpill for each grouping set,
                                         * exists only during first pass */
    TupleTableSlot *hash_spill_rslot;   /* for reading spill files */
    TupleTableSlot *hash_spill_wslot;   /* for writing spill files */
    List       *hash_batches;   /* hash batches remaining to be processed */
    bool        hash_ever_spilled;  /* ever spilled during this execution? */
    bool        hash_spill_mode;    /* we hit a limit during the current batch
                                     * and we must not create new groups */
    Size        hash_mem_limit; /* limit before spilling hash table */
    uint64      hash_ngroups_limit; /* limit before spilling hash table */
    int         hash_planned_partitions;    /* number of partitions planned
                                             * for first pass */
    double      hashentrysize;  /* estimate revised during execution */
    Size        hash_mem_peak;  /* peak hash table memory usage */
    uint64      hash_ngroups_current;   /* number of groups currently in
                                         * memory in all hash tables */
    uint64      hash_disk_used; /* kB of disk space used */
    int         hash_batches_used;  /* batches used during entire execution */
 
    AggStatePerHash perhash;    /* array of per-hashtable data */
    AggStatePerGroup *hash_pergroup;    /* grouping set indexed array of
                                         * per-group pointers */
 
    /* support for evaluation of agg input expressions: */
#define FIELDNO_AGGSTATE_ALL_PERGROUPS 54
    AggStatePerGroup *all_pergroups;    /* array of first ->pergroups, than
                                         * ->hash_pergroup */
    SharedAggInfo *shared_info; /* one entry per worker */
} AggState;
 
/* ----------------
 *  WindowAggState information
 * ----------------
 */
/* these structs are private in nodeWindowAgg.c: */
typedef struct WindowStatePerFuncData *WindowStatePerFunc;
typedef struct WindowStatePerAggData *WindowStatePerAgg;
 
/*
 * WindowAggStatus -- Used to track the status of WindowAggState
 */
typedef enum WindowAggStatus
{
    WINDOWAGG_DONE,             /* No more processing to do */
    WINDOWAGG_RUN,              /* Normal processing of window funcs */
    WINDOWAGG_PASSTHROUGH,      /* Don't eval window funcs */
    WINDOWAGG_PASSTHROUGH_STRICT,   /* Pass-through plus don't store new
                                     * tuples during spool */
} WindowAggStatus;
 
typedef struct WindowAggState
{
    ScanState   ss;             /* its first field is NodeTag */
 
    /* these fields are filled in by ExecInitExpr: */
    List       *funcs;          /* all WindowFunc nodes in targetlist */
    int         numfuncs;       /* total number of window functions */
    int         numaggs;        /* number that are plain aggregates */
 
    WindowStatePerFunc perfunc; /* per-window-function information */
    WindowStatePerAgg peragg;   /* per-plain-aggregate information */
    ExprState  *partEqfunction; /* equality funcs for partition columns */
    ExprState  *ordEqfunction;  /* equality funcs for ordering columns */
    Tuplestorestate *buffer;    /* stores rows of current partition */
    int         current_ptr;    /* read pointer # for current row */
    int         framehead_ptr;  /* read pointer # for frame head, if used */
    int         frametail_ptr;  /* read pointer # for frame tail, if used */
    int         grouptail_ptr;  /* read pointer # for group tail, if used */
    int64       spooled_rows;   /* total # of rows in buffer */
    int64       currentpos;     /* position of current row in partition */
    int64       frameheadpos;   /* current frame head position */
    int64       frametailpos;   /* current frame tail position (frame end+1) */
    /* use struct pointer to avoid including windowapi.h here */
    struct WindowObjectData *agg_winobj;    /* winobj for aggregate fetches */
    int64       aggregatedbase; /* start row for current aggregates */
    int64       aggregatedupto; /* rows before this one are aggregated */
    WindowAggStatus status;     /* run status of WindowAggState */
 
    int         frameOptions;   /* frame_clause options, see WindowDef */
    ExprState  *startOffset;    /* expression for starting bound offset */
    ExprState  *endOffset;      /* expression for ending bound offset */
    Datum       startOffsetValue;   /* result of startOffset evaluation */
    Datum       endOffsetValue; /* result of endOffset evaluation */
 
    /* these fields are used with RANGE offset PRECEDING/FOLLOWING: */
    FmgrInfo    startInRangeFunc;   /* in_range function for startOffset */
    FmgrInfo    endInRangeFunc; /* in_range function for endOffset */
    Oid         inRangeColl;    /* collation for in_range tests */
    bool        inRangeAsc;     /* use ASC sort order for in_range tests? */
    bool        inRangeNullsFirst;  /* nulls sort first for in_range tests? */
 
    /* fields relating to runconditions */
    bool        use_pass_through;   /* When false, stop execution when
                                     * runcondition is no longer true.  Else
                                     * just stop evaluating window funcs. */
    bool        top_window;     /* true if this is the top-most WindowAgg or
                                 * the only WindowAgg in this query level */
    ExprState  *runcondition;   /* Condition which must remain true otherwise
                                 * execution of the WindowAgg will finish or
                                 * go into pass-through mode.  NULL when there
                                 * is no such condition. */
 
    /* these fields are used in GROUPS mode: */
    int64       currentgroup;   /* peer group # of current row in partition */
    int64       frameheadgroup; /* peer group # of frame head row */
    int64       frametailgroup; /* peer group # of frame tail row */
    int64       groupheadpos;   /* current row's peer group head position */
    int64       grouptailpos;   /* " " " " tail position (group end+1) */
 
    MemoryContext partcontext;  /* context for partition-lifespan data */
    MemoryContext aggcontext;   /* shared context for aggregate working data */
    MemoryContext curaggcontext;    /* current aggregate's working data */
    ExprContext *tmpcontext;    /* short-term evaluation context */
 
    bool        all_first;      /* true if the scan is starting */
    bool        partition_spooled;  /* true if all tuples in current partition
                                     * have been spooled into tuplestore */
    bool        next_partition; /* true if begin_partition needs to be called */
    bool        more_partitions;    /* true if there's more partitions after
                                     * this one */
    bool        framehead_valid;    /* true if frameheadpos is known up to
                                     * date for current row */
    bool        frametail_valid;    /* true if frametailpos is known up to
                                     * date for current row */
    bool        grouptail_valid;    /* true if grouptailpos is known up to
                                     * date for current row */
 
    TupleTableSlot *first_part_slot;    /* first tuple of current or next
                                         * partition */
    TupleTableSlot *framehead_slot; /* first tuple of current frame */
    TupleTableSlot *frametail_slot; /* first tuple after current frame */
 
    /* temporary slots for tuples fetched back from tuplestore */
    TupleTableSlot *agg_row_slot;
    TupleTableSlot *temp_slot_1;
    TupleTableSlot *temp_slot_2;
} WindowAggState;
 
/* ----------------
 *   UniqueState information
 *
 *      Unique nodes are used "on top of" sort nodes to discard
 *      duplicate tuples returned from the sort phase.  Basically
 *      all it does is compare the current tuple from the subplan
 *      with the previously fetched tuple (stored in its result slot).
 *      If the two are identical in all interesting fields, then
 *      we just fetch another tuple from the sort and try again.
 * ----------------
 */
typedef struct UniqueState
{
    PlanState   ps;             /* its first field is NodeTag */
    ExprState  *eqfunction;     /* tuple equality qual */
} UniqueState;
 
/* ----------------
 * GatherState information
 *
 *      Gather nodes launch 1 or more parallel workers, run a subplan
 *      in those workers, and collect the results.
 * ----------------
 */
typedef struct GatherState
{
    PlanState   ps;             /* its first field is NodeTag */
    bool        initialized;    /* workers launched? */
    bool        need_to_scan_locally;   /* need to read from local plan? */
    int64       tuples_needed;  /* tuple bound, see ExecSetTupleBound */
    /* these fields are set up once: */
    TupleTableSlot *funnel_slot;
    struct ParallelExecutorInfo *pei;
    /* all remaining fields are reinitialized during a rescan: */
    int         nworkers_launched;  /* original number of workers */
    int         nreaders;       /* number of still-active workers */
    int         nextreader;     /* next one to try to read from */
    struct TupleQueueReader **reader;   /* array with nreaders active entries */
} GatherState;
 
/* ----------------
 * GatherMergeState information
 *
 *      Gather merge nodes launch 1 or more parallel workers, run a
 *      subplan which produces sorted output in each worker, and then
 *      merge the results into a single sorted stream.
 * ----------------
 */
struct GMReaderTupleBuffer;     /* private in nodeGatherMerge.c */
 
typedef struct GatherMergeState
{
    PlanState   ps;             /* its first field is NodeTag */
    bool        initialized;    /* workers launched? */
    bool        gm_initialized; /* gather_merge_init() done? */
    bool        need_to_scan_locally;   /* need to read from local plan? */
    int64       tuples_needed;  /* tuple bound, see ExecSetTupleBound */
    /* these fields are set up once: */
    TupleDesc   tupDesc;        /* descriptor for subplan result tuples */
    int         gm_nkeys;       /* number of sort columns */
    SortSupport gm_sortkeys;    /* array of length gm_nkeys */
    struct ParallelExecutorInfo *pei;
    /* all remaining fields are reinitialized during a rescan */
    /* (but the arrays are not reallocated, just cleared) */
    int         nworkers_launched;  /* original number of workers */
    int         nreaders;       /* number of active workers */
    TupleTableSlot **gm_slots;  /* array with nreaders+1 entries */
    struct TupleQueueReader **reader;   /* array with nreaders active entries */
    struct GMReaderTupleBuffer *gm_tuple_buffers;   /* nreaders tuple buffers */
    struct binaryheap *gm_heap; /* binary heap of slot indices */
} GatherMergeState;
 
/* ----------------
 *   HashState information
 * ----------------
 */
typedef struct HashState
{
    PlanState   ps;             /* its first field is NodeTag */
    HashJoinTable hashtable;    /* hash table for the hashjoin */
    ExprState  *hash_expr;      /* ExprState to get hash value */
 
    FmgrInfo   *skew_hashfunction;  /* lookup data for skew hash function */
    Oid         skew_collation; /* collation to call skew_hashfunction with */
 
    /*
     * In a parallelized hash join, the leader retains a pointer to the
     * shared-memory stats area in its shared_info field, and then copies the
     * shared-memory info back to local storage before DSM shutdown.  The
     * shared_info field remains NULL in workers, or in non-parallel joins.
     */
    SharedHashInfo *shared_info;
 
    /*
     * If we are collecting hash stats, this points to an initially-zeroed
     * collection area, which could be either local storage or in shared
     * memory; either way it's for just one process.
     */
    HashInstrumentation *hinstrument;
 
    /* Parallel hash state. */
    struct ParallelHashJoinState *parallel_state;
} HashState;
 
/* ----------------
 *   SetOpState information
 *
 *      SetOp nodes support either sorted or hashed de-duplication.
 *      The sorted mode is a bit like MergeJoin, the hashed mode like Agg.
 * ----------------
 */
typedef struct SetOpStatePerInput
{
    TupleTableSlot *firstTupleSlot; /* first tuple of current group */
    int64       numTuples;      /* number of tuples in current group */
    TupleTableSlot *nextTupleSlot;  /* next input tuple, if already read */
    bool        needGroup;      /* do we need to load a new group? */
} SetOpStatePerInput;
 
typedef struct SetOpState
{
    PlanState   ps;             /* its first field is NodeTag */
    bool        setop_done;     /* indicates completion of output scan */
    int64       numOutput;      /* number of dups left to output */
    int         numCols;        /* number of grouping columns */
 
    /* these fields are used in SETOP_SORTED mode: */
    SortSupport sortKeys;       /* per-grouping-field sort data */
    SetOpStatePerInput leftInput;   /* current outer-relation input state */
    SetOpStatePerInput rightInput;  /* current inner-relation input state */
    bool        need_init;      /* have we read the first tuples yet? */
 
    /* these fields are used in SETOP_HASHED mode: */
    Oid        *eqfuncoids;     /* per-grouping-field equality fns */
    FmgrInfo   *hashfunctions;  /* per-grouping-field hash fns */
    TupleHashTable hashtable;   /* hash table with one entry per group */
    MemoryContext tuplesContext;    /* context containing hash table's tuples */
    bool        table_filled;   /* hash table filled yet? */
    TupleHashIterator hashiter; /* for iterating through hash table */
} SetOpState;
 
/* ----------------
 *   LockRowsState information
 *
 *      LockRows nodes are used to enforce FOR [KEY] UPDATE/SHARE locking.
 * ----------------
 */
typedef struct LockRowsState
{
    PlanState   ps;             /* its first field is NodeTag */
    List       *lr_arowMarks;   /* List of ExecAuxRowMarks */
    EPQState    lr_epqstate;    /* for evaluating EvalPlanQual rechecks */
} LockRowsState;
 
/* ----------------
 *   LimitState information
 *
 *      Limit nodes are used to enforce LIMIT/OFFSET clauses.
 *      They just select the desired subrange of their subplan's output.
 *
 * offset is the number of initial tuples to skip (0 does nothing).
 * count is the number of tuples to return after skipping the offset tuples.
 * If no limit count was specified, count is undefined and noCount is true.
 * When lstate == LIMIT_INITIAL, offset/count/noCount haven't been set yet.
 * ----------------
 */
typedef enum
{
    LIMIT_INITIAL,              /* initial state for LIMIT node */
    LIMIT_RESCAN,               /* rescan after recomputing parameters */
    LIMIT_EMPTY,                /* there are no returnable rows */
    LIMIT_INWINDOW,             /* have returned a row in the window */
    LIMIT_WINDOWEND_TIES,       /* have returned a tied row */
    LIMIT_SUBPLANEOF,           /* at EOF of subplan (within window) */
    LIMIT_WINDOWEND,            /* stepped off end of window */
    LIMIT_WINDOWSTART,          /* stepped off beginning of window */
} LimitStateCond;
 
typedef struct LimitState
{
    PlanState   ps;             /* its first field is NodeTag */
    ExprState  *limitOffset;    /* OFFSET parameter, or NULL if none */
    ExprState  *limitCount;     /* COUNT parameter, or NULL if none */
    LimitOption limitOption;    /* limit specification type */
    int64       offset;         /* current OFFSET value */
    int64       count;          /* current COUNT, if any */
    bool        noCount;        /* if true, ignore count */
    LimitStateCond lstate;      /* state machine status, as above */
    int64       position;       /* 1-based index of last tuple returned */
    TupleTableSlot *subSlot;    /* tuple last obtained from subplan */
    ExprState  *eqfunction;     /* tuple equality qual in case of WITH TIES
                                 * option */
    TupleTableSlot *last_slot;  /* slot for evaluation of ties */
} LimitState;
 
#endif                          /* EXECNODES_H */

innerPlanState

#define innerPlanState

(

node

)

(((PlanState *)(node))->righttree)

Definition at line 1263 of file execnodes.h.

InstrCountFiltered1

#define InstrCountFiltered1	(		node,
			delta
	)

Value:

    do { \
		if (((PlanState *)(node))->instrument) \
            ((PlanState *)(node))->instrument->nfiltered1 += (delta); \
    } while(0)

Definition at line 1272 of file execnodes.h.

       { \
		if (((PlanState *)(node))->instrument) \
            ((PlanState *)(node))->instrument->nfiltered1 += (delta); \
    } while(0)

InstrCountFiltered2

#define InstrCountFiltered2	(		node,
			delta
	)

Value:

    do { \
		if (((PlanState *)(node))->instrument) \
            ((PlanState *)(node))->instrument->nfiltered2 += (delta); \
    } while(0)

Definition at line 1277 of file execnodes.h.

       { \
		if (((PlanState *)(node))->instrument) \
            ((PlanState *)(node))->instrument->nfiltered2 += (delta); \
    } while(0)

InstrCountTuples2

#define InstrCountTuples2	(		node,
			delta
	)

Value:

    do { \
		if (((PlanState *)(node))->instrument) \
            ((PlanState *)(node))->instrument->ntuples2 += (delta); \
    } while (0)

Definition at line 1267 of file execnodes.h.

       { \
		if (((PlanState *)(node))->instrument) \
            ((PlanState *)(node))->instrument->ntuples2 += (delta); \
    } while (0)

MERGE_DELETE

#define MERGE_DELETE   0x04

Definition at line 1398 of file execnodes.h.

MERGE_INSERT

#define MERGE_INSERT   0x01

Definition at line 1396 of file execnodes.h.

MERGE_UPDATE

#define MERGE_UPDATE   0x02

Definition at line 1397 of file execnodes.h.

outerPlanState

#define outerPlanState

(

node

)

(((PlanState *)(node))->lefttree)

Definition at line 1264 of file execnodes.h.

ResetTupleHashIterator

#define ResetTupleHashIterator	(		htable,
			iter
	)		InitTupleHashIterator(htable, iter)

Definition at line 901 of file execnodes.h.

ScanTupleHashTable

#define ScanTupleHashTable	(		htable,
			iter
	)		tuplehash_iterate(htable->hashtab, iter)

Definition at line 903 of file execnodes.h.

SH_DECLARE

#define SH_DECLARE

Definition at line 868 of file execnodes.h.

SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE   TupleHashEntryData

Definition at line 865 of file execnodes.h.

SH_KEY_TYPE

#define SH_KEY_TYPE   MinimalTuple

Definition at line 866 of file execnodes.h.

SH_PREFIX

#define SH_PREFIX   tuplehash

Definition at line 864 of file execnodes.h.

SH_SCOPE

#define SH_SCOPE   extern

Definition at line 867 of file execnodes.h.

TermTupleHashIterator

#define TermTupleHashIterator

(

iter

)

((void) 0)

Definition at line 899 of file execnodes.h.

Typedef Documentation

AggState

typedef struct AggState AggState

AggStatePerAgg

typedef struct AggStatePerAggData* AggStatePerAgg

Definition at line 2413 of file execnodes.h.

AggStatePerGroup

typedef struct AggStatePerGroupData* AggStatePerGroup

Definition at line 2415 of file execnodes.h.

AggStatePerHash

typedef struct AggStatePerHashData* AggStatePerHash

Definition at line 2417 of file execnodes.h.

AggStatePerPhase

typedef struct AggStatePerPhaseData* AggStatePerPhase

Definition at line 2416 of file execnodes.h.

AggStatePerTrans

typedef struct AggStatePerTransData* AggStatePerTrans

Definition at line 2414 of file execnodes.h.

AppendState

typedef struct AppendState AppendState

Definition at line 1492 of file execnodes.h.

AsyncRequest

typedef struct AsyncRequest AsyncRequest

BitmapAndState

typedef struct BitmapAndState BitmapAndState

BitmapHeapScanState

typedef struct BitmapHeapScanState BitmapHeapScanState

BitmapIndexScanState

typedef struct BitmapIndexScanState BitmapIndexScanState

BitmapOrState

typedef struct BitmapOrState BitmapOrState

CteScanState

typedef struct CteScanState CteScanState

CustomScanState

typedef struct CustomScanState CustomScanState

DomainConstraintState

typedef struct DomainConstraintState DomainConstraintState

DomainConstraintType

typedef enum DomainConstraintType DomainConstraintType

EPQState

typedef struct EPQState EPQState

EState

typedef struct EState EState

ExecAuxRowMark

typedef struct ExecAuxRowMark ExecAuxRowMark

ExecProcNodeMtd

typedef TupleTableSlot *(* ExecProcNodeMtd) (PlanState *pstate)

Definition at line 1153 of file execnodes.h.

ExecRowMark

typedef struct ExecRowMark ExecRowMark

Definition at line 58 of file execnodes.h.

ExprContext

typedef struct ExprContext ExprContext

Definition at line 60 of file execnodes.h.

ExprContext_CB

typedef struct ExprContext_CB ExprContext_CB

ExprContextCallbackFunction

typedef void(* ExprContextCallbackFunction) (Datum arg)

Definition at line 237 of file execnodes.h.

ExprState

typedef struct ExprState ExprState

Definition at line 59 of file execnodes.h.

ExprStateEvalFunc

typedef Datum(* ExprStateEvalFunc) (ExprState *expression, ExprContext *econtext, bool *isNull)

Definition at line 70 of file execnodes.h.

ForeignScanState

typedef struct ForeignScanState ForeignScanState

FunctionScanState

typedef struct FunctionScanState FunctionScanState

GatherMergeState

typedef struct GatherMergeState GatherMergeState

GatherState

typedef struct GatherState GatherState

GroupState

typedef struct GroupState GroupState

HashJoinState

typedef struct HashJoinState HashJoinState

HashJoinTable

typedef struct HashJoinTableData* HashJoinTable

Definition at line 2235 of file execnodes.h.

HashJoinTuple

typedef struct HashJoinTupleData* HashJoinTuple

Definition at line 2234 of file execnodes.h.

HashState

typedef struct HashState HashState

IncrementalSortState

typedef struct IncrementalSortState IncrementalSortState

IndexInfo

typedef struct IndexInfo IndexInfo

IndexOnlyScanState

typedef struct IndexOnlyScanState IndexOnlyScanState

IndexScanState

typedef struct IndexScanState IndexScanState

JoinState

typedef struct JoinState JoinState

JsonExprState

typedef struct JsonExprState JsonExprState

JunkFilter

typedef struct JunkFilter JunkFilter

LimitState

typedef struct LimitState LimitState

LockRowsState

typedef struct LockRowsState LockRowsState

MaterialState

typedef struct MaterialState MaterialState

MemoizeState

typedef struct MemoizeState MemoizeState

MergeActionState

typedef struct MergeActionState MergeActionState

MergeAppendState

typedef struct MergeAppendState MergeAppendState

MergeJoinClause

typedef struct MergeJoinClauseData* MergeJoinClause

Definition at line 2183 of file execnodes.h.

MergeJoinState

typedef struct MergeJoinState MergeJoinState

ModifyTableState

typedef struct ModifyTableState ModifyTableState

NamedTuplestoreScanState

typedef struct NamedTuplestoreScanState NamedTuplestoreScanState

NestLoopState

typedef struct NestLoopState NestLoopState

OnConflictActionState

typedef struct OnConflictActionState OnConflictActionState

ParallelAppendState

typedef struct ParallelAppendState ParallelAppendState

Definition at line 1494 of file execnodes.h.

ParallelBitmapHeapState

typedef struct ParallelBitmapHeapState ParallelBitmapHeapState

PlanState

typedef struct PlanState PlanState

Definition at line 57 of file execnodes.h.

PresortedKeyData

typedef struct PresortedKeyData PresortedKeyData

ProjectionInfo

typedef struct ProjectionInfo ProjectionInfo

ProjectSetState

typedef struct ProjectSetState ProjectSetState

RecursiveUnionState

typedef struct RecursiveUnionState RecursiveUnionState

ResultRelInfo

typedef struct ResultRelInfo ResultRelInfo

ResultState

typedef struct ResultState ResultState

ReturnSetInfo

typedef struct ReturnSetInfo ReturnSetInfo

SampleScanState

typedef struct SampleScanState SampleScanState

ScanState

typedef struct ScanState ScanState

SeqScanState

typedef struct SeqScanState SeqScanState

SetExprState

typedef struct SetExprState SetExprState

SetOpState

typedef struct SetOpState SetOpState

SetOpStatePerInput

typedef struct SetOpStatePerInput SetOpStatePerInput

SortState

typedef struct SortState SortState

SubPlanState

typedef struct SubPlanState SubPlanState

SubqueryScanState

typedef struct SubqueryScanState SubqueryScanState

TableFuncScanState

typedef struct TableFuncScanState TableFuncScanState

TidRangeScanState

typedef struct TidRangeScanState TidRangeScanState

TidScanState

typedef struct TidScanState TidScanState

TupleHashEntry

typedef struct TupleHashEntryData* TupleHashEntry

Definition at line 847 of file execnodes.h.

TupleHashEntryData

typedef struct TupleHashEntryData TupleHashEntryData

TupleHashIterator

typedef tuplehash_iterator TupleHashIterator

Definition at line 890 of file execnodes.h.

TupleHashTable

typedef struct TupleHashTableData* TupleHashTable

Definition at line 848 of file execnodes.h.

TupleHashTableData

typedef struct TupleHashTableData TupleHashTableData

UniqueState

typedef struct UniqueState UniqueState

ValuesScanState

typedef struct ValuesScanState ValuesScanState

WindowAggState

typedef struct WindowAggState WindowAggState

WindowAggStatus

typedef enum WindowAggStatus WindowAggStatus

WindowFuncExprState

typedef struct WindowFuncExprState WindowFuncExprState

WindowStatePerAgg

typedef struct WindowStatePerAggData* WindowStatePerAgg

Definition at line 2502 of file execnodes.h.

WindowStatePerFunc

typedef struct WindowStatePerFuncData* WindowStatePerFunc

Definition at line 2501 of file execnodes.h.

WorkTableScanState

typedef struct WorkTableScanState WorkTableScanState

Enumeration Type Documentation

DomainConstraintType

enum DomainConstraintType

Enumerator
DOM_CONSTRAINT_NOTNULL
DOM_CONSTRAINT_CHECK

Definition at line 1050 of file execnodes.h.

{
    DOM_CONSTRAINT_NOTNULL,
    DOM_CONSTRAINT_CHECK,
} DomainConstraintType;

ExprDoneCond

enum ExprDoneCond

Enumerator
ExprSingleResult
ExprMultipleResult
ExprEndResult

Definition at line 327 of file execnodes.h.

{
    ExprSingleResult,           /* expression does not return a set */
    ExprMultipleResult,         /* this result is an element of a set */
    ExprEndResult,              /* there are no more elements in the set */
} ExprDoneCond;

IncrementalSortExecutionStatus

enum IncrementalSortExecutionStatus

Enumerator
INCSORT_LOADFULLSORT
INCSORT_LOADPREFIXSORT
INCSORT_READFULLSORT
INCSORT_READPREFIXSORT

Definition at line 2358 of file execnodes.h.

{
    INCSORT_LOADFULLSORT,
    INCSORT_LOADPREFIXSORT,
    INCSORT_READFULLSORT,
    INCSORT_READPREFIXSORT,
} IncrementalSortExecutionStatus;

LimitStateCond

enum LimitStateCond

Enumerator
LIMIT_INITIAL
LIMIT_RESCAN
LIMIT_EMPTY
LIMIT_INWINDOW
LIMIT_WINDOWEND_TIES
LIMIT_SUBPLANEOF
LIMIT_WINDOWEND
LIMIT_WINDOWSTART

Definition at line 2770 of file execnodes.h.

{
    LIMIT_INITIAL,              /* initial state for LIMIT node */
    LIMIT_RESCAN,               /* rescan after recomputing parameters */
    LIMIT_EMPTY,                /* there are no returnable rows */
    LIMIT_INWINDOW,             /* have returned a row in the window */
    LIMIT_WINDOWEND_TIES,       /* have returned a tied row */
    LIMIT_SUBPLANEOF,           /* at EOF of subplan (within window) */
    LIMIT_WINDOWEND,            /* stepped off end of window */
    LIMIT_WINDOWSTART,          /* stepped off beginning of window */
} LimitStateCond;

SetFunctionReturnMode

enum SetFunctionReturnMode

Enumerator
SFRM_ValuePerCall
SFRM_Materialize
SFRM_Materialize_Random
SFRM_Materialize_Preferred

Definition at line 340 of file execnodes.h.

{
    SFRM_ValuePerCall = 0x01,   /* one value returned per call */
    SFRM_Materialize = 0x02,    /* result set instantiated in Tuplestore */
    SFRM_Materialize_Random = 0x04, /* Tuplestore needs randomAccess */
    SFRM_Materialize_Preferred = 0x08,  /* caller prefers Tuplestore */
} SetFunctionReturnMode;

SharedBitmapState

enum SharedBitmapState

Enumerator
BM_INITIAL
BM_INPROGRESS
BM_FINISHED

Definition at line 1835 of file execnodes.h.

{
    BM_INITIAL,
    BM_INPROGRESS,
    BM_FINISHED,
} SharedBitmapState;

WindowAggStatus

enum WindowAggStatus

Enumerator
WINDOWAGG_DONE
WINDOWAGG_RUN
WINDOWAGG_PASSTHROUGH
WINDOWAGG_PASSTHROUGH_STRICT

Definition at line 2507 of file execnodes.h.

{
    WINDOWAGG_DONE,             /* No more processing to do */
    WINDOWAGG_RUN,              /* Normal processing of window funcs */
    WINDOWAGG_PASSTHROUGH,      /* Don't eval window funcs */
    WINDOWAGG_PASSTHROUGH_STRICT,   /* Pass-through plus don't store new
                                     * tuples during spool */
} WindowAggStatus;