execnodes.h

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * execnodes.h
 *    definitions for executor state nodes
 *
 * Most plan node types declared in plannodes.h have a corresponding
 * execution-state node type declared here.  An exception is that
 * expression nodes (subtypes of Expr) are usually represented by steps
 * of an ExprState, and fully handled within execExpr* - but sometimes
 * their state needs to be shared with other parts of the executor, as
 * for example with SubPlanState, which nodeSubplan.c has to modify.
 *
 * Node types declared in this file do not have any copy/equal/out/read
 * support.  (That is currently hard-wired in gen_node_support.pl, rather
 * than being explicitly represented by pg_node_attr decorations here.)
 * There is no need for copy, equal, or read support for executor trees.
 * Output support could be useful for debugging; but there are a lot of
 * specialized fields that would require custom code, so for now it's
 * not provided.
 *
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * src/include/nodes/execnodes.h
 *
 *-------------------------------------------------------------------------
 */
#ifndef EXECNODES_H
#define EXECNODES_H
 
#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"
 
/*
 * forward references in this file
 */
typedef struct PlanState PlanState;
typedef struct ExecRowMark ExecRowMark;
typedef struct ExprState ExprState;
typedef struct ExprContext ExprContext;
 
 
/* ----------------
 *      ExprState node
 *
 * ExprState represents the evaluation state for a whole expression tree.
 * It contains instructions (in ->steps) to evaluate the expression.
 * ----------------
 */
typedef Datum (*ExprStateEvalFunc) (ExprState *expression,
                                    ExprContext *econtext,
                                    bool *isNull);
 
/* Bits in ExprState->flags (see also execExpr.h for private flag bits): */
/* expression is for use with ExecQual() */
#define EEO_FLAG_IS_QUAL                    (1 << 0)
/* expression refers to OLD table columns */
#define EEO_FLAG_HAS_OLD                    (1 << 1)
/* expression refers to NEW table columns */
#define EEO_FLAG_HAS_NEW                    (1 << 2)
/* OLD table row is NULL in RETURNING list */
#define EEO_FLAG_OLD_IS_NULL                (1 << 3)
/* NEW table row is NULL in RETURNING list */
#define EEO_FLAG_NEW_IS_NULL                (1 << 4)
 
typedef struct ExprState
{
    NodeTag     type;
 
#define FIELDNO_EXPRSTATE_FLAGS 1
    uint8       flags;          /* bitmask of EEO_FLAG_* bits, see above */
 
    /*
     * Storage for result value of a scalar expression, or for individual
     * column results within expressions built by ExecBuildProjectionInfo().
     */
#define FIELDNO_EXPRSTATE_RESNULL 2
    bool        resnull;
#define FIELDNO_EXPRSTATE_RESVALUE 3
    Datum       resvalue;
 
    /*
     * If projecting a tuple result, this slot holds the result; else NULL.
     */
#define FIELDNO_EXPRSTATE_RESULTSLOT 4
    TupleTableSlot *resultslot;
 
    /*
     * Instructions to compute expression's return value.
     */
    struct ExprEvalStep *steps;
 
    /*
     * Function that actually evaluates the expression.  This can be set to
     * different values depending on the complexity of the expression.
     */
    ExprStateEvalFunc evalfunc;
 
    /* original expression tree, for debugging only */
    Expr       *expr;
 
    /* private state for an evalfunc */
    void       *evalfunc_private;
 
    /*
     * XXX: following fields only needed during "compilation" (ExecInitExpr);
     * could be thrown away afterwards.
     */
 
    int         steps_len;      /* number of steps currently */
    int         steps_alloc;    /* allocated length of steps array */
 
#define FIELDNO_EXPRSTATE_PARENT 11
    PlanState  *parent;         /* parent PlanState node, if any */
    ParamListInfo ext_params;   /* for compiling PARAM_EXTERN nodes */
 
    Datum      *innermost_caseval;
    bool       *innermost_casenull;
 
    Datum      *innermost_domainval;
    bool       *innermost_domainnull;
 
    /*
     * For expression nodes that support soft errors. Should be set to NULL if
     * the caller wants errors to be thrown. Callers that do not want errors
     * thrown should set it to a valid ErrorSaveContext before calling
     * ExecInitExprRec().
     */
    ErrorSaveContext *escontext;
} ExprState;
 
 
/* ----------------
 *    IndexInfo information
 *
 *      this struct holds the information needed to construct new index
 *      entries for a particular index.  Used for both index_build and
 *      retail creation of index entries.
 *
 * ii_Concurrent, ii_BrokenHotChain, and ii_ParallelWorkers are used only
 * during index build; they're conventionally zeroed otherwise.
 * ----------------
 */
typedef struct IndexInfo
{
    NodeTag     type;
 
    /* total number of columns in index */
    int         ii_NumIndexAttrs;
    /* number of key columns in index */
    int         ii_NumIndexKeyAttrs;
 
    /*
     * Underlying-rel attribute numbers used as keys (zeroes indicate
     * expressions). It also contains info about included columns.
     */
    AttrNumber  ii_IndexAttrNumbers[INDEX_MAX_KEYS];
 
    /* expr trees for expression entries, or NIL if none */
    List       *ii_Expressions; /* list of Expr */
    /* exec state for expressions, or NIL if none */
    List       *ii_ExpressionsState;    /* list of ExprState */
 
    /* partial-index predicate, or NIL if none */
    List       *ii_Predicate;   /* list of Expr */
    /* exec state for expressions, or NIL if none */
    ExprState  *ii_PredicateState;
 
    /* Per-column exclusion operators, or NULL if none */
    Oid        *ii_ExclusionOps;    /* array with one entry per column */
    /* Underlying function OIDs for ExclusionOps */
    Oid        *ii_ExclusionProcs;  /* array with one entry per column */
    /* Opclass strategy numbers for ExclusionOps */
    uint16     *ii_ExclusionStrats; /* array with one entry per column */
 
    /* These are like Exclusion*, but for unique indexes */
    Oid        *ii_UniqueOps;   /* array with one entry per column */
    Oid        *ii_UniqueProcs; /* array with one entry per column */
    uint16     *ii_UniqueStrats;    /* array with one entry per column */
 
    /* is it a unique index? */
    bool        ii_Unique;
    /* is NULLS NOT DISTINCT? */
    bool        ii_NullsNotDistinct;
    /* is it valid for inserts? */
    bool        ii_ReadyForInserts;
    /* IndexUnchanged status determined yet? */
    bool        ii_CheckedUnchanged;
    /* aminsert hint, cached for retail inserts */
    bool        ii_IndexUnchanged;
    /* are we doing a concurrent index build? */
    bool        ii_Concurrent;
    /* did we detect any broken HOT chains? */
    bool        ii_BrokenHotChain;
    /* is it a summarizing index? */
    bool        ii_Summarizing;
    /* is it a WITHOUT OVERLAPS index? */
    bool        ii_WithoutOverlaps;
    /* # of workers requested (excludes leader) */
    int         ii_ParallelWorkers;
 
    /* Oid of index AM */
    Oid         ii_Am;
    /* private cache area for index AM */
    void       *ii_AmCache;
 
    /* memory context holding this IndexInfo */
    MemoryContext ii_Context;
} IndexInfo;
 
/* ----------------
 *    ExprContext_CB
 *
 *      List of callbacks to be called at ExprContext shutdown.
 * ----------------
 */
typedef void (*ExprContextCallbackFunction) (Datum arg);
 
typedef struct ExprContext_CB
{
    struct ExprContext_CB *next;
    ExprContextCallbackFunction function;
    Datum       arg;
} ExprContext_CB;
 
/* ----------------
 *    ExprContext
 *
 *      This class holds the "current context" information
 *      needed to evaluate expressions for doing tuple qualifications
 *      and tuple projections.  For example, if an expression refers
 *      to an attribute in the current inner tuple then we need to know
 *      what the current inner tuple is and so we look at the expression
 *      context.
 *
 *  There are two memory contexts associated with an ExprContext:
 *  * ecxt_per_query_memory is a query-lifespan context, typically the same
 *    context the ExprContext node itself is allocated in.  This context
 *    can be used for purposes such as storing function call cache info.
 *  * ecxt_per_tuple_memory is a short-term context for expression results.
 *    As the name suggests, it will typically be reset once per tuple,
 *    before we begin to evaluate expressions for that tuple.  Each
 *    ExprContext normally has its very own per-tuple memory context.
 *
 *  CurrentMemoryContext should be set to ecxt_per_tuple_memory before
 *  calling ExecEvalExpr() --- see ExecEvalExprSwitchContext().
 * ----------------
 */
typedef struct ExprContext
{
    NodeTag     type;
 
    /* Tuples that Var nodes in expression may refer to */
#define FIELDNO_EXPRCONTEXT_SCANTUPLE 1
    TupleTableSlot *ecxt_scantuple;
#define FIELDNO_EXPRCONTEXT_INNERTUPLE 2
    TupleTableSlot *ecxt_innertuple;
#define FIELDNO_EXPRCONTEXT_OUTERTUPLE 3
    TupleTableSlot *ecxt_outertuple;
 
    /* Memory contexts for expression evaluation --- see notes above */
    MemoryContext ecxt_per_query_memory;
    MemoryContext ecxt_per_tuple_memory;
 
    /* Values to substitute for Param nodes in expression */
    ParamExecData *ecxt_param_exec_vals;    /* for PARAM_EXEC params */
    ParamListInfo ecxt_param_list_info; /* for other param types */
 
    /*
     * Values to substitute for Aggref nodes in the expressions of an Agg
     * node, or for WindowFunc nodes within a WindowAgg node.
     */
#define FIELDNO_EXPRCONTEXT_AGGVALUES 8
    Datum      *ecxt_aggvalues; /* precomputed values for aggs/windowfuncs */
#define FIELDNO_EXPRCONTEXT_AGGNULLS 9
    bool       *ecxt_aggnulls;  /* null flags for aggs/windowfuncs */
 
    /* Value to substitute for CaseTestExpr nodes in expression */
#define FIELDNO_EXPRCONTEXT_CASEDATUM 10
    Datum       caseValue_datum;
#define FIELDNO_EXPRCONTEXT_CASENULL 11
    bool        caseValue_isNull;
 
    /* Value to substitute for CoerceToDomainValue nodes in expression */
#define FIELDNO_EXPRCONTEXT_DOMAINDATUM 12
    Datum       domainValue_datum;
#define FIELDNO_EXPRCONTEXT_DOMAINNULL 13
    bool        domainValue_isNull;
 
    /* Tuples that OLD/NEW Var nodes in RETURNING may refer to */
#define FIELDNO_EXPRCONTEXT_OLDTUPLE 14
    TupleTableSlot *ecxt_oldtuple;
#define FIELDNO_EXPRCONTEXT_NEWTUPLE 15
    TupleTableSlot *ecxt_newtuple;
 
    /* Link to containing EState (NULL if a standalone ExprContext) */
    struct EState *ecxt_estate;
 
    /* Functions to call back when ExprContext is shut down or rescanned */
    ExprContext_CB *ecxt_callbacks;
} ExprContext;
 
/*
 * Set-result status used when evaluating functions potentially returning a
 * set.
 */
typedef enum
{
    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;
 
/*
 * Return modes for functions returning sets.  Note values must be chosen
 * as separate bits so that a bitmask can be formed to indicate supported
 * modes.  SFRM_Materialize_Random and SFRM_Materialize_Preferred are
 * auxiliary flags about SFRM_Materialize mode, rather than separate modes.
 */
typedef enum
{
    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;
 
/*
 * When calling a function that might return a set (multiple rows),
 * a node of this type is passed as fcinfo->resultinfo to allow
 * return status to be passed back.  A function returning set should
 * raise an error if no such resultinfo is provided.
 */
typedef struct ReturnSetInfo
{
    NodeTag     type;
    /* values set by caller: */
    ExprContext *econtext;      /* context function is being called in */
    TupleDesc   expectedDesc;   /* tuple descriptor expected by caller */
    int         allowedModes;   /* bitmask: return modes caller can handle */
    /* result status from function (but pre-initialized by caller): */
    SetFunctionReturnMode returnMode;   /* actual return mode */
    ExprDoneCond isDone;        /* status for ValuePerCall mode */
    /* fields filled by function in Materialize return mode: */
    Tuplestorestate *setResult; /* holds the complete returned tuple set */
    TupleDesc   setDesc;        /* actual descriptor for returned tuples */
} ReturnSetInfo;
 
/* ----------------
 *      ProjectionInfo node information
 *
 *      This is all the information needed to perform projections ---
 *      that is, form new tuples by evaluation of targetlist expressions.
 *      Nodes which need to do projections create one of these.
 *
 *      The target tuple slot is kept in ProjectionInfo->pi_state.resultslot.
 *      ExecProject() evaluates the tlist, forms a tuple, and stores it
 *      in the given slot.  Note that the result will be a "virtual" tuple
 *      unless ExecMaterializeSlot() is then called to force it to be
 *      converted to a physical tuple.  The slot must have a tupledesc
 *      that matches the output of the tlist!
 * ----------------
 */
typedef struct ProjectionInfo
{
    NodeTag     type;
    /* instructions to evaluate projection */
    ExprState   pi_state;
    /* expression context in which to evaluate expression */
    ExprContext *pi_exprContext;
} ProjectionInfo;
 
/* ----------------
 *    JunkFilter
 *
 *    This class is used to store information regarding junk attributes.
 *    A junk attribute is an attribute in a tuple that is needed only for
 *    storing intermediate information in the executor, and does not belong
 *    in emitted tuples.  For example, when we do an UPDATE query,
 *    the planner adds a "junk" entry to the targetlist so that the tuples
 *    returned to ExecutePlan() contain an extra attribute: the ctid of
 *    the tuple to be updated.  This is needed to do the update, but we
 *    don't want the ctid to be part of the stored new tuple!  So, we
 *    apply a "junk filter" to remove the junk attributes and form the
 *    real output tuple.  The junkfilter code also provides routines to
 *    extract the values of the junk attribute(s) from the input tuple.
 *
 *    targetList:       the original target list (including junk attributes).
 *    cleanTupType:     the tuple descriptor for the "clean" tuple (with
 *                      junk attributes removed).
 *    cleanMap:         A map with the correspondence between the non-junk
 *                      attribute numbers of the "original" tuple and the
 *                      attribute numbers of the "clean" tuple.
 *    resultSlot:       tuple slot used to hold cleaned tuple.
 * ----------------
 */
typedef struct JunkFilter
{
    NodeTag     type;
    List       *jf_targetList;
    TupleDesc   jf_cleanTupType;
    AttrNumber *jf_cleanMap;
    TupleTableSlot *jf_resultSlot;
} JunkFilter;
 
/*
 * OnConflictSetState
 *
 * Executor state of an ON CONFLICT DO UPDATE operation.
 */
typedef struct OnConflictSetState
{
    NodeTag     type;
 
    TupleTableSlot *oc_Existing;    /* slot to store existing target tuple in */
    TupleTableSlot *oc_ProjSlot;    /* CONFLICT ... SET ... projection target */
    ProjectionInfo *oc_ProjInfo;    /* for ON CONFLICT DO UPDATE SET */
    ExprState  *oc_WhereClause; /* state for the WHERE clause */
} OnConflictSetState;
 
/* ----------------
 *   MergeActionState information
 *
 *  Executor state for a MERGE action.
 * ----------------
 */
typedef struct MergeActionState
{
    NodeTag     type;
 
    MergeAction *mas_action;    /* associated MergeAction node */
    ProjectionInfo *mas_proj;   /* projection of the action's targetlist for
                                 * this rel */
    ExprState  *mas_whenqual;   /* WHEN [NOT] MATCHED AND conditions */
} MergeActionState;
 
/*
 * ResultRelInfo
 *
 * Whenever we update an existing relation, we have to update indexes on the
 * relation, and perhaps also fire triggers.  ResultRelInfo holds all the
 * information needed about a result relation, including indexes.
 *
 * Normally, a ResultRelInfo refers to a table that is in the query's range
 * table; then ri_RangeTableIndex is the RT index and ri_RelationDesc is
 * just a copy of the relevant es_relations[] entry.  However, in some
 * situations we create ResultRelInfos for relations that are not in the
 * range table, namely for targets of tuple routing in a partitioned table,
 * and when firing triggers in tables other than the target tables (See
 * ExecGetTriggerResultRel).  In these situations, ri_RangeTableIndex is 0
 * and ri_RelationDesc is a separately-opened relcache pointer that needs to
 * be separately closed.
 */
typedef struct ResultRelInfo
{
    NodeTag     type;
 
    /* result relation's range table index, or 0 if not in range table */
    Index       ri_RangeTableIndex;
 
    /* relation descriptor for result relation */
    Relation    ri_RelationDesc;
 
    /* # of indices existing on result relation */
    int         ri_NumIndices;
 
    /* array of relation descriptors for indices */
    RelationPtr ri_IndexRelationDescs;
 
    /* array of key/attr info for indices */
    IndexInfo **ri_IndexRelationInfo;
 
    /*
     * For UPDATE/DELETE/MERGE result relations, the attribute number of the
     * row identity junk attribute in the source plan's output tuples
     */
    AttrNumber  ri_RowIdAttNo;
 
    /* For UPDATE, attnums of generated columns to be computed */
    Bitmapset  *ri_extraUpdatedCols;
    /* true if the above has been computed */
    bool        ri_extraUpdatedCols_valid;
 
    /* Projection to generate new tuple in an INSERT/UPDATE */
    ProjectionInfo *ri_projectNew;
    /* Slot to hold that tuple */
    TupleTableSlot *ri_newTupleSlot;
    /* Slot to hold the old tuple being updated */
    TupleTableSlot *ri_oldTupleSlot;
    /* Have the projection and the slots above been initialized? */
    bool        ri_projectNewInfoValid;
 
    /* updates do LockTuple() before oldtup read; see README.tuplock */
    bool        ri_needLockTagTuple;
 
    /* triggers to be fired, if any */
    TriggerDesc *ri_TrigDesc;
 
    /* cached lookup info for trigger functions */
    FmgrInfo   *ri_TrigFunctions;
 
    /* array of trigger WHEN expr states */
    ExprState **ri_TrigWhenExprs;
 
    /* optional runtime measurements for triggers */
    Instrumentation *ri_TrigInstrument;
 
    /* On-demand created slots for triggers / returning processing */
    TupleTableSlot *ri_ReturningSlot;   /* for trigger output tuples */
    TupleTableSlot *ri_TrigOldSlot; /* for a trigger's old tuple */
    TupleTableSlot *ri_TrigNewSlot; /* for a trigger's new tuple */
    TupleTableSlot *ri_AllNullSlot; /* for RETURNING OLD/NEW */
 
    /* FDW callback functions, if foreign table */
    struct FdwRoutine *ri_FdwRoutine;
 
    /* available to save private state of FDW */
    void       *ri_FdwState;
 
    /* true when modifying foreign table directly */
    bool        ri_usesFdwDirectModify;
 
    /* batch insert stuff */
    int         ri_NumSlots;    /* number of slots in the array */
    int         ri_NumSlotsInitialized; /* number of initialized slots */
    int         ri_BatchSize;   /* max slots inserted in a single batch */
    TupleTableSlot **ri_Slots;  /* input tuples for batch insert */
    TupleTableSlot **ri_PlanSlots;
 
    /* list of WithCheckOption's to be checked */
    List       *ri_WithCheckOptions;
 
    /* list of WithCheckOption expr states */
    List       *ri_WithCheckOptionExprs;
 
    /* array of expr states for checking check constraints */
    ExprState **ri_CheckConstraintExprs;
 
    /*
     * array of expr states for checking not-null constraints on virtual
     * generated columns
     */
    ExprState **ri_GenVirtualNotNullConstraintExprs;
 
    /*
     * Arrays of stored generated columns ExprStates for INSERT/UPDATE/MERGE.
     */
    ExprState **ri_GeneratedExprsI;
    ExprState **ri_GeneratedExprsU;
 
    /* number of stored generated columns we need to compute */
    int         ri_NumGeneratedNeededI;
    int         ri_NumGeneratedNeededU;
 
    /* list of RETURNING expressions */
    List       *ri_returningList;
 
    /* for computing a RETURNING list */
    ProjectionInfo *ri_projectReturning;
 
    /* list of arbiter indexes to use to check conflicts */
    List       *ri_onConflictArbiterIndexes;
 
    /* ON CONFLICT evaluation state */
    OnConflictSetState *ri_onConflict;
 
    /* for MERGE, lists of MergeActionState (one per MergeMatchKind) */
    List       *ri_MergeActions[NUM_MERGE_MATCH_KINDS];
 
    /* for MERGE, expr state for checking the join condition */
    ExprState  *ri_MergeJoinCondition;
 
    /* partition check expression state (NULL if not set up yet) */
    ExprState  *ri_PartitionCheckExpr;
 
    /*
     * Map to convert child result relation tuples to the format of the table
     * actually mentioned in the query (called "root").  Computed only if
     * needed.  A NULL map value indicates that no conversion is needed, so we
     * must have a separate flag to show if the map has been computed.
     */
    TupleConversionMap *ri_ChildToRootMap;
    bool        ri_ChildToRootMapValid;
 
    /*
     * As above, but in the other direction.
     */
    TupleConversionMap *ri_RootToChildMap;
    bool        ri_RootToChildMapValid;
 
    /*
     * Other information needed by child result relations
     *
     * ri_RootResultRelInfo gives the target relation mentioned in the query.
     * Used as the root for tuple routing and/or transition capture.
     *
     * ri_PartitionTupleSlot is non-NULL if the relation is a partition to
     * route tuples into and ri_RootToChildMap conversion is needed.
     */
    struct ResultRelInfo *ri_RootResultRelInfo;
    TupleTableSlot *ri_PartitionTupleSlot;
 
    /* for use by copyfrom.c when performing multi-inserts */
    struct CopyMultiInsertBuffer *ri_CopyMultiInsertBuffer;
 
    /*
     * Used when a leaf partition is involved in a cross-partition update of
     * one of its ancestors; see ExecCrossPartitionUpdateForeignKey().
     */
    List       *ri_ancestorResultRels;
} ResultRelInfo;
 
/* ----------------
 *    AsyncRequest
 *
 * State for an asynchronous tuple request.
 * ----------------
 */
typedef struct AsyncRequest
{
    PlanState  *requestor;      /* Node that wants a tuple */
    PlanState  *requestee;      /* Node from which a tuple is wanted */
    int         request_index;  /* Scratch space for requestor */
    bool        callback_pending;   /* Callback is needed */
    bool        request_complete;   /* Request complete, result valid */
    TupleTableSlot *result;     /* Result (NULL or an empty slot if no more
                                 * tuples) */
} AsyncRequest;
 
/* ----------------
 *    EState information
 *
 * Working state for an Executor invocation
 * ----------------
 */
typedef struct EState
{
    NodeTag     type;
 
    /* Basic state for all query types: */
    ScanDirection es_direction; /* current scan direction */
    Snapshot    es_snapshot;    /* time qual to use */
    Snapshot    es_crosscheck_snapshot; /* crosscheck time qual for RI */
    List       *es_range_table; /* List of RangeTblEntry */
    Index       es_range_table_size;    /* size of the range table arrays */
    Relation   *es_relations;   /* Array of per-range-table-entry Relation
                                 * pointers, or NULL if not yet opened */
    ExecRowMark **es_rowmarks;  /* Array of per-range-table-entry
                                 * ExecRowMarks, or NULL if none */
    List       *es_rteperminfos;    /* List of RTEPermissionInfo */
    PlannedStmt *es_plannedstmt;    /* link to top of plan tree */
    List       *es_part_prune_infos;    /* List of PartitionPruneInfo */
    List       *es_part_prune_states;   /* List of PartitionPruneState */
    List       *es_part_prune_results;  /* List of Bitmapset */
    Bitmapset  *es_unpruned_relids; /* PlannedStmt.unprunableRelids + RT
                                     * indexes of leaf partitions that survive
                                     * initial pruning; see
                                     * ExecDoInitialPruning() */
    const char *es_sourceText;  /* Source text from QueryDesc */
 
    JunkFilter *es_junkFilter;  /* top-level junk filter, if any */
 
    /* If query can insert/delete tuples, the command ID to mark them with */
    CommandId   es_output_cid;
 
    /* Info about target table(s) for insert/update/delete queries: */
    ResultRelInfo **es_result_relations;    /* Array of per-range-table-entry
                                             * ResultRelInfo pointers, or NULL
                                             * if not a target table */
    List       *es_opened_result_relations; /* List of non-NULL entries in
                                             * es_result_relations in no
                                             * specific order */
 
    PartitionDirectory es_partition_directory;  /* for PartitionDesc lookup */
 
    /*
     * The following list contains ResultRelInfos created by the tuple routing
     * code for partitions that aren't found in the es_result_relations array.
     */
    List       *es_tuple_routing_result_relations;
 
    /* Stuff used for firing triggers: */
    List       *es_trig_target_relations;   /* trigger-only ResultRelInfos */
 
    /* Parameter info: */
    ParamListInfo es_param_list_info;   /* values of external params */
    ParamExecData *es_param_exec_vals;  /* values of internal params */
 
    QueryEnvironment *es_queryEnv;  /* query environment */
 
    /* Other working state: */
    MemoryContext es_query_cxt; /* per-query context in which EState lives */
 
    List       *es_tupleTable;  /* List of TupleTableSlots */
 
    uint64      es_processed;   /* # of tuples processed during one
                                 * ExecutorRun() call. */
    uint64      es_total_processed; /* total # of tuples aggregated across all
                                     * ExecutorRun() calls. */
 
    int         es_top_eflags;  /* eflags passed to ExecutorStart */
    int         es_instrument;  /* OR of InstrumentOption flags */
    bool        es_finished;    /* true when ExecutorFinish is done */
 
    List       *es_exprcontexts;    /* List of ExprContexts within EState */
 
    List       *es_subplanstates;   /* List of PlanState for SubPlans */
 
    List       *es_auxmodifytables; /* List of secondary ModifyTableStates */
 
    /*
     * this ExprContext is for per-output-tuple operations, such as constraint
     * checks and index-value computations.  It will be reset for each output
     * tuple.  Note that it will be created only if needed.
     */
    ExprContext *es_per_tuple_exprcontext;
 
    /*
     * If not NULL, this is an EPQState's EState. This is a field in EState
     * both to allow EvalPlanQual aware executor nodes to detect that they
     * need to perform EPQ related work, and to provide necessary information
     * to do so.
     */
    struct EPQState *es_epq_active;
 
    bool        es_use_parallel_mode;   /* can we use parallel workers? */
 
    int         es_parallel_workers_to_launch;  /* number of workers to
                                                 * launch. */
    int         es_parallel_workers_launched;   /* number of workers actually
                                                 * launched. */
 
    /* The per-query shared memory area to use for parallel execution. */
    struct dsa_area *es_query_dsa;
 
    /*
     * JIT information. es_jit_flags indicates whether JIT should be performed
     * and with which options.  es_jit is created on-demand when JITing is
     * performed.
     *
     * es_jit_worker_instr is the combined, on demand allocated,
     * instrumentation from all workers. The leader's instrumentation is kept
     * separate, and is combined on demand by ExplainPrintJITSummary().
     */
    int         es_jit_flags;
    struct JitContext *es_jit;
    struct JitInstrumentation *es_jit_worker_instr;
 
    /*
     * Lists of ResultRelInfos for foreign tables on which batch-inserts are
     * to be executed and owning ModifyTableStates, stored in the same order.
     */
    List       *es_insert_pending_result_relations;
    List       *es_insert_pending_modifytables;
} EState;
 
 
/*
 * ExecRowMark -
 *     runtime representation of FOR [KEY] UPDATE/SHARE clauses
 *
 * When doing UPDATE/DELETE/MERGE/SELECT FOR [KEY] UPDATE/SHARE, we will have
 * an ExecRowMark for each non-target relation in the query (except inheritance
 * parent RTEs, which can be ignored at runtime).  Virtual relations such as
 * subqueries-in-FROM will have an ExecRowMark with relation == NULL.  See
 * PlanRowMark for details about most of the fields.  In addition to fields
 * directly derived from PlanRowMark, we store an activity flag (to denote
 * inactive children of inheritance trees), curCtid, which is used by the
 * WHERE CURRENT OF code, and ermExtra, which is available for use by the plan
 * node that sources the relation (e.g., for a foreign table the FDW can use
 * ermExtra to hold information).
 *
 * EState->es_rowmarks is an array of these structs, indexed by RT index,
 * with NULLs for irrelevant RT indexes.  es_rowmarks itself is NULL if
 * there are no rowmarks.
 */
typedef struct ExecRowMark
{
    Relation    relation;       /* opened and suitably locked relation */
    Oid         relid;          /* its OID (or InvalidOid, if subquery) */
    Index       rti;            /* its range table index */
    Index       prti;           /* parent range table index, if child */
    Index       rowmarkId;      /* unique identifier for resjunk columns */
    RowMarkType markType;       /* see enum in nodes/plannodes.h */
    LockClauseStrength strength;    /* LockingClause's strength, or LCS_NONE */
    LockWaitPolicy waitPolicy;  /* NOWAIT and SKIP LOCKED */
    bool        ermActive;      /* is this mark relevant for current tuple? */
    ItemPointerData curCtid;    /* ctid of currently locked tuple, if any */
    void       *ermExtra;       /* available for use by relation source node */
} ExecRowMark;
 
/*
 * ExecAuxRowMark -
 *     additional runtime representation of FOR [KEY] UPDATE/SHARE clauses
 *
 * Each LockRows and ModifyTable node keeps a list of the rowmarks it needs to
 * deal with.  In addition to a pointer to the related entry in es_rowmarks,
 * this struct carries the column number(s) of the resjunk columns associated
 * with the rowmark (see comments for PlanRowMark for more detail).
 */
typedef struct ExecAuxRowMark
{
    ExecRowMark *rowmark;       /* related entry in es_rowmarks */
    AttrNumber  ctidAttNo;      /* resno of ctid junk attribute, if any */
    AttrNumber  toidAttNo;      /* resno of tableoid junk attribute, if any */
    AttrNumber  wholeAttNo;     /* resno of whole-row junk attribute, if any */
} ExecAuxRowMark;
 
 
/* ----------------------------------------------------------------
 *               Tuple Hash Tables
 *
 * All-in-memory tuple hash tables are used for a number of purposes.
 *
 * Note: tab_hash_expr is for hashing the key datatype(s) stored in the table,
 * and tab_eq_func is a non-cross-type ExprState for equality checks on those
 * types.  Normally these are the only ExprStates used, but
 * FindTupleHashEntry() supports searching a hashtable using cross-data-type
 * hashing.  For that, the caller must supply an ExprState to hash the LHS
 * datatype as well as the cross-type equality ExprState to use.  in_hash_expr
 * and cur_eq_func are set to point to the caller's hash and equality
 * ExprStates while doing such a search.  During LookupTupleHashEntry(), they
 * point to tab_hash_expr and tab_eq_func respectively.
 * ----------------------------------------------------------------
 */
typedef struct TupleHashEntryData *TupleHashEntry;
typedef struct TupleHashTableData *TupleHashTable;
 
/*
 * TupleHashEntryData is a slot in the tuplehash_hash table.  If it's
 * populated, it contains a pointer to a MinimalTuple that can also have
 * associated "additional data".  That's stored in the TupleHashTable's
 * tuplescxt.
 */
typedef struct TupleHashEntryData
{
    MinimalTuple firstTuple;    /* -> copy of first tuple in this group */
    uint32      status;         /* hash status */
    uint32      hash;           /* hash value (cached) */
} TupleHashEntryData;
 
/* define parameters necessary to generate the tuple hash table interface */
#define SH_PREFIX tuplehash
#define SH_ELEMENT_TYPE TupleHashEntryData
#define SH_KEY_TYPE MinimalTuple
#define SH_SCOPE extern
#define SH_DECLARE
#include "lib/simplehash.h"
 
typedef struct TupleHashTableData
{
    tuplehash_hash *hashtab;    /* underlying simplehash hash table */
    int         numCols;        /* number of columns in lookup key */
    AttrNumber *keyColIdx;      /* attr numbers of key columns */
    ExprState  *tab_hash_expr;  /* ExprState for hashing table datatype(s) */
    ExprState  *tab_eq_func;    /* comparator for table datatype(s) */
    Oid        *tab_collations; /* collations for hash and comparison */
    MemoryContext tuplescxt;    /* memory context storing hashed tuples */
    MemoryContext tempcxt;      /* context for function evaluations */
    Size        additionalsize; /* size of additional data */
    TupleTableSlot *tableslot;  /* slot for referencing table entries */
    /* The following fields are set transiently for each table search: */
    TupleTableSlot *inputslot;  /* current input tuple's slot */
    ExprState  *in_hash_expr;   /* ExprState for hashing input datatype(s) */
    ExprState  *cur_eq_func;    /* comparator for input vs. table */
    ExprContext *exprcontext;   /* expression context */
} TupleHashTableData;
 
typedef tuplehash_iterator TupleHashIterator;
 
/*
 * Use InitTupleHashIterator/TermTupleHashIterator for a read/write scan.
 * Use ResetTupleHashIterator if the table can be frozen (in this case no
 * explicit scan termination is needed).
 */
#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)
 
 
/* ----------------------------------------------------------------
 *               Expression State Nodes
 *
 * Formerly, there was a separate executor expression state node corresponding
 * to each node in a planned expression tree.  That's no longer the case; for
 * common expression node types, all the execution info is embedded into
 * step(s) in a single ExprState node.  But we still have a few executor state
 * node types for selected expression node types, mostly those in which info
 * has to be shared with other parts of the execution state tree.
 * ----------------------------------------------------------------
 */
 
/* ----------------
 *      WindowFuncExprState node
 * ----------------
 */
typedef struct WindowFuncExprState
{
    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 */