/* ---------------------------------------------------------------- * FILE * execnodes.h * * DESCRIPTION * definitions for executor state nodes * * NOTES * this file is listed in lib/Gen/inherits.sh and in the * INH_SRC list in conf/inh.mk and is used to generate the * obj/lib/C/plannodes.c file * * IDENTIFICATION * $Header: /general/TFA/unclassified/src/utils/postgres-v3r1/src/lib/H/nodes/RCS/execnodes.h,v 1.56 91/11/11 19:23:51 glass Exp $ * ---------------------------------------------------------------- */ #ifndef ExecNodesIncluded #define ExecNodesIncluded #include "tmp/postgres.h" #include "executor/recursion_a.h" /* recursion stuff that must go first - JRB */ #include "nodes/primnodes.h" #include "nodes/pg_lisp.h" #include "nodes/nodes.h" /* bogus inheritance system */ #include "rules/params.h" /* parameterized plan stuff... */ #include "rules/prs2.h" /* for the prs2_info field of EState */ #include "storage/item.h" #include "access/sdir.h" #include "access/htup.h" #include "access/tupdesc.h" #include "access/funcindex.h" #include "utils/rel.h" #include "access/relscan.h" #include "executor/hashjoin.h" #include "executor/tuptable.h" #include "access/rulescan.h" /* ---------------------------------------------------------------- * Node Function Declarations * * All of these #defines indicate that we have written print/equal/copy * support for the classes named. The print routines are in * lib/C/printfuncs.c, the equal functions are in lib/C/equalfincs.c and * the copy functions can be found in lib/C/copyfuncs.c * * An interface routine is generated automatically by Gen_creator.sh for * each node type. This routine will call either do nothing or call * an _print, _equal or _copy function defined in one of the above * files, depending on whether or not the appropriate #define is specified. * * Thus, when adding a new node type, you have to add a set of * _print, _equal and _copy functions to the above files and then * add some #defines below. * * This is pretty complicated, and a better-designed system needs to be * implemented. * ---------------------------------------------------------------- */ #define OutEStateExists /* ---------------------------------------------------------------- * Executor Support Types * ---------------------------------------------------------------- */ #define abstime AbsoluteTime typedef int *IntPtr; typedef void (*HookFunction)(); /* ---------------- * IndexInfo information * * this class holds the information saying what attributes * are the key attributes for this index. -cim 10/15/89 * * NumKeyAttributes number of key attributes for this index * KeyAttributeNumbers array of attribute numbers used as keys * ---------------- */ class (IndexInfo) public (Node) { inherits0(Node); int ii_NumKeyAttributes; AttributeNumberPtr ii_KeyAttributeNumbers; FuncIndexInfoPtr ii_FuncIndexInfo; }; typedef IndexInfo *IndexInfoPtr; /* ---------------- * RelationInfo information * * whenever we update an existing relation, we have to * update indices on the relation. The RelationInfo class * is used to hold all the information on result relations, * including indices.. -cim 10/15/89 * * RangeTableIndex result relation's range table index * RelationDesc relation descriptor for result relation * NumIndices number indices existing on result relation * IndexRelationDescs array of relation descriptors for indices * IndexInfoPtr array of key/attr info for indices * ---------------- */ class (RelationInfo) public (Node) { inherits0(Node); Index ri_RangeTableIndex; Relation ri_RelationDesc; int ri_NumIndices; RelationPtr ri_IndexRelationDescs; IndexInfoPtr ri_IndexRelationInfo; }; /* ---------------- * TupleCount node information * * retrieved number of tuples seen by ExecRetrieve * appended number of tuples seen by ExecAppend * deleted number of tuples seen by ExecDelete * replaced number of tuples seen by ExecReplace * inserted number of index tuples inserted * processed number of tuples processed by the plan * ---------------- */ class (TupleCount) public (Node) { inherits0(Node); /* private: */ int tc_retrieved; int tc_appended; int tc_deleted; int tc_replaced; int tc_inserted; int tc_processed; /* public: */ }; /* ---------------- * Note: the executor tuple table is managed and manipulated by special * code and macros in executor/tuple.c and lib/H/executor/tuptable.h * -cim 1/18/90 * * TupleTableSlot information * * shouldFree boolean - should we call pfree() on tuple * descIsNew boolean - true when tupleDescriptor changes * tupleDescriptor type information kept regarding the tuple data * buffer the buffer for tuples pointing to disk pages * * LispValue information * * val.car pointer to tuple data * cdr pointer to special info (currenty unused) * * The executor stores pointers to tuples in a ``tuple table'' * which is composed of TupleTableSlot's. Some of the tuples * are pointers to buffer pages and others are pointers to * palloc'ed memory and the shouldFree variable tells us when * we may call pfree() on a tuple. -cim 9/23/90 * * In the implementation of nested-dot queries such as * "retrieve (EMP.hobbies.all)", a single scan may return tuples * of many types, so now we return pointers to tuple descriptors * along with tuples returned via the tuple table. -cim 1/18/90 * ---------------- */ class (TupleTableSlot) public (LispValue) { inherits2(LispValue); /* private: */ bool ttc_shouldFree; bool ttc_descIsNew; TupleDescriptor ttc_tupleDescriptor; Buffer ttc_buffer; /* public: */ }; /* ---------------- * ExprContext * * This class holds the "current context" information * needed to evaluate expressions for doing tuple qualifications * and tuple projections. For example, if an expression refers * to an attribute in the current inner tuple then we need to know * what the current inner tuple is and so we look at the expression * context. * * old comments: * Most of this information was originally stored in global variables * in the Lisp system. * * ExprContexts are stored in CommonState nodes and so * all executor state nodes which inherit from CommonState * have ExprContexts although not all of them need it. * * SOON: ExprContext will contain indexes of tuples in the tupleTable * stored in the EState, rather than pointers which it now stores. * It might still be used to store type/buffer information though. * (I haven't thought that out yet) -cim 6/20/90 * ---------------- */ class (ExprContext) public (Node) { #define ExprContextDefs \ inherits0(Node); \ TupleTableSlot ecxt_scantuple; \ TupleTableSlot ecxt_innertuple; \ TupleTableSlot ecxt_outertuple; \ Relation ecxt_relation; \ Index ecxt_relid; \ ParamListInfo ecxt_param_list_info /* private: */ ExprContextDefs; /* public: */ }; /* ---------------- * ProjectionInfo node information * * This is all the information needed to preform projections * on a tuple. Nodes which need to do projections create one * of these. In theory, when a node wants to preform a projection * it should just update this information as necessary and then * call ExecProject(). -cim 6/3/91 * * targetlist target list for projection * len length of target list * tupValue array of pointers to projection results * exprContext expression context for ExecTargetList * slot slot to place projection result in * ---------------- */ class (ProjectionInfo) public (Node) { inherits0(Node); /* private: */ List pi_targetlist; int pi_len; Pointer pi_tupValue; ExprContext pi_exprContext; TupleTableSlot pi_slot; /* public: */ }; /* ---------------- * JunkFilter * * this class is used to store information regarding junk attributes. * A junk attribute is an attribute in a tuple that is needed only for * storing intermediate information in the executor, and does not belong * in the tuple proper. For example, when we do a delete or replace * query, the planner adds an entry to the targetlist so that the tuples * returned to ExecutePlan() contain an extra attribute: the t_ctid of * the tuple to be deleted/replaced. This is needed for amdelete() and * amreplace(). In doing a delete this does not make much of a * difference, but in doing a replace we have to make sure we disgard * all the junk in a tuple before calling amreplace(). Otherwise the * inserted tuple will not have the correct schema. This solves a * problem with hash-join and merge-sort replace plans. -cim 10/10/90 * * targetList: the original target list (including junk attributes). * length: the length of 'targetList'. * tupType: the tuple descriptor for the "original" tuple * (including the junk attributes). * cleanTargetList: the "clean" target list (junk attributes removed). * cleanLength: the length of 'cleanTargetList' * cleanTupTyp: the tuple descriptor of the "clean" tuple (with * junk attributes removed). * cleanMap: A map with the correspondance between the non junk * attributes of the "original" tuple and the * attributes of the "clean" tuple. * ---------------- */ class (JunkFilter) public (JunkFilter) { inherits0(Node); /* private: */ List jf_targetList; int jf_length; TupleDescriptor jf_tupType; List jf_cleanTargetList; int jf_cleanLength; TupleDescriptor jf_cleanTupType; AttributeNumberPtr jf_cleanMap; /* public: */ }; /* ---------------- * EState information * * direction direction of the scan * time ? * owner ? * locks ? * subplan_info ? * error_message ? * * range_table array of scan relation information * * qualification_tuple tuple satisifying qualification * (going away soon) * * qualification_tuple_id tid of qualification_tuple * (going away soon) * * qualification_tuple_buffer buffer of qualification_tuple * (going away soon) * * raw_qualification_tuple tuple satsifying qualification * but with no rules activated. * (going away soon) * * relation_relation_descriptor as it says * * into_relation_descriptor relation being retrieved "into" * * result_relation_information for update queries * * tuplecount summary of tuples processed * * param_list_info information needed to transform * Param nodes into Const nodes * * prs2_info Information used by the rule * manager (for loop detection * etc.). Must be initialized to NULL * * explain_relation The relation descriptor of the * result relation of an 'explain' * command. NULL if this is not * an explain command. * * BaseId during InitPlan(), each node is * given a number. this is the next * number to be assigned. * * tupleTable this is a pointer to an array * of pointers to tuples used by * the executor at any given moment. * * junkFilter contains information used to * extract junk attributes from a tuple. * (see JunkFilter above) * * result_rel_scanstate points to the scanstate for the * result relation, if there is one. * this should be a ScanState but it's * a Pointer because of order conflicts. * * result_rel_ruleinfo general information * for the result relation needed * by the rule manager. * ---------------- */ class (EState) public (Node) { inherits0(Node); ScanDirection es_direction; abstime es_time; ObjectId es_owner; List es_locks; List es_subplan_info; Name es_error_message; List es_range_table; HeapTuple es_qualification_tuple; ItemPointer es_qualification_tuple_id; Buffer es_qualification_tuple_buffer; HeapTuple es_raw_qualification_tuple; Relation es_relation_relation_descriptor; Relation es_into_relation_descriptor; RelationInfo es_result_relation_info; TupleCount es_tuplecount; ParamListInfo es_param_list_info; Prs2EStateInfo es_prs2_info; Relation es_explain_relation; int es_BaseId; TupleTable es_tupleTable; JunkFilter es_junkFilter; Pointer es_result_rel_scanstate; RelationRuleInfo es_result_rel_ruleinfo; }; /* ---------------- * Executor Type information needed by plannodes.h * *| Note: the bogus classes CommonState and CommonScanState exist only *| because our inheritance system only allows single inheritance *| and we have to have unique slot names. Hence two or more *| classes which want to have a common slot must ALL inherit *| the slot from some other class. (This is a big hack to *| allow our classes to share slot names..) *| *| Example: *| the class Result and the class NestLoop nodes both want *| a slot called "OuterTuple" so they both have to inherit *| it from some other class. In this case they inherit *| it from CommonState. "CommonState" and "CommonScanState" are *| the best names I could come up with for this sort of *| stuff. *| *| As a result, many classes have extra slots which they *| don't use. These slots are denoted (unused) in the *| comment preceeding the class definition. If you *| comes up with a better idea of a way of doing things *| along these lines, then feel free to make your idea *| known to me.. -cim 10/15/89 * ---------------- */ /* ---------------- * HookNode information * * HookNodes are used to attach debugging routines to the plan * at runtime. The hook functions are passed a pointer * to the node with which they are associated when they are * called. * * at_initnode function called in ExecInitNode when hook is assigned * pre_procnode function called just before ExecProcNode * pre_endnode function called just before ExecEndNode * post_initnode function called just after ExecInitNode * post_procnode function called just after ExecProcNode * post_endnode function called just after ExecEndNode * data pointer to user defined information * * Note: there cannot be a pre_initnode call as this node's * base node is assigned during the initnode processing. * ---------------- */ class (HookNode) public (Node) { #define HookNodeDefs \ inherits0(Node); \ HookFunction hook_at_initnode; \ HookFunction hook_pre_procnode; \ HookFunction hook_pre_endnode; \ HookFunction hook_post_initnode; \ HookFunction hook_post_procnode; \ HookFunction hook_post_endnode; \ Pointer hook_data /* private: */ HookNodeDefs; /* public: */ }; /* ---------------------------------------------------------------- * Common Executor State Information * ---------------------------------------------------------------- */ /* ---------------- * BaseNode information * * BaseNodes are the fundamental superclass for all the * remaining executor state nodes. They contain the important * fields: * * id integer used to keep track of other information * associated with a specific executor state node. * * parent backward pointer to this node's parent node. * * parent_state backward pointer to this node's parent node's * private state. * * hook pointer to this node's hook node, if it exists. * * The id is used to keep track of executor resources and * tuples during the query and the hook is used to attach * debugging information. * ---------------- */ class (BaseNode) public (Node) { #define BaseNodeDefs \ inherits0(Node); \ int base_id; \ Pointer base_parent; \ Pointer base_parent_state; \ HookNode base_hook /* private: */ BaseNodeDefs; /* public: */ }; /* ---------------- * CommonState information * *| this is a bogus class used to hold slots so other *| nodes can inherit them... * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * * old comments * *| ScanAttributes and NumScanAttributes are new -- they are *| used to keep track of the attribute numbers of attributes *| which are actually inspected by the query so the rule manager *| doesn't have to needlessluy check for rules on attributes *| that won't ever be inspected.. *| *| -cim 10/15/89 *| *| ExprContext contains the node's expression context which *| is created and initialized at ExecInit time. Keeping these *| around reduces memory allocations and allows nodes to refer *| to tuples in other nodes (albeit in a gross fashion). -cim 10/30/89 *| *| * SOON: ExprContext will contain indexes of tuples in the tupleTable *| stored in the EState, rather than pointers which it now stores. *| -cim 6/20/90 * ---------------- */ class (CommonState) public (BaseNode) { #define CommonStateDefs \ inherits1(BaseNode); \ TupleTableSlot cs_OuterTupleSlot; \ TupleTableSlot cs_ResultTupleSlot; \ ExprContext cs_ExprContext; \ ProjectionInfo cs_ProjInfo; \ int cs_NumScanAttributes; \ AttributeNumberPtr cs_ScanAttributes /* private: */ CommonStateDefs; /* public: */ }; /* ---------------------------------------------------------------- * Control Node State Information * ---------------------------------------------------------------- */ /* ---------------- * ResultState information * * Loop flag which tells us to quit when we * have already returned a constant tuple. * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (ResultState) public (CommonState) { inherits2(CommonState); int rs_Loop; }; /* ---------------- * AppendState information * * append nodes have this field "unionplans" which is this * list of plans to execute in sequence.. these variables * keep track of things.. * * whichplan which plan is being executed * nplans how many plans are in the list * initialized array of ExecInitNode() results * rtentries range table for the current plan * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (AppendState) public (BaseNode) { inherits2(CommonState); int as_whichplan; int as_nplans; ListPtr as_initialized; List as_rtentries; }; /* ---------------------------------------------------------------- * Scan State Information * ---------------------------------------------------------------- */ /* ---------------- * CommonScanState information * * CommonScanState is a class like CommonState, but is used more * by the nodes like SeqScan and Sort which want to * keep track of an underlying relation. * * currentRelation relation being scanned * currentScanDesc current scan descriptor for scan * ruleInfo information needed by the rule manager. * ScanTupleSlot pointer to slot in tuple table holding scan tuple * RawTupleSlot used by rule manager to hold original tuple * before any rules are applied. * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (CommonScanState) public (CommonState) { #define CommonScanStateDefs \ inherits2(CommonState); \ Relation css_currentRelation; \ HeapScanDesc css_currentScanDesc; \ RelationRuleInfo css_ruleInfo; \ TupleTableSlot css_ScanTupleSlot; \ TupleTableSlot css_RawTupleSlot /* private: */ CommonScanStateDefs; /* public: */ }; /* ---------------- * ScanState information * * ProcOuterFlag need to process outer subtree * OldRelId need for compare for joins if result relid. * * CommonScanState information * * currentRelation relation being scanned * currentScanDesc current scan descriptor for scan * ScanTupleSlot pointer to slot in tuple table holding scan tuple * ViewTupleSlot ... holding the view tuple from the rmgr. * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (ScanState) public (CommonScanState) { inherits3(CommonScanState); /* private: */ bool ss_ProcOuterFlag; Index ss_OldRelId; /* public: */ }; class (ScanTempState) public (CommonScanState) { inherits3(CommonScanState); /* private: */ int st_whichplan; int st_nplans; /* public: */ }; /* ---------------- * IndexScanState information * *| index scans don't use CommonScanState because *| the underlying AM abstractions for heap scans and *| index scans are too different.. It would be nice *| if the current abstraction was more useful but ... -cim 10/15/89 * * IndexPtr current index in use * NumIndices number of indices in this scan * ScanKeys Skey structures to scan index rels * NumScanKeys array of no of keys in each Skey struct * RuntimeKeyInfo array of array of flags for Skeys evaled at runtime * RelationDescs ptr to array of relation descriptors * ScanDescs ptr to array of scan descriptors * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (IndexScanState) public (CommonState) { inherits2(CommonState); int iss_NumIndices; int iss_IndexPtr; ScanKeyPtr iss_ScanKeys; IntPtr iss_NumScanKeys; Pointer iss_RuntimeKeyInfo; RelationPtr iss_RelationDescs; IndexScanDescPtr iss_ScanDescs; }; /* ---------------------------------------------------------------- * Join State Information * ---------------------------------------------------------------- */ /* ---------------- * JoinState information * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (JoinState) public (CommonState) { #define JoinStateDefs \ inherits2(CommonState) /* private: */ JoinStateDefs; /* public: */ }; /* ---------------- * NestLoopState information * * PortalFlag Set to enable portals to work. * * JoinState information * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (NestLoopState) public (JoinState) { inherits3(JoinState); /* private: */ bool nl_PortalFlag; /* public: */ }; /* ---------------- * MergeJoinState information * * OSortopI outerKey1 sortOp innerKey1 ... * ISortopO innerkey1 sortOp outerkey1 ... * JoinState current "state" of join. see executor.h * MarkedTupleSlot pointer to slot in tuple table for marked tuple * * JoinState information * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (MergeJoinState) public (JoinState) { inherits3(JoinState); /* private: */ List mj_OSortopI; List mj_ISortopO; int mj_JoinState; TupleTableSlot mj_MarkedTupleSlot; /* public: */ }; typedef File *FileP; typedef char *charP; /* ---------------- * HashJoinState information * * hj_HashTable address of the hash table for the hashjoin * hj_HashTableShmId shared memory id of hash table * hj_CurBucket the current hash bucket that we are searching * for matches of the current outer tuple * hj_CurTuple the current matching inner tuple in the * current hash bucket * hj_CurOTuple the current matching inner tuple in the * current hash overflow chain * hj_InnerHashKey the inner hash key in the hashjoin condition * hj_OuterBatches file descriptors for outer batches * hj_InnerBatches file descriptors for inner batches * hj_OuterReadPos current read position of outer batch * hj_OuterReadBlk current read block of outer batch * hj_OuterTupleSlot tuple slot for outer tuples * hj_HashTupleSlot tuple slot for hashed tuples * * * * JoinState information * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (HashJoinState) public (JoinState) { inherits3(JoinState); /* private: */ HashJoinTable hj_HashTable; IpcMemoryId hj_HashTableShmId; HashBucket hj_CurBucket; HeapTuple hj_CurTuple; OverflowTuple hj_CurOTuple; Var hj_InnerHashKey; FileP hj_OuterBatches; FileP hj_InnerBatches; charP hj_OuterReadPos; int hj_OuterReadBlk; Pointer hj_OuterTupleSlot; Pointer hj_HashTupleSlot; /* public: */ }; /* ---------------------------------------------------------------- * Materialization State Information * ---------------------------------------------------------------- */ /* ---------------- * MaterialState information * * materialize nodes are used to materialize the results * of a subplan into a temporary relation. * * Flag indicated whether subplan has been materialized * TempRelation temporary relation containing result of executing * the subplan. * * CommonScanState information * * currentRelation relation descriptor of sorted relation * currentScanDesc current scan descriptor for scan * ScanTupleSlot pointer to slot in tuple table holding scan tuple * ViewTupleSlot ... holding the view tuple from the rmgr. * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (MaterialState) public (CommonScanState) { inherits3(CommonScanState); /* private: */ bool mat_Flag; Relation mat_TempRelation; /* public: */ }; /* --------------------- * AggregateState information * * aggregate nodes are used to modify and materialize the results * of a subplan into a temporary relation. Instead of just placing * the tuples in the temp relation, the Agg node retrieves a tuple * from the temp relation using the "by" index if there is one, and * modifies the returned tuple to reflect the changes caused by * aggregation. When the subplan returns no more tuples, the final * state function is performed, and the temp relation contains the * computed aggregate(s). * * Flag indicated whether aggregate has been materialized * TempRelation temporary relation containing result of aggregating * the subplan. * *clause* *not used until aggregate functions are supported* * * CommonScanState information * * currentRelation relation descriptor of sorted relation * currentScanDesc current scan descriptor for scan * ScanTupleSlot pointer to slot in tuple table holding scan tuple * ViewTupleSlot ... holding the view tuple from the rmgr. * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node ues to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ------------------------- */ class (AggState) public (CommonScanState) { inherits3(CommonScanState); /* private: */ bool agg_Flag; Relation agg_TempRelation; /*public: */ }; /* ---------------- * SortState information * *| sort nodes are really just a kind of a scan since *| we implement sorts by retrieveing the entire subplan *| into a temp relation, sorting the temp relation into *| another sorted relation, and then preforming a simple *| unqualified sequential scan on the sorted relation.. *| -cim 10/15/89 * * Flag indicated whether relation has been sorted * Keys scan key structures used to keep info on sort keys * TempRelation temporary relation containing result of executing * the subplan. * * CommonScanState information * * currentRelation relation descriptor of sorted relation * currentScanDesc current scan descriptor for scan * ScanTupleSlot pointer to slot in tuple table holding scan tuple * ViewTupleSlot ... holding the view tuple from the rmgr. * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (SortState) public (CommonScanState) { #define SortStateDefs \ inherits3(CommonScanState); \ bool sort_Flag; \ Pointer sort_Keys; \ Relation sort_TempRelation /* private: */ SortStateDefs; /* public: */ }; /* ---------------- * UniqueState information * * Unique nodes are used "on top of" sort nodes to discard * duplicate tuples returned from the sort phase. Basically * all it does is compare the current tuple from the subplan * with the previously fetched tuple stored in OuterTuple and * if the two are identical, then we just fetch another tuple * from the sort and try again. * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (UniqueState) public (CommonState) { inherits2(CommonState); /* private: */ /* public: */ }; /* ---------------- * HashState information * * hashBatches file descriptors for the batches * * CommonState information * * OuterTupleSlot pointer to slot containing current "outer" tuple * ResultTupleSlot pointer to slot in tuple table for projected tuple * ExprContext node's current expression context * ProjInfo info this node uses to form tuple projections * NumScanAttributes size of ScanAttributes array * ScanAttributes attribute numbers of interest in this tuple * ---------------- */ class (HashState) public (CommonState) { inherits2(CommonState); /* private: */ FileP hashBatches; /* public: */ }; #endif /* ExecNodesIncluded */