granicus.if.org Git - postgresql/blob - src/include/nodes/execnodes.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * execnodes.h
   4  *        definitions for executor state nodes
   5  *
   6  *
   7  * Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group
   8  * Portions Copyright (c) 1994, Regents of the University of California
   9  *
  10  * src/include/nodes/execnodes.h
  11  *
  12  *-------------------------------------------------------------------------
  13  */
  14 #ifndef EXECNODES_H
  15 #define EXECNODES_H
  16
  17 #include "access/genam.h"
  18 #include "access/heapam.h"
  19 #include "executor/instrument.h"
  20 #include "nodes/params.h"
  21 #include "nodes/plannodes.h"
  22 #include "utils/reltrigger.h"
  23 #include "utils/sortsupport.h"
  24 #include "utils/tuplestore.h"
  25
  26
  27 /* ----------------
  28  *        IndexInfo information
  29  *
  30  *              this struct holds the information needed to construct new index
  31  *              entries for a particular index.  Used for both index_build and
  32  *              retail creation of index entries.
  33  *
  34  *              NumIndexAttrs           number of columns in this index
  35  *              KeyAttrNumbers          underlying-rel attribute numbers used as keys
  36  *                                                      (zeroes indicate expressions)
  37  *              Expressions                     expr trees for expression entries, or NIL if none
  38  *              ExpressionsState        exec state for expressions, or NIL if none
  39  *              Predicate                       partial-index predicate, or NIL if none
  40  *              PredicateState          exec state for predicate, or NIL if none
  41  *              ExclusionOps            Per-column exclusion operators, or NULL if none
  42  *              ExclusionProcs          Underlying function OIDs for ExclusionOps
  43  *              ExclusionStrats         Opclass strategy numbers for ExclusionOps
  44  *              Unique                          is it a unique index?
  45  *              ReadyForInserts         is it valid for inserts?
  46  *              Concurrent                      are we doing a concurrent index build?
  47  *              BrokenHotChain          did we detect any broken HOT chains?
  48  *
  49  * ii_Concurrent and ii_BrokenHotChain are used only during index build;
  50  * they're conventionally set to false otherwise.
  51  * ----------------
  52  */
  53 typedef struct IndexInfo
  54 {
  55         NodeTag         type;
  56         int                     ii_NumIndexAttrs;
  57         AttrNumber      ii_KeyAttrNumbers[INDEX_MAX_KEYS];
  58         List       *ii_Expressions; /* list of Expr */
  59         List       *ii_ExpressionsState;        /* list of ExprState */
  60         List       *ii_Predicate;       /* list of Expr */
  61         List       *ii_PredicateState;          /* list of ExprState */
  62         Oid                *ii_ExclusionOps;    /* array with one entry per column */
  63         Oid                *ii_ExclusionProcs;          /* array with one entry per column */
  64         uint16     *ii_ExclusionStrats;         /* array with one entry per column */
  65         bool            ii_Unique;
  66         bool            ii_ReadyForInserts;
  67         bool            ii_Concurrent;
  68         bool            ii_BrokenHotChain;
  69 } IndexInfo;
  70
  71 /* ----------------
  72  *        ExprContext_CB
  73  *
  74  *              List of callbacks to be called at ExprContext shutdown.
  75  * ----------------
  76  */
  77 typedef void (*ExprContextCallbackFunction) (Datum arg);
  78
  79 typedef struct ExprContext_CB
  80 {
  81         struct ExprContext_CB *next;
  82         ExprContextCallbackFunction function;
  83         Datum           arg;
  84 } ExprContext_CB;
  85
  86 /* ----------------
  87  *        ExprContext
  88  *
  89  *              This class holds the "current context" information
  90  *              needed to evaluate expressions for doing tuple qualifications
  91  *              and tuple projections.  For example, if an expression refers
  92  *              to an attribute in the current inner tuple then we need to know
  93  *              what the current inner tuple is and so we look at the expression
  94  *              context.
  95  *
  96  *      There are two memory contexts associated with an ExprContext:
  97  *      * ecxt_per_query_memory is a query-lifespan context, typically the same
  98  *        context the ExprContext node itself is allocated in.  This context
  99  *        can be used for purposes such as storing function call cache info.
 100  *      * ecxt_per_tuple_memory is a short-term context for expression results.
 101  *        As the name suggests, it will typically be reset once per tuple,
 102  *        before we begin to evaluate expressions for that tuple.  Each
 103  *        ExprContext normally has its very own per-tuple memory context.
 104  *
 105  *      CurrentMemoryContext should be set to ecxt_per_tuple_memory before
 106  *      calling ExecEvalExpr() --- see ExecEvalExprSwitchContext().
 107  * ----------------
 108  */
 109 typedef struct ExprContext
 110 {
 111         NodeTag         type;
 112
 113         /* Tuples that Var nodes in expression may refer to */
 114         TupleTableSlot *ecxt_scantuple;
 115         TupleTableSlot *ecxt_innertuple;
 116         TupleTableSlot *ecxt_outertuple;
 117
 118         /* Memory contexts for expression evaluation --- see notes above */
 119         MemoryContext ecxt_per_query_memory;
 120         MemoryContext ecxt_per_tuple_memory;
 121
 122         /* Values to substitute for Param nodes in expression */
 123         ParamExecData *ecxt_param_exec_vals;            /* for PARAM_EXEC params */
 124         ParamListInfo ecxt_param_list_info; /* for other param types */
 125
 126         /*
 127          * Values to substitute for Aggref nodes in the expressions of an Agg
 128          * node, or for WindowFunc nodes within a WindowAgg node.
 129          */
 130         Datum      *ecxt_aggvalues; /* precomputed values for aggs/windowfuncs */
 131         bool       *ecxt_aggnulls;      /* null flags for aggs/windowfuncs */
 132
 133         /* Value to substitute for CaseTestExpr nodes in expression */
 134         Datum           caseValue_datum;
 135         bool            caseValue_isNull;
 136
 137         /* Value to substitute for CoerceToDomainValue nodes in expression */
 138         Datum           domainValue_datum;
 139         bool            domainValue_isNull;
 140
 141         /* Link to containing EState (NULL if a standalone ExprContext) */
 142         struct EState *ecxt_estate;
 143
 144         /* Functions to call back when ExprContext is shut down or rescanned */
 145         ExprContext_CB *ecxt_callbacks;
 146 } ExprContext;
 147
 148 /*
 149  * Set-result status returned by ExecEvalExpr()
 150  */
 151 typedef enum
 152 {
 153         ExprSingleResult,                       /* expression does not return a set */
 154         ExprMultipleResult,                     /* this result is an element of a set */
 155         ExprEndResult                           /* there are no more elements in the set */
 156 } ExprDoneCond;
 157
 158 /*
 159  * Return modes for functions returning sets.  Note values must be chosen
 160  * as separate bits so that a bitmask can be formed to indicate supported
 161  * modes.  SFRM_Materialize_Random and SFRM_Materialize_Preferred are
 162  * auxiliary flags about SFRM_Materialize mode, rather than separate modes.
 163  */
 164 typedef enum
 165 {
 166         SFRM_ValuePerCall = 0x01,       /* one value returned per call */
 167         SFRM_Materialize = 0x02,        /* result set instantiated in Tuplestore */
 168         SFRM_Materialize_Random = 0x04,         /* Tuplestore needs randomAccess */
 169         SFRM_Materialize_Preferred = 0x08       /* caller prefers Tuplestore */
 170 } SetFunctionReturnMode;
 171
 172 /*
 173  * When calling a function that might return a set (multiple rows),
 174  * a node of this type is passed as fcinfo->resultinfo to allow
 175  * return status to be passed back.  A function returning set should
 176  * raise an error if no such resultinfo is provided.
 177  */
 178 typedef struct ReturnSetInfo
 179 {
 180         NodeTag         type;
 181         /* values set by caller: */
 182         ExprContext *econtext;          /* context function is being called in */
 183         TupleDesc       expectedDesc;   /* tuple descriptor expected by caller */
 184         int                     allowedModes;   /* bitmask: return modes caller can handle */
 185         /* result status from function (but pre-initialized by caller): */
 186         SetFunctionReturnMode returnMode;       /* actual return mode */
 187         ExprDoneCond isDone;            /* status for ValuePerCall mode */
 188         /* fields filled by function in Materialize return mode: */
 189         Tuplestorestate *setResult; /* holds the complete returned tuple set */
 190         TupleDesc       setDesc;                /* actual descriptor for returned tuples */
 191 } ReturnSetInfo;
 192
 193 /* ----------------
 194  *              ProjectionInfo node information
 195  *
 196  *              This is all the information needed to perform projections ---
 197  *              that is, form new tuples by evaluation of targetlist expressions.
 198  *              Nodes which need to do projections create one of these.
 199  *
 200  *              ExecProject() evaluates the tlist, forms a tuple, and stores it
 201  *              in the given slot.  Note that the result will be a "virtual" tuple
 202  *              unless ExecMaterializeSlot() is then called to force it to be
 203  *              converted to a physical tuple.  The slot must have a tupledesc
 204  *              that matches the output of the tlist!
 205  *
 206  *              The planner very often produces tlists that consist entirely of
 207  *              simple Var references (lower levels of a plan tree almost always
 208  *              look like that).  And top-level tlists are often mostly Vars too.
 209  *              We therefore optimize execution of simple-Var tlist entries.
 210  *              The pi_targetlist list actually contains only the tlist entries that
 211  *              aren't simple Vars, while those that are Vars are processed using the
 212  *              varSlotOffsets/varNumbers/varOutputCols arrays.
 213  *
 214  *              The lastXXXVar fields are used to optimize fetching of fields from
 215  *              input tuples: they let us do a slot_getsomeattrs() call to ensure
 216  *              that all needed attributes are extracted in one pass.
 217  *
 218  *              targetlist              target list for projection (non-Var expressions only)
 219  *              exprContext             expression context in which to evaluate targetlist
 220  *              slot                    slot to place projection result in
 221  *              itemIsDone              workspace array for ExecProject
 222  *              directMap               true if varOutputCols[] is an identity map
 223  *              numSimpleVars   number of simple Vars found in original tlist
 224  *              varSlotOffsets  array indicating which slot each simple Var is from
 225  *              varNumbers              array containing input attr numbers of simple Vars
 226  *              varOutputCols   array containing output attr numbers of simple Vars
 227  *              lastInnerVar    highest attnum from inner tuple slot (0 if none)
 228  *              lastOuterVar    highest attnum from outer tuple slot (0 if none)
 229  *              lastScanVar             highest attnum from scan tuple slot (0 if none)
 230  * ----------------
 231  */
 232 typedef struct ProjectionInfo
 233 {
 234         NodeTag         type;
 235         List       *pi_targetlist;
 236         ExprContext *pi_exprContext;
 237         TupleTableSlot *pi_slot;
 238         ExprDoneCond *pi_itemIsDone;
 239         bool            pi_directMap;
 240         int                     pi_numSimpleVars;
 241         int                *pi_varSlotOffsets;
 242         int                *pi_varNumbers;
 243         int                *pi_varOutputCols;
 244         int                     pi_lastInnerVar;
 245         int                     pi_lastOuterVar;
 246         int                     pi_lastScanVar;
 247 } ProjectionInfo;
 248
 249 /* ----------------
 250  *        JunkFilter
 251  *
 252  *        This class is used to store information regarding junk attributes.
 253  *        A junk attribute is an attribute in a tuple that is needed only for
 254  *        storing intermediate information in the executor, and does not belong
 255  *        in emitted tuples.  For example, when we do an UPDATE query,
 256  *        the planner adds a "junk" entry to the targetlist so that the tuples
 257  *        returned to ExecutePlan() contain an extra attribute: the ctid of
 258  *        the tuple to be updated.  This is needed to do the update, but we
 259  *        don't want the ctid to be part of the stored new tuple!  So, we
 260  *        apply a "junk filter" to remove the junk attributes and form the
 261  *        real output tuple.  The junkfilter code also provides routines to
 262  *        extract the values of the junk attribute(s) from the input tuple.
 263  *
 264  *        targetList:           the original target list (including junk attributes).
 265  *        cleanTupType:         the tuple descriptor for the "clean" tuple (with
 266  *                                              junk attributes removed).
 267  *        cleanMap:                     A map with the correspondence between the non-junk
 268  *                                              attribute numbers of the "original" tuple and the
 269  *                                              attribute numbers of the "clean" tuple.
 270  *        resultSlot:           tuple slot used to hold cleaned tuple.
 271  *        junkAttNo:            not used by junkfilter code.  Can be used by caller
 272  *                                              to remember the attno of a specific junk attribute
 273  *                                              (nodeModifyTable.c keeps the "ctid" or "wholerow"
 274  *                                              attno here).
 275  * ----------------
 276  */
 277 typedef struct JunkFilter
 278 {
 279         NodeTag         type;
 280         List       *jf_targetList;
 281         TupleDesc       jf_cleanTupType;
 282         AttrNumber *jf_cleanMap;
 283         TupleTableSlot *jf_resultSlot;
 284         AttrNumber      jf_junkAttNo;
 285 } JunkFilter;
 286
 287 /* ----------------
 288  *        ResultRelInfo information
 289  *
 290  *              Whenever we update an existing relation, we have to
 291  *              update indices on the relation, and perhaps also fire triggers.
 292  *              The ResultRelInfo class is used to hold all the information needed
 293  *              about a result relation, including indices.. -cim 10/15/89
 294  *
 295  *              RangeTableIndex                 result relation's range table index
 296  *              RelationDesc                    relation descriptor for result relation
 297  *              NumIndices                              # of indices existing on result relation
 298  *              IndexRelationDescs              array of relation descriptors for indices
 299  *              IndexRelationInfo               array of key/attr info for indices
 300  *              TrigDesc                                triggers to be fired, if any
 301  *              TrigFunctions                   cached lookup info for trigger functions
 302  *              TrigWhenExprs                   array of trigger WHEN expr states
 303  *              TrigInstrument                  optional runtime measurements for triggers
 304  *              FdwRoutine                              FDW callback functions, if foreign table
 305  *              FdwState                                available to save private state of FDW
 306  *              WithCheckOptions                list of WithCheckOption's for views
 307  *              WithCheckOptionExprs    list of WithCheckOption expr states
 308  *              ConstraintExprs                 array of constraint-checking expr states
 309  *              junkFilter                              for removing junk attributes from tuples
 310  *              projectReturning                for computing a RETURNING list
 311  * ----------------
 312  */
 313 typedef struct ResultRelInfo
 314 {
 315         NodeTag         type;
 316         Index           ri_RangeTableIndex;
 317         Relation        ri_RelationDesc;
 318         int                     ri_NumIndices;
 319         RelationPtr ri_IndexRelationDescs;
 320         IndexInfo **ri_IndexRelationInfo;
 321         TriggerDesc *ri_TrigDesc;
 322         FmgrInfo   *ri_TrigFunctions;
 323         List      **ri_TrigWhenExprs;
 324         Instrumentation *ri_TrigInstrument;
 325         struct FdwRoutine *ri_FdwRoutine;
 326         void       *ri_FdwState;
 327         List       *ri_WithCheckOptions;
 328         List       *ri_WithCheckOptionExprs;
 329         List      **ri_ConstraintExprs;
 330         JunkFilter *ri_junkFilter;
 331         ProjectionInfo *ri_projectReturning;
 332 } ResultRelInfo;
 333
 334 /* ----------------
 335  *        EState information
 336  *
 337  * Master working state for an Executor invocation
 338  * ----------------
 339  */
 340 typedef struct EState
 341 {
 342         NodeTag         type;
 343
 344         /* Basic state for all query types: */
 345         ScanDirection es_direction; /* current scan direction */
 346         Snapshot        es_snapshot;    /* time qual to use */
 347         Snapshot        es_crosscheck_snapshot; /* crosscheck time qual for RI */
 348         List       *es_range_table; /* List of RangeTblEntry */
 349         PlannedStmt *es_plannedstmt;    /* link to top of plan tree */
 350
 351         JunkFilter *es_junkFilter;      /* top-level junk filter, if any */
 352
 353         /* If query can insert/delete tuples, the command ID to mark them with */
 354         CommandId       es_output_cid;
 355
 356         /* Info about target table(s) for insert/update/delete queries: */
 357         ResultRelInfo *es_result_relations; /* array of ResultRelInfos */
 358         int                     es_num_result_relations;                /* length of array */
 359         ResultRelInfo *es_result_relation_info;         /* currently active array elt */
 360
 361         /* Stuff used for firing triggers: */
 362         List       *es_trig_target_relations;           /* trigger-only ResultRelInfos */
 363         TupleTableSlot *es_trig_tuple_slot; /* for trigger output tuples */
 364         TupleTableSlot *es_trig_oldtup_slot;            /* for TriggerEnabled */
 365         TupleTableSlot *es_trig_newtup_slot;            /* for TriggerEnabled */
 366
 367         /* Parameter info: */
 368         ParamListInfo es_param_list_info;       /* values of external params */
 369         ParamExecData *es_param_exec_vals;      /* values of internal params */
 370
 371         /* Other working state: */
 372         MemoryContext es_query_cxt; /* per-query context in which EState lives */
 373
 374         List       *es_tupleTable;      /* List of TupleTableSlots */
 375
 376         List       *es_rowMarks;        /* List of ExecRowMarks */
 377
 378         uint32          es_processed;   /* # of tuples processed */
 379         Oid                     es_lastoid;             /* last oid processed (by INSERT) */
 380
 381         int                     es_top_eflags;  /* eflags passed to ExecutorStart */
 382         int                     es_instrument;  /* OR of InstrumentOption flags */
 383         bool            es_finished;    /* true when ExecutorFinish is done */
 384
 385         List       *es_exprcontexts;    /* List of ExprContexts within EState */
 386
 387         List       *es_subplanstates;           /* List of PlanState for SubPlans */
 388
 389         List       *es_auxmodifytables;         /* List of secondary ModifyTableStates */
 390
 391         /*
 392          * this ExprContext is for per-output-tuple operations, such as constraint
 393          * checks and index-value computations.  It will be reset for each output
 394          * tuple.  Note that it will be created only if needed.
 395          */
 396         ExprContext *es_per_tuple_exprcontext;
 397
 398         /*
 399          * These fields are for re-evaluating plan quals when an updated tuple is
 400          * substituted in READ COMMITTED mode.  es_epqTuple[] contains tuples that
 401          * scan plan nodes should return instead of whatever they'd normally
 402          * return, or NULL if nothing to return; es_epqTupleSet[] is true if a
 403          * particular array entry is valid; and es_epqScanDone[] is state to
 404          * remember if the tuple has been returned already.  Arrays are of size
 405          * list_length(es_range_table) and are indexed by scan node scanrelid - 1.
 406          */
 407         HeapTuple  *es_epqTuple;        /* array of EPQ substitute tuples */
 408         bool       *es_epqTupleSet; /* true if EPQ tuple is provided */
 409         bool       *es_epqScanDone; /* true if EPQ tuple has been fetched */
 410 } EState;
 411
 412
 413 /*
 414  * ExecRowMark -
 415  *         runtime representation of FOR [KEY] UPDATE/SHARE clauses
 416  *
 417  * When doing UPDATE, DELETE, or SELECT FOR [KEY] UPDATE/SHARE, we should have an
 418  * ExecRowMark for each non-target relation in the query (except inheritance
 419  * parent RTEs, which can be ignored at runtime).  See PlanRowMark for details
 420  * about most of the fields.  In addition to fields directly derived from
 421  * PlanRowMark, we store curCtid, which is used by the WHERE CURRENT OF code.
 422  *
 423  * EState->es_rowMarks is a list of these structs.
 424  */
 425 typedef struct ExecRowMark
 426 {
 427         Relation        relation;               /* opened and suitably locked relation */
 428         Index           rti;                    /* its range table index */
 429         Index           prti;                   /* parent range table index, if child */
 430         Index           rowmarkId;              /* unique identifier for resjunk columns */
 431         RowMarkType markType;           /* see enum in nodes/plannodes.h */
 432         LockWaitPolicy waitPolicy;      /* NOWAIT and SKIP LOCKED */
 433         ItemPointerData curCtid;        /* ctid of currently locked tuple, if any */
 434 } ExecRowMark;
 435
 436 /*
 437  * ExecAuxRowMark -
 438  *         additional runtime representation of FOR [KEY] UPDATE/SHARE clauses
 439  *
 440  * Each LockRows and ModifyTable node keeps a list of the rowmarks it needs to
 441  * deal with.  In addition to a pointer to the related entry in es_rowMarks,
 442  * this struct carries the column number(s) of the resjunk columns associated
 443  * with the rowmark (see comments for PlanRowMark for more detail).  In the
 444  * case of ModifyTable, there has to be a separate ExecAuxRowMark list for
 445  * each child plan, because the resjunk columns could be at different physical
 446  * column positions in different subplans.
 447  */
 448 typedef struct ExecAuxRowMark
 449 {
 450         ExecRowMark *rowmark;           /* related entry in es_rowMarks */
 451         AttrNumber      ctidAttNo;              /* resno of ctid junk attribute, if any */
 452         AttrNumber      toidAttNo;              /* resno of tableoid junk attribute, if any */
 453         AttrNumber      wholeAttNo;             /* resno of whole-row junk attribute, if any */
 454 } ExecAuxRowMark;
 455
 456
 457 /* ----------------------------------------------------------------
 458  *                               Tuple Hash Tables
 459  *
 460  * All-in-memory tuple hash tables are used for a number of purposes.
 461  *
 462  * Note: tab_hash_funcs are for the key datatype(s) stored in the table,
 463  * and tab_eq_funcs are non-cross-type equality operators for those types.
 464  * Normally these are the only functions used, but FindTupleHashEntry()
 465  * supports searching a hashtable using cross-data-type hashing.  For that,
 466  * the caller must supply hash functions for the LHS datatype as well as
 467  * the cross-type equality operators to use.  in_hash_funcs and cur_eq_funcs
 468  * are set to point to the caller's function arrays while doing such a search.
 469  * During LookupTupleHashEntry(), they point to tab_hash_funcs and
 470  * tab_eq_funcs respectively.
 471  * ----------------------------------------------------------------
 472  */
 473 typedef struct TupleHashEntryData *TupleHashEntry;
 474 typedef struct TupleHashTableData *TupleHashTable;
 475
 476 typedef struct TupleHashEntryData
 477 {
 478         /* firstTuple must be the first field in this struct! */
 479         MinimalTuple firstTuple;        /* copy of first tuple in this group */
 480         /* there may be additional data beyond the end of this struct */
 481 } TupleHashEntryData;                   /* VARIABLE LENGTH STRUCT */
 482
 483 typedef struct TupleHashTableData
 484 {
 485         HTAB       *hashtab;            /* underlying dynahash table */
 486         int                     numCols;                /* number of columns in lookup key */
 487         AttrNumber *keyColIdx;          /* attr numbers of key columns */
 488         FmgrInfo   *tab_hash_funcs; /* hash functions for table datatype(s) */
 489         FmgrInfo   *tab_eq_funcs;       /* equality functions for table datatype(s) */
 490         MemoryContext tablecxt;         /* memory context containing table */
 491         MemoryContext tempcxt;          /* context for function evaluations */
 492         Size            entrysize;              /* actual size to make each hash entry */
 493         TupleTableSlot *tableslot;      /* slot for referencing table entries */
 494         /* The following fields are set transiently for each table search: */
 495         TupleTableSlot *inputslot;      /* current input tuple's slot */
 496         FmgrInfo   *in_hash_funcs;      /* hash functions for input datatype(s) */
 497         FmgrInfo   *cur_eq_funcs;       /* equality functions for input vs. table */
 498 }       TupleHashTableData;
 499
 500 typedef HASH_SEQ_STATUS TupleHashIterator;
 501
 502 /*
 503  * Use InitTupleHashIterator/TermTupleHashIterator for a read/write scan.
 504  * Use ResetTupleHashIterator if the table can be frozen (in this case no
 505  * explicit scan termination is needed).
 506  */
 507 #define InitTupleHashIterator(htable, iter) \
 508         hash_seq_init(iter, (htable)->hashtab)
 509 #define TermTupleHashIterator(iter) \
 510         hash_seq_term(iter)
 511 #define ResetTupleHashIterator(htable, iter) \
 512         do { \
 513                 hash_freeze((htable)->hashtab); \
 514                 hash_seq_init(iter, (htable)->hashtab); \
 515         } while (0)
 516 #define ScanTupleHashTable(iter) \
 517         ((TupleHashEntry) hash_seq_search(iter))
 518
 519
 520 /* ----------------------------------------------------------------
 521  *                               Expression State Trees
 522  *
 523  * Each executable expression tree has a parallel ExprState tree.
 524  *
 525  * Unlike PlanState, there is not an exact one-for-one correspondence between
 526  * ExprState node types and Expr node types.  Many Expr node types have no
 527  * need for node-type-specific run-time state, and so they can use plain
 528  * ExprState or GenericExprState as their associated ExprState node type.
 529  * ----------------------------------------------------------------
 530  */
 531
 532 /* ----------------
 533  *              ExprState node
 534  *
 535  * ExprState is the common superclass for all ExprState-type nodes.
 536  *
 537  * It can also be instantiated directly for leaf Expr nodes that need no
 538  * local run-time state (such as Var, Const, or Param).
 539  *
 540  * To save on dispatch overhead, each ExprState node contains a function
 541  * pointer to the routine to execute to evaluate the node.
 542  * ----------------
 543  */
 544
 545 typedef struct ExprState ExprState;
 546
 547 typedef Datum (*ExprStateEvalFunc) (ExprState *expression,
 548                                                                                                 ExprContext *econtext,
 549                                                                                                 bool *isNull,
 550                                                                                                 ExprDoneCond *isDone);
 551
 552 struct ExprState
 553 {
 554         NodeTag         type;
 555         Expr       *expr;                       /* associated Expr node */
 556         ExprStateEvalFunc evalfunc; /* routine to run to execute node */
 557 };
 558
 559 /* ----------------
 560  *              GenericExprState node
 561  *
 562  * This is used for Expr node types that need no local run-time state,
 563  * but have one child Expr node.
 564  * ----------------
 565  */
 566 typedef struct GenericExprState
 567 {
 568         ExprState       xprstate;
 569         ExprState  *arg;                        /* state of my child node */
 570 } GenericExprState;
 571
 572 /* ----------------
 573  *              WholeRowVarExprState node
 574  * ----------------
 575  */
 576 typedef struct WholeRowVarExprState
 577 {
 578         ExprState       xprstate;
 579         struct PlanState *parent;       /* parent PlanState, or NULL if none */
 580         TupleDesc       wrv_tupdesc;    /* descriptor for resulting tuples */
 581         JunkFilter *wrv_junkFilter; /* JunkFilter to remove resjunk cols */
 582 } WholeRowVarExprState;
 583
 584 /* ----------------
 585  *              AggrefExprState node
 586  * ----------------
 587  */
 588 typedef struct AggrefExprState
 589 {
 590         ExprState       xprstate;
 591         List       *aggdirectargs;      /* states of direct-argument expressions */
 592         List       *args;                       /* states of aggregated-argument expressions */
 593         ExprState  *aggfilter;          /* state of FILTER expression, if any */
 594         int                     aggno;                  /* ID number for agg within its plan node */
 595 } AggrefExprState;
 596
 597 /* ----------------
 598  *              WindowFuncExprState node
 599  * ----------------
 600  */
 601 typedef struct WindowFuncExprState
 602 {
 603         ExprState       xprstate;
 604         List       *args;                       /* states of argument expressions */
 605         ExprState  *aggfilter;          /* FILTER expression */
 606         int                     wfuncno;                /* ID number for wfunc within its plan node */
 607 } WindowFuncExprState;
 608
 609 /* ----------------
 610  *              ArrayRefExprState node
 611  *
 612  * Note: array types can be fixed-length (typlen > 0), but only when the
 613  * element type is itself fixed-length.  Otherwise they are varlena structures
 614  * and have typlen = -1.  In any case, an array type is never pass-by-value.
 615  * ----------------
 616  */
 617 typedef struct ArrayRefExprState
 618 {
 619         ExprState       xprstate;
 620         List       *refupperindexpr;    /* states for child nodes */
 621         List       *reflowerindexpr;
 622         ExprState  *refexpr;
 623         ExprState  *refassgnexpr;
 624         int16           refattrlength;  /* typlen of array type */
 625         int16           refelemlength;  /* typlen of the array element type */
 626         bool            refelembyval;   /* is the element type pass-by-value? */
 627         char            refelemalign;   /* typalign of the element type */
 628 } ArrayRefExprState;
 629
 630 /* ----------------
 631  *              FuncExprState node
 632  *
 633  * Although named for FuncExpr, this is also used for OpExpr, DistinctExpr,
 634  * and NullIf nodes; be careful to check what xprstate.expr is actually
 635  * pointing at!
 636  * ----------------
 637  */
 638 typedef struct FuncExprState
 639 {
 640         ExprState       xprstate;
 641         List       *args;                       /* states of argument expressions */
 642
 643         /*
 644          * Function manager's lookup info for the target function.  If func.fn_oid
 645          * is InvalidOid, we haven't initialized it yet (nor any of the following
 646          * fields).
 647          */
 648         FmgrInfo        func;
 649
 650         /*
 651          * For a set-returning function (SRF) that returns a tuplestore, we keep
 652          * the tuplestore here and dole out the result rows one at a time. The
 653          * slot holds the row currently being returned.
 654          */
 655         Tuplestorestate *funcResultStore;
 656         TupleTableSlot *funcResultSlot;
 657
 658         /*
 659          * In some cases we need to compute a tuple descriptor for the function's
 660          * output.  If so, it's stored here.
 661          */
 662         TupleDesc       funcResultDesc;
 663         bool            funcReturnsTuple;               /* valid when funcResultDesc isn't
 664                                                                                  * NULL */
 665
 666         /*
 667          * setArgsValid is true when we are evaluating a set-returning function
 668          * that uses value-per-call mode and we are in the middle of a call
 669          * series; we want to pass the same argument values to the function again
 670          * (and again, until it returns ExprEndResult).  This indicates that
 671          * fcinfo_data already contains valid argument data.
 672          */
 673         bool            setArgsValid;
 674
 675         /*
 676          * Flag to remember whether we found a set-valued argument to the
 677          * function. This causes the function result to be a set as well. Valid
 678          * only when setArgsValid is true or funcResultStore isn't NULL.
 679          */
 680         bool            setHasSetArg;   /* some argument returns a set */
 681
 682         /*
 683          * Flag to remember whether we have registered a shutdown callback for
 684          * this FuncExprState.  We do so only if funcResultStore or setArgsValid
 685          * has been set at least once (since all the callback is for is to release
 686          * the tuplestore or clear setArgsValid).
 687          */
 688         bool            shutdown_reg;   /* a shutdown callback is registered */
 689
 690         /*
 691          * Call parameter structure for the function.  This has been initialized
 692          * (by InitFunctionCallInfoData) if func.fn_oid is valid.  It also saves
 693          * argument values between calls, when setArgsValid is true.
 694          */
 695         FunctionCallInfoData fcinfo_data;
 696 } FuncExprState;
 697
 698 /* ----------------
 699  *              ScalarArrayOpExprState node
 700  *
 701  * This is a FuncExprState plus some additional data.
 702  * ----------------
 703  */
 704 typedef struct ScalarArrayOpExprState
 705 {
 706         FuncExprState fxprstate;
 707         /* Cached info about array element type */
 708         Oid                     element_type;
 709         int16           typlen;
 710         bool            typbyval;
 711         char            typalign;
 712 } ScalarArrayOpExprState;
 713
 714 /* ----------------
 715  *              BoolExprState node
 716  * ----------------
 717  */
 718 typedef struct BoolExprState
 719 {
 720         ExprState       xprstate;
 721         List       *args;                       /* states of argument expression(s) */
 722 } BoolExprState;
 723
 724 /* ----------------
 725  *              SubPlanState node
 726  * ----------------
 727  */
 728 typedef struct SubPlanState
 729 {
 730         ExprState       xprstate;
 731         struct PlanState *planstate;    /* subselect plan's state tree */
 732         struct PlanState *parent;       /* parent plan node's state tree */
 733         ExprState  *testexpr;           /* state of combining expression */
 734         List       *args;                       /* states of argument expression(s) */
 735         HeapTuple       curTuple;               /* copy of most recent tuple from subplan */
 736         Datum           curArray;               /* most recent array from ARRAY() subplan */
 737         /* these are used when hashing the subselect's output: */
 738         ProjectionInfo *projLeft;       /* for projecting lefthand exprs */
 739         ProjectionInfo *projRight;      /* for projecting subselect output */
 740         TupleHashTable hashtable;       /* hash table for no-nulls subselect rows */
 741         TupleHashTable hashnulls;       /* hash table for rows with null(s) */
 742         bool            havehashrows;   /* TRUE if hashtable is not empty */
 743         bool            havenullrows;   /* TRUE if hashnulls is not empty */
 744         MemoryContext hashtablecxt; /* memory context containing hash tables */
 745         MemoryContext hashtempcxt;      /* temp memory context for hash tables */
 746         ExprContext *innerecontext; /* econtext for computing inner tuples */
 747         AttrNumber *keyColIdx;          /* control data for hash tables */
 748         FmgrInfo   *tab_hash_funcs; /* hash functions for table datatype(s) */
 749         FmgrInfo   *tab_eq_funcs;       /* equality functions for table datatype(s) */
 750         FmgrInfo   *lhs_hash_funcs; /* hash functions for lefthand datatype(s) */
 751         FmgrInfo   *cur_eq_funcs;       /* equality functions for LHS vs. table */
 752 } SubPlanState;
 753
 754 /* ----------------
 755  *              AlternativeSubPlanState node
 756  * ----------------
 757  */
 758 typedef struct AlternativeSubPlanState
 759 {
 760         ExprState       xprstate;
 761         List       *subplans;           /* states of alternative subplans */
 762         int                     active;                 /* list index of the one we're using */
 763 } AlternativeSubPlanState;
 764
 765 /* ----------------
 766  *              FieldSelectState node
 767  * ----------------
 768  */
 769 typedef struct FieldSelectState
 770 {
 771         ExprState       xprstate;
 772         ExprState  *arg;                        /* input expression */
 773         TupleDesc       argdesc;                /* tupdesc for most recent input */
 774 } FieldSelectState;
 775
 776 /* ----------------
 777  *              FieldStoreState node
 778  * ----------------
 779  */
 780 typedef struct FieldStoreState
 781 {
 782         ExprState       xprstate;
 783         ExprState  *arg;                        /* input tuple value */
 784         List       *newvals;            /* new value(s) for field(s) */
 785         TupleDesc       argdesc;                /* tupdesc for most recent input */
 786 } FieldStoreState;
 787
 788 /* ----------------
 789  *              CoerceViaIOState node
 790  * ----------------
 791  */
 792 typedef struct CoerceViaIOState
 793 {
 794         ExprState       xprstate;
 795         ExprState  *arg;                        /* input expression */
 796         FmgrInfo        outfunc;                /* lookup info for source output function */
 797         FmgrInfo        infunc;                 /* lookup info for result input function */
 798         Oid                     intypioparam;   /* argument needed for input function */
 799 } CoerceViaIOState;
 800
 801 /* ----------------
 802  *              ArrayCoerceExprState node
 803  * ----------------
 804  */
 805 typedef struct ArrayCoerceExprState
 806 {
 807         ExprState       xprstate;
 808         ExprState  *arg;                        /* input array value */
 809         Oid                     resultelemtype; /* element type of result array */
 810         FmgrInfo        elemfunc;               /* lookup info for element coercion function */
 811         /* use struct pointer to avoid including array.h here */
 812         struct ArrayMapState *amstate;          /* workspace for array_map */
 813 } ArrayCoerceExprState;
 814
 815 /* ----------------
 816  *              ConvertRowtypeExprState node
 817  * ----------------
 818  */
 819 typedef struct ConvertRowtypeExprState
 820 {
 821         ExprState       xprstate;
 822         ExprState  *arg;                        /* input tuple value */
 823         TupleDesc       indesc;                 /* tupdesc for source rowtype */
 824         TupleDesc       outdesc;                /* tupdesc for result rowtype */
 825         /* use "struct" so we needn't include tupconvert.h here */
 826         struct TupleConversionMap *map;
 827         bool            initialized;
 828 } ConvertRowtypeExprState;
 829
 830 /* ----------------
 831  *              CaseExprState node
 832  * ----------------
 833  */
 834 typedef struct CaseExprState
 835 {
 836         ExprState       xprstate;
 837         ExprState  *arg;                        /* implicit equality comparison argument */
 838         List       *args;                       /* the arguments (list of WHEN clauses) */
 839         ExprState  *defresult;          /* the default result (ELSE clause) */
 840 } CaseExprState;
 841
 842 /* ----------------
 843  *              CaseWhenState node
 844  * ----------------
 845  */
 846 typedef struct CaseWhenState
 847 {
 848         ExprState       xprstate;
 849         ExprState  *expr;                       /* condition expression */
 850         ExprState  *result;                     /* substitution result */
 851 } CaseWhenState;
 852
 853 /* ----------------
 854  *              ArrayExprState node
 855  *
 856  * Note: ARRAY[] expressions always produce varlena arrays, never fixed-length
 857  * arrays.
 858  * ----------------
 859  */
 860 typedef struct ArrayExprState
 861 {
 862         ExprState       xprstate;
 863         List       *elements;           /* states for child nodes */
 864         int16           elemlength;             /* typlen of the array element type */
 865         bool            elembyval;              /* is the element type pass-by-value? */
 866         char            elemalign;              /* typalign of the element type */
 867 } ArrayExprState;
 868
 869 /* ----------------
 870  *              RowExprState node
 871  * ----------------
 872  */
 873 typedef struct RowExprState
 874 {
 875         ExprState       xprstate;
 876         List       *args;                       /* the arguments */
 877         TupleDesc       tupdesc;                /* descriptor for result tuples */
 878 } RowExprState;
 879
 880 /* ----------------
 881  *              RowCompareExprState node
 882  * ----------------
 883  */
 884 typedef struct RowCompareExprState
 885 {
 886         ExprState       xprstate;
 887         List       *largs;                      /* the left-hand input arguments */
 888         List       *rargs;                      /* the right-hand input arguments */
 889         FmgrInfo   *funcs;                      /* array of comparison function info */
 890         Oid                *collations;         /* array of collations to use */
 891 } RowCompareExprState;
 892
 893 /* ----------------
 894  *              CoalesceExprState node
 895  * ----------------
 896  */
 897 typedef struct CoalesceExprState
 898 {
 899         ExprState       xprstate;
 900         List       *args;                       /* the arguments */
 901 } CoalesceExprState;
 902
 903 /* ----------------
 904  *              MinMaxExprState node
 905  * ----------------
 906  */
 907 typedef struct MinMaxExprState
 908 {
 909         ExprState       xprstate;
 910         List       *args;                       /* the arguments */
 911         FmgrInfo        cfunc;                  /* lookup info for comparison func */
 912 } MinMaxExprState;
 913
 914 /* ----------------
 915  *              XmlExprState node
 916  * ----------------
 917  */
 918 typedef struct XmlExprState
 919 {
 920         ExprState       xprstate;
 921         List       *named_args;         /* ExprStates for named arguments */
 922         List       *args;                       /* ExprStates for other arguments */
 923 } XmlExprState;
 924
 925 /* ----------------
 926  *              NullTestState node
 927  * ----------------
 928  */
 929 typedef struct NullTestState
 930 {
 931         ExprState       xprstate;
 932         ExprState  *arg;                        /* input expression */
 933         /* used only if input is of composite type: */
 934         TupleDesc       argdesc;                /* tupdesc for most recent input */
 935 } NullTestState;
 936
 937 /* ----------------
 938  *              CoerceToDomainState node
 939  * ----------------
 940  */
 941 typedef struct CoerceToDomainState
 942 {
 943         ExprState       xprstate;
 944         ExprState  *arg;                        /* input expression */
 945         /* Cached list of constraints that need to be checked */
 946         List       *constraints;        /* list of DomainConstraintState nodes */
 947 } CoerceToDomainState;
 948
 949 /*
 950  * DomainConstraintState - one item to check during CoerceToDomain
 951  *
 952  * Note: this is just a Node, and not an ExprState, because it has no
 953  * corresponding Expr to link to.  Nonetheless it is part of an ExprState
 954  * tree, so we give it a name following the xxxState convention.
 955  */
 956 typedef enum DomainConstraintType
 957 {
 958         DOM_CONSTRAINT_NOTNULL,
 959         DOM_CONSTRAINT_CHECK
 960 } DomainConstraintType;
 961
 962 typedef struct DomainConstraintState
 963 {
 964         NodeTag         type;
 965         DomainConstraintType constrainttype;            /* constraint type */
 966         char       *name;                       /* name of constraint (for error msgs) */
 967         ExprState  *check_expr;         /* for CHECK, a boolean expression */
 968 } DomainConstraintState;
 969
 970
 971 /* ----------------------------------------------------------------
 972  *                               Executor State Trees
 973  *
 974  * An executing query has a PlanState tree paralleling the Plan tree
 975  * that describes the plan.
 976  * ----------------------------------------------------------------
 977  */
 978
 979 /* ----------------
 980  *              PlanState node
 981  *
 982  * We never actually instantiate any PlanState nodes; this is just the common
 983  * abstract superclass for all PlanState-type nodes.
 984  * ----------------
 985  */
 986 typedef struct PlanState
 987 {
 988         NodeTag         type;
 989
 990         Plan       *plan;                       /* associated Plan node */
 991
 992         EState     *state;                      /* at execution time, states of individual
 993                                                                  * nodes point to one EState for the whole
 994                                                                  * top-level plan */
 995
 996         Instrumentation *instrument;    /* Optional runtime stats for this node */
 997
 998         /*
 999          * Common structural data for all Plan types.  These links to subsidiary
1000          * state trees parallel links in the associated plan tree (except for the
1001          * subPlan list, which does not exist in the plan tree).
1002          */
1003         List       *targetlist;         /* target list to be computed at this node */
1004         List       *qual;                       /* implicitly-ANDed qual conditions */
1005         struct PlanState *lefttree; /* input plan tree(s) */
1006         struct PlanState *righttree;
1007         List       *initPlan;           /* Init SubPlanState nodes (un-correlated expr
1008                                                                  * subselects) */
1009         List       *subPlan;            /* SubPlanState nodes in my expressions */
1010
1011         /*
1012          * State for management of parameter-change-driven rescanning
1013          */
1014         Bitmapset  *chgParam;           /* set of IDs of changed Params */
1015
1016         /*
1017          * Other run-time state needed by most if not all node types.
1018          */
1019         TupleTableSlot *ps_ResultTupleSlot; /* slot for my result tuples */
1020         ExprContext *ps_ExprContext;    /* node's expression-evaluation context */
1021         ProjectionInfo *ps_ProjInfo;    /* info for doing tuple projection */
1022         bool            ps_TupFromTlist;/* state flag for processing set-valued
1023                                                                  * functions in targetlist */
1024 } PlanState;
1025
1026 /* ----------------
1027  *      these are defined to avoid confusion problems with "left"
1028  *      and "right" and "inner" and "outer".  The convention is that
1029  *      the "left" plan is the "outer" plan and the "right" plan is
1030  *      the inner plan, but these make the code more readable.
1031  * ----------------
1032  */
1033 #define innerPlanState(node)            (((PlanState *)(node))->righttree)
1034 #define outerPlanState(node)            (((PlanState *)(node))->lefttree)
1035
1036 /* Macros for inline access to certain instrumentation counters */
1037 #define InstrCountFiltered1(node, delta) \
1038         do { \
1039                 if (((PlanState *)(node))->instrument) \
1040                         ((PlanState *)(node))->instrument->nfiltered1 += (delta); \
1041         } while(0)
1042 #define InstrCountFiltered2(node, delta) \
1043         do { \
1044                 if (((PlanState *)(node))->instrument) \
1045                         ((PlanState *)(node))->instrument->nfiltered2 += (delta); \
1046         } while(0)
1047
1048 /*
1049  * EPQState is state for executing an EvalPlanQual recheck on a candidate
1050  * tuple in ModifyTable or LockRows.  The estate and planstate fields are
1051  * NULL if inactive.
1052  */
1053 typedef struct EPQState
1054 {
1055         EState     *estate;                     /* subsidiary EState */
1056         PlanState  *planstate;          /* plan state tree ready to be executed */
1057         TupleTableSlot *origslot;       /* original output tuple to be rechecked */
1058         Plan       *plan;                       /* plan tree to be executed */
1059         List       *arowMarks;          /* ExecAuxRowMarks (non-locking only) */
1060         int                     epqParam;               /* ID of Param to force scan node re-eval */
1061 } EPQState;
1062
1063
1064 /* ----------------
1065  *       ResultState information
1066  * ----------------
1067  */
1068 typedef struct ResultState
1069 {
1070         PlanState       ps;                             /* its first field is NodeTag */
1071         ExprState  *resconstantqual;
1072         bool            rs_done;                /* are we done? */
1073         bool            rs_checkqual;   /* do we need to check the qual? */
1074 } ResultState;
1075
1076 /* ----------------
1077  *       ModifyTableState information
1078  * ----------------
1079  */
1080 typedef struct ModifyTableState
1081 {
1082         PlanState       ps;                             /* its first field is NodeTag */
1083         CmdType         operation;              /* INSERT, UPDATE, or DELETE */
1084         bool            canSetTag;              /* do we set the command tag/es_processed? */
1085         bool            mt_done;                /* are we done? */
1086         PlanState **mt_plans;           /* subplans (one per target rel) */
1087         int                     mt_nplans;              /* number of plans in the array */
1088         int                     mt_whichplan;   /* which one is being executed (0..n-1) */
1089         ResultRelInfo *resultRelInfo;           /* per-subplan target relations */
1090         List      **mt_arowmarks;       /* per-subplan ExecAuxRowMark lists */
1091         EPQState        mt_epqstate;    /* for evaluating EvalPlanQual rechecks */
1092         bool            fireBSTriggers; /* do we need to fire stmt triggers? */
1093 } ModifyTableState;
1094
1095 /* ----------------
1096  *       AppendState information
1097  *
1098  *              nplans                  how many plans are in the array
1099  *              whichplan               which plan is being executed (0 .. n-1)
1100  * ----------------
1101  */
1102 typedef struct AppendState
1103 {
1104         PlanState       ps;                             /* its first field is NodeTag */
1105         PlanState **appendplans;        /* array of PlanStates for my inputs */
1106         int                     as_nplans;
1107         int                     as_whichplan;
1108 } AppendState;
1109
1110 /* ----------------
1111  *       MergeAppendState information
1112  *
1113  *              nplans                  how many plans are in the array
1114  *              nkeys                   number of sort key columns
1115  *              sortkeys                sort keys in SortSupport representation
1116  *              slots                   current output tuple of each subplan
1117  *              heap                    heap of active tuples
1118  *              initialized             true if we have fetched first tuple from each subplan
1119  * ----------------
1120  */
1121 typedef struct MergeAppendState
1122 {
1123         PlanState       ps;                             /* its first field is NodeTag */
1124         PlanState **mergeplans;         /* array of PlanStates for my inputs */
1125         int                     ms_nplans;
1126         int                     ms_nkeys;
1127         SortSupport ms_sortkeys;        /* array of length ms_nkeys */
1128         TupleTableSlot **ms_slots;      /* array of length ms_nplans */
1129         struct binaryheap *ms_heap; /* binary heap of slot indices */
1130         bool            ms_initialized; /* are subplans started? */
1131 } MergeAppendState;
1132
1133 /* ----------------
1134  *       RecursiveUnionState information
1135  *
1136  *              RecursiveUnionState is used for performing a recursive union.
1137  *
1138  *              recursing                       T when we're done scanning the non-recursive term
1139  *              intermediate_empty      T if intermediate_table is currently empty
1140  *              working_table           working table (to be scanned by recursive term)
1141  *              intermediate_table      current recursive output (next generation of WT)
1142  * ----------------
1143  */
1144 typedef struct RecursiveUnionState
1145 {
1146         PlanState       ps;                             /* its first field is NodeTag */
1147         bool            recursing;
1148         bool            intermediate_empty;
1149         Tuplestorestate *working_table;
1150         Tuplestorestate *intermediate_table;
1151         /* Remaining fields are unused in UNION ALL case */
1152         FmgrInfo   *eqfunctions;        /* per-grouping-field equality fns */
1153         FmgrInfo   *hashfunctions;      /* per-grouping-field hash fns */
1154         MemoryContext tempContext;      /* short-term context for comparisons */
1155         TupleHashTable hashtable;       /* hash table for tuples already seen */
1156         MemoryContext tableContext; /* memory context containing hash table */
1157 } RecursiveUnionState;
1158
1159 /* ----------------
1160  *       BitmapAndState information
1161  * ----------------
1162  */
1163 typedef struct BitmapAndState
1164 {
1165         PlanState       ps;                             /* its first field is NodeTag */
1166         PlanState **bitmapplans;        /* array of PlanStates for my inputs */
1167         int                     nplans;                 /* number of input plans */
1168 } BitmapAndState;
1169
1170 /* ----------------
1171  *       BitmapOrState information
1172  * ----------------
1173  */
1174 typedef struct BitmapOrState
1175 {
1176         PlanState       ps;                             /* its first field is NodeTag */
1177         PlanState **bitmapplans;        /* array of PlanStates for my inputs */
1178         int                     nplans;                 /* number of input plans */
1179 } BitmapOrState;
1180
1181 /* ----------------------------------------------------------------
1182  *                               Scan State Information
1183  * ----------------------------------------------------------------
1184  */
1185
1186 /* ----------------
1187  *       ScanState information
1188  *
1189  *              ScanState extends PlanState for node types that represent
1190  *              scans of an underlying relation.  It can also be used for nodes
1191  *              that scan the output of an underlying plan node --- in that case,
1192  *              only ScanTupleSlot is actually useful, and it refers to the tuple
1193  *              retrieved from the subplan.
1194  *
1195  *              currentRelation    relation being scanned (NULL if none)
1196  *              currentScanDesc    current scan descriptor for scan (NULL if none)
1197  *              ScanTupleSlot      pointer to slot in tuple table holding scan tuple
1198  * ----------------
1199  */
1200 typedef struct ScanState
1201 {
1202         PlanState       ps;                             /* its first field is NodeTag */
1203         Relation        ss_currentRelation;
1204         HeapScanDesc ss_currentScanDesc;
1205         TupleTableSlot *ss_ScanTupleSlot;
1206 } ScanState;
1207
1208 /*
1209  * SeqScan uses a bare ScanState as its state node, since it needs
1210  * no additional fields.
1211  */
1212 typedef ScanState SeqScanState;
1213
1214 /*
1215  * These structs store information about index quals that don't have simple
1216  * constant right-hand sides.  See comments for ExecIndexBuildScanKeys()
1217  * for discussion.
1218  */
1219 typedef struct
1220 {
1221         ScanKey         scan_key;               /* scankey to put value into */
1222         ExprState  *key_expr;           /* expr to evaluate to get value */
1223         bool            key_toastable;  /* is expr's result a toastable datatype? */
1224 } IndexRuntimeKeyInfo;
1225
1226 typedef struct
1227 {
1228         ScanKey         scan_key;               /* scankey to put value into */
1229         ExprState  *array_expr;         /* expr to evaluate to get array value */
1230         int                     next_elem;              /* next array element to use */
1231         int                     num_elems;              /* number of elems in current array value */
1232         Datum      *elem_values;        /* array of num_elems Datums */
1233         bool       *elem_nulls;         /* array of num_elems is-null flags */
1234 } IndexArrayKeyInfo;
1235
1236 /* ----------------
1237  *       IndexScanState information
1238  *
1239  *              indexqualorig      execution state for indexqualorig expressions
1240  *              ScanKeys                   Skey structures for index quals
1241  *              NumScanKeys                number of ScanKeys
1242  *              OrderByKeys                Skey structures for index ordering operators
1243  *              NumOrderByKeys     number of OrderByKeys
1244  *              RuntimeKeys                info about Skeys that must be evaluated at runtime
1245  *              NumRuntimeKeys     number of RuntimeKeys
1246  *              RuntimeKeysReady   true if runtime Skeys have been computed
1247  *              RuntimeContext     expr context for evaling runtime Skeys
1248  *              RelationDesc       index relation descriptor
1249  *              ScanDesc                   index scan descriptor
1250  * ----------------
1251  */
1252 typedef struct IndexScanState
1253 {
1254         ScanState       ss;                             /* its first field is NodeTag */
1255         List       *indexqualorig;
1256         ScanKey         iss_ScanKeys;
1257         int                     iss_NumScanKeys;
1258         ScanKey         iss_OrderByKeys;
1259         int                     iss_NumOrderByKeys;
1260         IndexRuntimeKeyInfo *iss_RuntimeKeys;
1261         int                     iss_NumRuntimeKeys;
1262         bool            iss_RuntimeKeysReady;
1263         ExprContext *iss_RuntimeContext;
1264         Relation        iss_RelationDesc;
1265         IndexScanDesc iss_ScanDesc;
1266 } IndexScanState;
1267
1268 /* ----------------
1269  *       IndexOnlyScanState information
1270  *
1271  *              indexqual                  execution state for indexqual expressions
1272  *              ScanKeys                   Skey structures for index quals
1273  *              NumScanKeys                number of ScanKeys
1274  *              OrderByKeys                Skey structures for index ordering operators
1275  *              NumOrderByKeys     number of OrderByKeys
1276  *              RuntimeKeys                info about Skeys that must be evaluated at runtime
1277  *              NumRuntimeKeys     number of RuntimeKeys
1278  *              RuntimeKeysReady   true if runtime Skeys have been computed
1279  *              RuntimeContext     expr context for evaling runtime Skeys
1280  *              RelationDesc       index relation descriptor
1281  *              ScanDesc                   index scan descriptor
1282  *              VMBuffer                   buffer in use for visibility map testing, if any
1283  *              HeapFetches                number of tuples we were forced to fetch from heap
1284  * ----------------
1285  */
1286 typedef struct IndexOnlyScanState
1287 {
1288         ScanState       ss;                             /* its first field is NodeTag */
1289         List       *indexqual;
1290         ScanKey         ioss_ScanKeys;
1291         int                     ioss_NumScanKeys;
1292         ScanKey         ioss_OrderByKeys;
1293         int                     ioss_NumOrderByKeys;
1294         IndexRuntimeKeyInfo *ioss_RuntimeKeys;
1295         int                     ioss_NumRuntimeKeys;
1296         bool            ioss_RuntimeKeysReady;
1297         ExprContext *ioss_RuntimeContext;
1298         Relation        ioss_RelationDesc;
1299         IndexScanDesc ioss_ScanDesc;
1300         Buffer          ioss_VMBuffer;
1301         long            ioss_HeapFetches;
1302 } IndexOnlyScanState;
1303
1304 /* ----------------
1305  *       BitmapIndexScanState information
1306  *
1307  *              result                     bitmap to return output into, or NULL
1308  *              ScanKeys                   Skey structures for index quals
1309  *              NumScanKeys                number of ScanKeys
1310  *              RuntimeKeys                info about Skeys that must be evaluated at runtime
1311  *              NumRuntimeKeys     number of RuntimeKeys
1312  *              ArrayKeys                  info about Skeys that come from ScalarArrayOpExprs
1313  *              NumArrayKeys       number of ArrayKeys
1314  *              RuntimeKeysReady   true if runtime Skeys have been computed
1315  *              RuntimeContext     expr context for evaling runtime Skeys
1316  *              RelationDesc       index relation descriptor
1317  *              ScanDesc                   index scan descriptor
1318  * ----------------
1319  */
1320 typedef struct BitmapIndexScanState
1321 {
1322         ScanState       ss;                             /* its first field is NodeTag */
1323         TIDBitmap  *biss_result;
1324         ScanKey         biss_ScanKeys;
1325         int                     biss_NumScanKeys;
1326         IndexRuntimeKeyInfo *biss_RuntimeKeys;
1327         int                     biss_NumRuntimeKeys;
1328         IndexArrayKeyInfo *biss_ArrayKeys;
1329         int                     biss_NumArrayKeys;
1330         bool            biss_RuntimeKeysReady;
1331         ExprContext *biss_RuntimeContext;
1332         Relation        biss_RelationDesc;
1333         IndexScanDesc biss_ScanDesc;
1334 } BitmapIndexScanState;
1335
1336 /* ----------------
1337  *       BitmapHeapScanState information
1338  *
1339  *              bitmapqualorig     execution state for bitmapqualorig expressions
1340  *              tbm                                bitmap obtained from child index scan(s)
1341  *              tbmiterator                iterator for scanning current pages
1342  *              tbmres                     current-page data
1343  *              exact_pages                total number of exact pages retrieved
1344  *              lossy_pages                total number of lossy pages retrieved
1345  *              prefetch_iterator  iterator for prefetching ahead of current page
1346  *              prefetch_pages     # pages prefetch iterator is ahead of current
1347  *              prefetch_target    target prefetch distance
1348  * ----------------
1349  */
1350 typedef struct BitmapHeapScanState
1351 {
1352         ScanState       ss;                             /* its first field is NodeTag */
1353         List       *bitmapqualorig;
1354         TIDBitmap  *tbm;
1355         TBMIterator *tbmiterator;
1356         TBMIterateResult *tbmres;
1357         long            exact_pages;
1358         long            lossy_pages;
1359         TBMIterator *prefetch_iterator;
1360         int                     prefetch_pages;
1361         int                     prefetch_target;
1362 } BitmapHeapScanState;
1363
1364 /* ----------------
1365  *       TidScanState information
1366  *
1367  *              isCurrentOf    scan has a CurrentOfExpr qual
1368  *              NumTids            number of tids in this scan
1369  *              TidPtr             index of currently fetched tid
1370  *              TidList            evaluated item pointers (array of size NumTids)
1371  * ----------------
1372  */
1373 typedef struct TidScanState
1374 {
1375         ScanState       ss;                             /* its first field is NodeTag */
1376         List       *tss_tidquals;       /* list of ExprState nodes */
1377         bool            tss_isCurrentOf;
1378         int                     tss_NumTids;
1379         int                     tss_TidPtr;
1380         ItemPointerData *tss_TidList;
1381         HeapTupleData tss_htup;
1382 } TidScanState;
1383
1384 /* ----------------
1385  *       SubqueryScanState information
1386  *
1387  *              SubqueryScanState is used for scanning a sub-query in the range table.
1388  *              ScanTupleSlot references the current output tuple of the sub-query.
1389  * ----------------
1390  */
1391 typedef struct SubqueryScanState
1392 {
1393         ScanState       ss;                             /* its first field is NodeTag */
1394         PlanState  *subplan;
1395 } SubqueryScanState;
1396
1397 /* ----------------
1398  *       FunctionScanState information
1399  *
1400  *              Function nodes are used to scan the results of a
1401  *              function appearing in FROM (typically a function returning set).
1402  *
1403  *              eflags                          node's capability flags
1404  *              ordinality                      is this scan WITH ORDINALITY?
1405  *              simple                          true if we have 1 function and no ordinality
1406  *              ordinal                         current ordinal column value
1407  *              nfuncs                          number of functions being executed
1408  *              funcstates                      per-function execution states (private in
1409  *                                                      nodeFunctionscan.c)
1410  *              argcontext                      memory context to evaluate function arguments in
1411  * ----------------
1412  */
1413 struct FunctionScanPerFuncState;
1414
1415 typedef struct FunctionScanState
1416 {
1417         ScanState       ss;                             /* its first field is NodeTag */
1418         int                     eflags;
1419         bool            ordinality;
1420         bool            simple;
1421         int64           ordinal;
1422         int                     nfuncs;
1423         struct FunctionScanPerFuncState *funcstates;            /* array of length
1424                                                                                                                  * nfuncs */
1425         MemoryContext argcontext;
1426 } FunctionScanState;
1427
1428 /* ----------------
1429  *       ValuesScanState information
1430  *
1431  *              ValuesScan nodes are used to scan the results of a VALUES list
1432  *
1433  *              rowcontext                      per-expression-list context
1434  *              exprlists                       array of expression lists being evaluated
1435  *              array_len                       size of array
1436  *              curr_idx                        current array index (0-based)
1437  *
1438  *      Note: ss.ps.ps_ExprContext is used to evaluate any qual or projection
1439  *      expressions attached to the node.  We create a second ExprContext,
1440  *      rowcontext, in which to build the executor expression state for each
1441  *      Values sublist.  Resetting this context lets us get rid of expression
1442  *      state for each row, avoiding major memory leakage over a long values list.
1443  * ----------------
1444  */
1445 typedef struct ValuesScanState
1446 {
1447         ScanState       ss;                             /* its first field is NodeTag */
1448         ExprContext *rowcontext;
1449         List      **exprlists;
1450         int                     array_len;
1451         int                     curr_idx;
1452 } ValuesScanState;
1453
1454 /* ----------------
1455  *       CteScanState information
1456  *
1457  *              CteScan nodes are used to scan a CommonTableExpr query.
1458  *
1459  * Multiple CteScan nodes can read out from the same CTE query.  We use
1460  * a tuplestore to hold rows that have been read from the CTE query but
1461  * not yet consumed by all readers.
1462  * ----------------
1463  */
1464 typedef struct CteScanState
1465 {
1466         ScanState       ss;                             /* its first field is NodeTag */
1467         int                     eflags;                 /* capability flags to pass to tuplestore */
1468         int                     readptr;                /* index of my tuplestore read pointer */
1469         PlanState  *cteplanstate;       /* PlanState for the CTE query itself */
1470         /* Link to the "leader" CteScanState (possibly this same node) */
1471         struct CteScanState *leader;
1472         /* The remaining fields are only valid in the "leader" CteScanState */
1473         Tuplestorestate *cte_table; /* rows already read from the CTE query */
1474         bool            eof_cte;                /* reached end of CTE query? */
1475 } CteScanState;
1476
1477 /* ----------------
1478  *       WorkTableScanState information
1479  *
1480  *              WorkTableScan nodes are used to scan the work table created by
1481  *              a RecursiveUnion node.  We locate the RecursiveUnion node
1482  *              during executor startup.
1483  * ----------------
1484  */
1485 typedef struct WorkTableScanState
1486 {
1487         ScanState       ss;                             /* its first field is NodeTag */
1488         RecursiveUnionState *rustate;
1489 } WorkTableScanState;
1490
1491 /* ----------------
1492  *       ForeignScanState information
1493  *
1494  *              ForeignScan nodes are used to scan foreign-data tables.
1495  * ----------------
1496  */
1497 typedef struct ForeignScanState
1498 {
1499         ScanState       ss;                             /* its first field is NodeTag */
1500         /* use struct pointer to avoid including fdwapi.h here */
1501         struct FdwRoutine *fdwroutine;
1502         void       *fdw_state;          /* foreign-data wrapper can keep state here */
1503 } ForeignScanState;
1504
1505 /* ----------------
1506  *       CustomScanState information
1507  *
1508  *              CustomScan nodes are used to execute custom code within executor.
1509  *
1510  * Core code must avoid assuming that the CustomScanState is only as large as
1511  * the structure declared here; providers are allowed to make it the first
1512  * element in a larger structure, and typically would need to do so.  The
1513  * struct is actually allocated by the CreateCustomScanState method associated
1514  * with the plan node.  Any additional fields can be initialized there, or in
1515  * the BeginCustomScan method.
1516  * ----------------
1517  */
1518 struct ExplainState;                    /* avoid including explain.h here */
1519 struct CustomScanState;
1520
1521 typedef struct CustomExecMethods
1522 {
1523         const char *CustomName;
1524
1525         /* Executor methods: mark/restore are optional, the rest are required */
1526         void            (*BeginCustomScan) (struct CustomScanState *node,
1527                                                                                                 EState *estate,
1528                                                                                                 int eflags);
1529         TupleTableSlot *(*ExecCustomScan) (struct CustomScanState *node);
1530         void            (*EndCustomScan) (struct CustomScanState *node);
1531         void            (*ReScanCustomScan) (struct CustomScanState *node);
1532         void            (*MarkPosCustomScan) (struct CustomScanState *node);
1533         void            (*RestrPosCustomScan) (struct CustomScanState *node);
1534
1535         /* Optional: print additional information in EXPLAIN */
1536         void            (*ExplainCustomScan) (struct CustomScanState *node,
1537                                                                                                   List *ancestors,
1538                                                                                                   struct ExplainState *es);
1539 } CustomExecMethods;
1540
1541 typedef struct CustomScanState
1542 {
1543         ScanState       ss;
1544         uint32          flags;                  /* mask of CUSTOMPATH_* flags, see relation.h */
1545         const CustomExecMethods *methods;
1546 } CustomScanState;
1547
1548 /* ----------------------------------------------------------------
1549  *                               Join State Information
1550  * ----------------------------------------------------------------
1551  */
1552
1553 /* ----------------
1554  *       JoinState information
1555  *
1556  *              Superclass for state nodes of join plans.
1557  * ----------------
1558  */
1559 typedef struct JoinState
1560 {
1561         PlanState       ps;
1562         JoinType        jointype;
1563         List       *joinqual;           /* JOIN quals (in addition to ps.qual) */
1564 } JoinState;
1565
1566 /* ----------------
1567  *       NestLoopState information
1568  *
1569  *              NeedNewOuter       true if need new outer tuple on next call
1570  *              MatchedOuter       true if found a join match for current outer tuple
1571  *              NullInnerTupleSlot prepared null tuple for left outer joins
1572  * ----------------
1573  */
1574 typedef struct NestLoopState
1575 {
1576         JoinState       js;                             /* its first field is NodeTag */
1577         bool            nl_NeedNewOuter;
1578         bool            nl_MatchedOuter;
1579         TupleTableSlot *nl_NullInnerTupleSlot;
1580 } NestLoopState;
1581
1582 /* ----------------
1583  *       MergeJoinState information
1584  *
1585  *              NumClauses                 number of mergejoinable join clauses
1586  *              Clauses                    info for each mergejoinable clause
1587  *              JoinState                  current state of ExecMergeJoin state machine
1588  *              ExtraMarks                 true to issue extra Mark operations on inner scan
1589  *              ConstFalseJoin     true if we have a constant-false joinqual
1590  *              FillOuter                  true if should emit unjoined outer tuples anyway
1591  *              FillInner                  true if should emit unjoined inner tuples anyway
1592  *              MatchedOuter       true if found a join match for current outer tuple
1593  *              MatchedInner       true if found a join match for current inner tuple
1594  *              OuterTupleSlot     slot in tuple table for cur outer tuple
1595  *              InnerTupleSlot     slot in tuple table for cur inner tuple
1596  *              MarkedTupleSlot    slot in tuple table for marked tuple
1597  *              NullOuterTupleSlot prepared null tuple for right outer joins
1598  *              NullInnerTupleSlot prepared null tuple for left outer joins
1599  *              OuterEContext      workspace for computing outer tuple's join values
1600  *              InnerEContext      workspace for computing inner tuple's join values
1601  * ----------------
1602  */
1603 /* private in nodeMergejoin.c: */
1604 typedef struct MergeJoinClauseData *MergeJoinClause;
1605
1606 typedef struct MergeJoinState
1607 {
1608         JoinState       js;                             /* its first field is NodeTag */
1609         int                     mj_NumClauses;
1610         MergeJoinClause mj_Clauses; /* array of length mj_NumClauses */
1611         int                     mj_JoinState;
1612         bool            mj_ExtraMarks;
1613         bool            mj_ConstFalseJoin;
1614         bool            mj_FillOuter;
1615         bool            mj_FillInner;
1616         bool            mj_MatchedOuter;
1617         bool            mj_MatchedInner;
1618         TupleTableSlot *mj_OuterTupleSlot;
1619         TupleTableSlot *mj_InnerTupleSlot;
1620         TupleTableSlot *mj_MarkedTupleSlot;
1621         TupleTableSlot *mj_NullOuterTupleSlot;
1622         TupleTableSlot *mj_NullInnerTupleSlot;
1623         ExprContext *mj_OuterEContext;
1624         ExprContext *mj_InnerEContext;
1625 } MergeJoinState;
1626
1627 /* ----------------
1628  *       HashJoinState information
1629  *
1630  *              hashclauses                             original form of the hashjoin condition
1631  *              hj_OuterHashKeys                the outer hash keys in the hashjoin condition
1632  *              hj_InnerHashKeys                the inner hash keys in the hashjoin condition
1633  *              hj_HashOperators                the join operators in the hashjoin condition
1634  *              hj_HashTable                    hash table for the hashjoin
1635  *                                                              (NULL if table not built yet)
1636  *              hj_CurHashValue                 hash value for current outer tuple
1637  *              hj_CurBucketNo                  regular bucket# for current outer tuple
1638  *              hj_CurSkewBucketNo              skew bucket# for current outer tuple
1639  *              hj_CurTuple                             last inner tuple matched to current outer
1640  *                                                              tuple, or NULL if starting search
1641  *                                                              (hj_CurXXX variables are undefined if
1642  *                                                              OuterTupleSlot is empty!)
1643  *              hj_OuterTupleSlot               tuple slot for outer tuples
1644  *              hj_HashTupleSlot                tuple slot for inner (hashed) tuples
1645  *              hj_NullOuterTupleSlot   prepared null tuple for right/full outer joins
1646  *              hj_NullInnerTupleSlot   prepared null tuple for left/full outer joins
1647  *              hj_FirstOuterTupleSlot  first tuple retrieved from outer plan
1648  *              hj_JoinState                    current state of ExecHashJoin state machine
1649  *              hj_MatchedOuter                 true if found a join match for current outer
1650  *              hj_OuterNotEmpty                true if outer relation known not empty
1651  * ----------------
1652  */
1653
1654 /* these structs are defined in executor/hashjoin.h: */
1655 typedef struct HashJoinTupleData *HashJoinTuple;
1656 typedef struct HashJoinTableData *HashJoinTable;
1657
1658 typedef struct HashJoinState
1659 {
1660         JoinState       js;                             /* its first field is NodeTag */
1661         List       *hashclauses;        /* list of ExprState nodes */
1662         List       *hj_OuterHashKeys;           /* list of ExprState nodes */
1663         List       *hj_InnerHashKeys;           /* list of ExprState nodes */
1664         List       *hj_HashOperators;           /* list of operator OIDs */
1665         HashJoinTable hj_HashTable;
1666         uint32          hj_CurHashValue;
1667         int                     hj_CurBucketNo;
1668         int                     hj_CurSkewBucketNo;
1669         HashJoinTuple hj_CurTuple;
1670         TupleTableSlot *hj_OuterTupleSlot;
1671         TupleTableSlot *hj_HashTupleSlot;
1672         TupleTableSlot *hj_NullOuterTupleSlot;
1673         TupleTableSlot *hj_NullInnerTupleSlot;
1674         TupleTableSlot *hj_FirstOuterTupleSlot;
1675         int                     hj_JoinState;
1676         bool            hj_MatchedOuter;
1677         bool            hj_OuterNotEmpty;
1678 } HashJoinState;
1679
1680
1681 /* ----------------------------------------------------------------
1682  *                               Materialization State Information
1683  * ----------------------------------------------------------------
1684  */
1685
1686 /* ----------------
1687  *       MaterialState information
1688  *
1689  *              materialize nodes are used to materialize the results
1690  *              of a subplan into a temporary file.
1691  *
1692  *              ss.ss_ScanTupleSlot refers to output of underlying plan.
1693  * ----------------
1694  */
1695 typedef struct MaterialState
1696 {
1697         ScanState       ss;                             /* its first field is NodeTag */
1698         int                     eflags;                 /* capability flags to pass to tuplestore */
1699         bool            eof_underlying; /* reached end of underlying plan? */
1700         Tuplestorestate *tuplestorestate;
1701 } MaterialState;
1702
1703 /* ----------------
1704  *       SortState information
1705  * ----------------
1706  */
1707 typedef struct SortState
1708 {
1709         ScanState       ss;                             /* its first field is NodeTag */
1710         bool            randomAccess;   /* need random access to sort output? */
1711         bool            bounded;                /* is the result set bounded? */
1712         int64           bound;                  /* if bounded, how many tuples are needed */
1713         bool            sort_Done;              /* sort completed yet? */
1714         bool            bounded_Done;   /* value of bounded we did the sort with */
1715         int64           bound_Done;             /* value of bound we did the sort with */
1716         void       *tuplesortstate; /* private state of tuplesort.c */
1717 } SortState;
1718
1719 /* ---------------------
1720  *      GroupState information
1721  * -------------------------
1722  */
1723 typedef struct GroupState
1724 {
1725         ScanState       ss;                             /* its first field is NodeTag */
1726         FmgrInfo   *eqfunctions;        /* per-field lookup data for equality fns */
1727         bool            grp_done;               /* indicates completion of Group scan */
1728 } GroupState;
1729
1730 /* ---------------------
1731  *      AggState information
1732  *
1733  *      ss.ss_ScanTupleSlot refers to output of underlying plan.
1734  *
1735  *      Note: ss.ps.ps_ExprContext contains ecxt_aggvalues and
1736  *      ecxt_aggnulls arrays, which hold the computed agg values for the current
1737  *      input group during evaluation of an Agg node's output tuple(s).  We
1738  *      create a second ExprContext, tmpcontext, in which to evaluate input
1739  *      expressions and run the aggregate transition functions.
1740  * -------------------------
1741  */
1742 /* these structs are private in nodeAgg.c: */
1743 typedef struct AggStatePerAggData *AggStatePerAgg;
1744 typedef struct AggStatePerGroupData *AggStatePerGroup;
1745
1746 typedef struct AggState
1747 {
1748         ScanState       ss;                             /* its first field is NodeTag */
1749         List       *aggs;                       /* all Aggref nodes in targetlist & quals */
1750         int                     numaggs;                /* length of list (could be zero!) */
1751         FmgrInfo   *eqfunctions;        /* per-grouping-field equality fns */
1752         FmgrInfo   *hashfunctions;      /* per-grouping-field hash fns */
1753         AggStatePerAgg peragg;          /* per-Aggref information */
1754         MemoryContext aggcontext;       /* memory context for long-lived data */
1755         ExprContext *tmpcontext;        /* econtext for input expressions */
1756         AggStatePerAgg curperagg;       /* identifies currently active aggregate */
1757         bool            agg_done;               /* indicates completion of Agg scan */
1758         /* these fields are used in AGG_PLAIN and AGG_SORTED modes: */
1759         AggStatePerGroup pergroup;      /* per-Aggref-per-group working state */
1760         HeapTuple       grp_firstTuple; /* copy of first tuple of current group */
1761         /* these fields are used in AGG_HASHED mode: */
1762         TupleHashTable hashtable;       /* hash table with one entry per group */
1763         TupleTableSlot *hashslot;       /* slot for loading hash table */
1764         List       *hash_needed;        /* list of columns needed in hash table */
1765         bool            table_filled;   /* hash table filled yet? */
1766         TupleHashIterator hashiter; /* for iterating through hash table */
1767 } AggState;
1768
1769 /* ----------------
1770  *      WindowAggState information
1771  * ----------------
1772  */
1773 /* these structs are private in nodeWindowAgg.c: */
1774 typedef struct WindowStatePerFuncData *WindowStatePerFunc;
1775 typedef struct WindowStatePerAggData *WindowStatePerAgg;
1776
1777 typedef struct WindowAggState
1778 {
1779         ScanState       ss;                             /* its first field is NodeTag */
1780
1781         /* these fields are filled in by ExecInitExpr: */
1782         List       *funcs;                      /* all WindowFunc nodes in targetlist */
1783         int                     numfuncs;               /* total number of window functions */
1784         int                     numaggs;                /* number that are plain aggregates */
1785
1786         WindowStatePerFunc perfunc; /* per-window-function information */
1787         WindowStatePerAgg peragg;       /* per-plain-aggregate information */
1788         FmgrInfo   *partEqfunctions;    /* equality funcs for partition columns */
1789         FmgrInfo   *ordEqfunctions; /* equality funcs for ordering columns */
1790         Tuplestorestate *buffer;        /* stores rows of current partition */
1791         int                     current_ptr;    /* read pointer # for current */
1792         int64           spooled_rows;   /* total # of rows in buffer */
1793         int64           currentpos;             /* position of current row in partition */
1794         int64           frameheadpos;   /* current frame head position */
1795         int64           frametailpos;   /* current frame tail position */
1796         /* use struct pointer to avoid including windowapi.h here */
1797         struct WindowObjectData *agg_winobj;            /* winobj for aggregate
1798                                                                                                  * fetches */
1799         int64           aggregatedbase; /* start row for current aggregates */
1800         int64           aggregatedupto; /* rows before this one are aggregated */
1801
1802         int                     frameOptions;   /* frame_clause options, see WindowDef */
1803         ExprState  *startOffset;        /* expression for starting bound offset */
1804         ExprState  *endOffset;          /* expression for ending bound offset */
1805         Datum           startOffsetValue;               /* result of startOffset evaluation */
1806         Datum           endOffsetValue; /* result of endOffset evaluation */
1807
1808         MemoryContext partcontext;      /* context for partition-lifespan data */
1809         MemoryContext aggcontext;       /* shared context for aggregate working data */
1810         MemoryContext curaggcontext;    /* current aggregate's working data */
1811         ExprContext *tmpcontext;        /* short-term evaluation context */
1812
1813         bool            all_first;              /* true if the scan is starting */
1814         bool            all_done;               /* true if the scan is finished */
1815         bool            partition_spooled;              /* true if all tuples in current
1816                                                                                  * partition have been spooled into
1817                                                                                  * tuplestore */
1818         bool            more_partitions;/* true if there's more partitions after this
1819                                                                  * one */
1820         bool            framehead_valid;/* true if frameheadpos is known up to date
1821                                                                  * for current row */
1822         bool            frametail_valid;/* true if frametailpos is known up to date
1823                                                                  * for current row */
1824
1825         TupleTableSlot *first_part_slot;        /* first tuple of current or next
1826                                                                                  * partition */
1827
1828         /* temporary slots for tuples fetched back from tuplestore */
1829         TupleTableSlot *agg_row_slot;
1830         TupleTableSlot *temp_slot_1;
1831         TupleTableSlot *temp_slot_2;
1832 } WindowAggState;
1833
1834 /* ----------------
1835  *       UniqueState information
1836  *
1837  *              Unique nodes are used "on top of" sort nodes to discard
1838  *              duplicate tuples returned from the sort phase.  Basically
1839  *              all it does is compare the current tuple from the subplan
1840  *              with the previously fetched tuple (stored in its result slot).
1841  *              If the two are identical in all interesting fields, then
1842  *              we just fetch another tuple from the sort and try again.
1843  * ----------------
1844  */
1845 typedef struct UniqueState
1846 {
1847         PlanState       ps;                             /* its first field is NodeTag */
1848         FmgrInfo   *eqfunctions;        /* per-field lookup data for equality fns */
1849         MemoryContext tempContext;      /* short-term context for comparisons */
1850 } UniqueState;
1851
1852 /* ----------------
1853  *       HashState information
1854  * ----------------
1855  */
1856 typedef struct HashState
1857 {
1858         PlanState       ps;                             /* its first field is NodeTag */
1859         HashJoinTable hashtable;        /* hash table for the hashjoin */
1860         List       *hashkeys;           /* list of ExprState nodes */
1861         /* hashkeys is same as parent's hj_InnerHashKeys */
1862 } HashState;
1863
1864 /* ----------------
1865  *       SetOpState information
1866  *
1867  *              Even in "sorted" mode, SetOp nodes are more complex than a simple
1868  *              Unique, since we have to count how many duplicates to return.  But
1869  *              we also support hashing, so this is really more like a cut-down
1870  *              form of Agg.
1871  * ----------------
1872  */
1873 /* this struct is private in nodeSetOp.c: */
1874 typedef struct SetOpStatePerGroupData *SetOpStatePerGroup;
1875
1876 typedef struct SetOpState
1877 {
1878         PlanState       ps;                             /* its first field is NodeTag */
1879         FmgrInfo   *eqfunctions;        /* per-grouping-field equality fns */
1880         FmgrInfo   *hashfunctions;      /* per-grouping-field hash fns */
1881         bool            setop_done;             /* indicates completion of output scan */
1882         long            numOutput;              /* number of dups left to output */
1883         MemoryContext tempContext;      /* short-term context for comparisons */
1884         /* these fields are used in SETOP_SORTED mode: */
1885         SetOpStatePerGroup pergroup;    /* per-group working state */
1886         HeapTuple       grp_firstTuple; /* copy of first tuple of current group */
1887         /* these fields are used in SETOP_HASHED mode: */
1888         TupleHashTable hashtable;       /* hash table with one entry per group */
1889         MemoryContext tableContext; /* memory context containing hash table */
1890         bool            table_filled;   /* hash table filled yet? */
1891         TupleHashIterator hashiter; /* for iterating through hash table */
1892 } SetOpState;
1893
1894 /* ----------------
1895  *       LockRowsState information
1896  *
1897  *              LockRows nodes are used to enforce FOR [KEY] UPDATE/SHARE locking.
1898  * ----------------
1899  */
1900 typedef struct LockRowsState
1901 {
1902         PlanState       ps;                             /* its first field is NodeTag */
1903         List       *lr_arowMarks;       /* List of ExecAuxRowMarks */
1904         EPQState        lr_epqstate;    /* for evaluating EvalPlanQual rechecks */
1905 } LockRowsState;
1906
1907 /* ----------------
1908  *       LimitState information
1909  *
1910  *              Limit nodes are used to enforce LIMIT/OFFSET clauses.
1911  *              They just select the desired subrange of their subplan's output.
1912  *
1913  * offset is the number of initial tuples to skip (0 does nothing).
1914  * count is the number of tuples to return after skipping the offset tuples.
1915  * If no limit count was specified, count is undefined and noCount is true.
1916  * When lstate == LIMIT_INITIAL, offset/count/noCount haven't been set yet.
1917  * ----------------
1918  */
1919 typedef enum
1920 {
1921         LIMIT_INITIAL,                          /* initial state for LIMIT node */
1922         LIMIT_RESCAN,                           /* rescan after recomputing parameters */
1923         LIMIT_EMPTY,                            /* there are no returnable rows */
1924         LIMIT_INWINDOW,                         /* have returned a row in the window */
1925         LIMIT_SUBPLANEOF,                       /* at EOF of subplan (within window) */
1926         LIMIT_WINDOWEND,                        /* stepped off end of window */
1927         LIMIT_WINDOWSTART                       /* stepped off beginning of window */
1928 } LimitStateCond;
1929
1930 typedef struct LimitState
1931 {
1932         PlanState       ps;                             /* its first field is NodeTag */
1933         ExprState  *limitOffset;        /* OFFSET parameter, or NULL if none */
1934         ExprState  *limitCount;         /* COUNT parameter, or NULL if none */
1935         int64           offset;                 /* current OFFSET value */
1936         int64           count;                  /* current COUNT, if any */
1937         bool            noCount;                /* if true, ignore count */
1938         LimitStateCond lstate;          /* state machine status, as above */
1939         int64           position;               /* 1-based index of last tuple returned */
1940         TupleTableSlot *subSlot;        /* tuple last obtained from subplan */
1941 } LimitState;
1942
1943 #endif   /* EXECNODES_H */