自学教程：C++ ExecInitScanTupleSlot函数代码示例

/* ---------------------------------------------------------------- *		ExecInitWorkTableScan * ---------------------------------------------------------------- */WorkTableScanState *ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags){	WorkTableScanState *scanstate;	/* check for unsupported flags */	/*	 * GPDB_84_MERGE_FIXME: Make sure we don't require EXEC_FLAG_BACKWARD	 * in GPDB.	 */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * WorkTableScan should not have any children.	 */	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create new WorkTableScanState for node	 */	scanstate = makeNode(WorkTableScanState);	scanstate->ss.ps.plan = (Plan *) node;	scanstate->ss.ps.state = estate;	scanstate->rustate = NULL;	/* we'll set this later */	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ss.ps);	/*	 * initialize child expressions	 */	scanstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) scanstate);	scanstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) scanstate);#define WORKTABLESCAN_NSLOTS 2	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &scanstate->ss.ps);	ExecInitScanTupleSlot(estate, &scanstate->ss);	/*	 * Initialize result tuple type, but not yet projection info.	 */	ExecAssignResultTypeFromTL(&scanstate->ss.ps);	/* scanstate->ss.ps.ps_TupFromTlist = false; */	return scanstate;}

/* ---------------------------------------------------------------- *		ExecInitSeqScan * ---------------------------------------------------------------- */SeqScanState *ExecInitSeqScan(SeqScan *node, EState *estate, int eflags){	SeqScanState *scanstate;	AttrNumber ctid_attrno;	/*	 * Once upon a time it was possible to have an outerPlan of a SeqScan, but	 * not any more.	 */	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create state structure	 */	scanstate = makeNode(SeqScanState);	scanstate->ps.plan = (Plan *) node;	scanstate->ps.state = estate;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ps);	/*	 * initialize child expressions	 */	scanstate->ps.targetlist = (List *)		ExecInitExpr((Expr *) node->plan.targetlist,					 (PlanState *) scanstate);	scanstate->ps.qual = (List *)		ExecInitExpr((Expr *) node->plan.qual,					 (PlanState *) scanstate);#define SEQSCAN_NSLOTS 2	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &scanstate->ps);	ExecInitScanTupleSlot(estate, scanstate);	/*	 * initialize scan relation	 */	InitScanRelation(scanstate, estate);	scanstate->ps.ps_TupFromTlist = false;	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&scanstate->ps);	ExecAssignScanProjectionInfo(scanstate);	return scanstate;}

/* ---------------------------------------------------------------- *		ExecInitAppendOnlyScan * ---------------------------------------------------------------- */AppendOnlyScanState *ExecInitAppendOnlyScan(AppendOnlyScan *node, EState *estate, int eflags){	AppendOnlyScanState	*appendonlystate;	Relation			currentRelation;		Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create state structure	 */	appendonlystate = makeNode(AppendOnlyScanState);	appendonlystate->ss.ps.plan = (Plan *) node;	appendonlystate->ss.ps.state = estate;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &appendonlystate->ss.ps);	/*	 * initialize child expressions	 */	appendonlystate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) appendonlystate);	appendonlystate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) appendonlystate);#define AOSCAN_NSLOTS 2	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &appendonlystate->ss.ps);	ExecInitScanTupleSlot(estate, &appendonlystate->ss);	/*	 * get the relation object id from the relid'th entry in the range table	 * and open that relation.	 */	currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid);		appendonlystate->ss.ss_currentRelation = currentRelation;	ExecAssignScanType(&appendonlystate->ss, RelationGetDescr(currentRelation));		/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&appendonlystate->ss.ps);	ExecAssignScanProjectionInfo(&appendonlystate->ss);	initGpmonPktForAppendOnlyScan((Plan *)node, &appendonlystate->ss.ps.gpmon_pkt, estate);	return appendonlystate;}

/* ----------------- * ExecInitGroup * *	Creates the run-time information for the group node produced by the *	planner and initializes its outer subtree * ----------------- */GroupState *ExecInitGroup(Group *node, EState *estate, int eflags){	GroupState *grpstate;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * create state structure	 */	grpstate = makeNode(GroupState);	grpstate->ss.ps.plan = (Plan *) node;	grpstate->ss.ps.state = estate;	grpstate->ss.ps.ExecProcNode = ExecGroup;	grpstate->grp_done = false;	/*	 * create expression context	 */	ExecAssignExprContext(estate, &grpstate->ss.ps);	/*	 * tuple table initialization	 */	ExecInitScanTupleSlot(estate, &grpstate->ss);	ExecInitResultTupleSlot(estate, &grpstate->ss.ps);	/*	 * initialize child expressions	 */	grpstate->ss.ps.qual =		ExecInitQual(node->plan.qual, (PlanState *) grpstate);	/*	 * initialize child nodes	 */	outerPlanState(grpstate) = ExecInitNode(outerPlan(node), estate, eflags);	/*	 * initialize tuple type.	 */	ExecAssignScanTypeFromOuterPlan(&grpstate->ss);	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&grpstate->ss.ps);	ExecAssignProjectionInfo(&grpstate->ss.ps, NULL);	/*	 * Precompute fmgr lookup data for inner loop	 */	grpstate->eqfunctions =		execTuplesMatchPrepare(node->numCols,							   node->grpOperators);	return grpstate;}

/* ---------------------------------------------------------------- *		ExecInitWorkTableScan * ---------------------------------------------------------------- */WorkTableScanState *ExecInitWorkTableScan(WorkTableScan *node, EState *estate, int eflags){	WorkTableScanState *scanstate;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * WorkTableScan should not have any children.	 */	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create new WorkTableScanState for node	 */	scanstate = makeNode(WorkTableScanState);	scanstate->ss.ps.plan = (Plan *) node;	scanstate->ss.ps.state = estate;	scanstate->ss.ps.ExecProcNode = ExecWorkTableScan;	scanstate->rustate = NULL;	/* we'll set this later */	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ss.ps);	/*	 * tuple table initialization	 */	ExecInitResultTypeTL(&scanstate->ss.ps);	/* signal that return type is not yet known */	scanstate->ss.ps.resultopsset = true;	scanstate->ss.ps.resultopsfixed = false;	ExecInitScanTupleSlot(estate, &scanstate->ss, NULL, &TTSOpsMinimalTuple);	/*	 * initialize child expressions	 */	scanstate->ss.ps.qual =		ExecInitQual(node->scan.plan.qual, (PlanState *) scanstate);	/*	 * Do not yet initialize projection info, see ExecWorkTableScan() for	 * details.	 */	return scanstate;}

/* ---------------------------------------------------------------- *		ExecInitSeqScan * ---------------------------------------------------------------- */SeqScanState *ExecInitSeqScan(SeqScan *node, EState *estate, int eflags){	SeqScanState *scanstate;	/*	 * Once upon a time it was possible to have an outerPlan of a SeqScan, but	 * not any more.	 */	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create state structure	 */	scanstate = makeNode(SeqScanState);	scanstate->ss.ps.plan = (Plan *) node;	scanstate->ss.ps.state = estate;	scanstate->ss.ps.ExecProcNode = ExecSeqScan;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ss.ps);	/*	 * initialize child expressions	 */	scanstate->ss.ps.qual =		ExecInitQual(node->plan.qual, (PlanState *) scanstate);	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &scanstate->ss.ps);	ExecInitScanTupleSlot(estate, &scanstate->ss);	/*	 * initialize scan relation	 */	InitScanRelation(scanstate, estate, eflags);	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&scanstate->ss.ps);	ExecAssignScanProjectionInfo(&scanstate->ss);	return scanstate;}

/* ---------------- *		ExecCreateSlotFromOuterPlan * ---------------- */voidExecCreateScanSlotFromOuterPlan(EState *estate,								ScanState *scanstate,								const TupleTableSlotOps *tts_ops){	PlanState  *outerPlan;	TupleDesc	tupDesc;	outerPlan = outerPlanState(scanstate);	tupDesc = ExecGetResultType(outerPlan);	ExecInitScanTupleSlot(estate, scanstate, tupDesc, tts_ops);}

/* ---------------------------------------------------------------- *		ExecInitMaterial * ---------------------------------------------------------------- */MaterialState *ExecInitMaterial(Material *node, EState *estate){	MaterialState *matstate;	Plan	   *outerPlan;	/*	 * create state structure	 */	matstate = makeNode(MaterialState);	matstate->ss.ps.plan = (Plan *) node;	matstate->ss.ps.state = estate;	matstate->tuplestorestate = NULL;	matstate->eof_underlying = false;	/*	 * Miscellaneous initialization	 *	 * Materialization nodes don't need ExprContexts because they never call	 * ExecQual or ExecProject.	 */#define MATERIAL_NSLOTS 2	/*	 * tuple table initialization	 *	 * material nodes only return tuples from their materialized relation.	 */	ExecInitResultTupleSlot(estate, &matstate->ss.ps);	ExecInitScanTupleSlot(estate, &matstate->ss);	/*	 * initializes child nodes	 */	outerPlan = outerPlan(node);	outerPlanState(matstate) = ExecInitNode(outerPlan, estate);	/*	 * initialize tuple type.  no need to initialize projection info because	 * this node doesn't do projections.	 */	ExecAssignResultTypeFromTL(&matstate->ss.ps);	ExecAssignScanTypeFromOuterPlan(&matstate->ss);	matstate->ss.ps.ps_ProjInfo = NULL;	return matstate;}

/* * InitScanStateInternal *   Initialize ScanState common variables for various Scan node. */voidInitScanStateInternal(ScanState *scanState, Plan *plan, EState *estate,		int eflags, bool initCurrentRelation){	Assert(IsA(plan, SeqScan) ||		   IsA(plan, AppendOnlyScan) ||		   IsA(plan, ParquetScan) ||		   IsA(plan, TableScan) ||		   IsA(plan, DynamicTableScan) ||		   IsA(plan, BitmapTableScan));	PlanState *planState = &scanState->ps;	planState->plan = plan;	planState->state = estate;	/* Create expression evaluation context */	ExecAssignExprContext(estate, planState);		/* Initialize tuple table slot */	ExecInitResultTupleSlot(estate, planState);	ExecInitScanTupleSlot(estate, scanState);		/*	 * For dynamic table scan, We do not initialize expression states; instead	 * we wait until the first partition, and initialize the expression state	 * at that time. Also, for dynamic table scan, we do not need to open the	 * parent partition relation.	 */	if (initCurrentRelation)	{		InitScanStateRelationDetails(scanState, plan, estate);	}	/* Initialize result tuple type. */	ExecAssignResultTypeFromTL(planState);	/*	 * If eflag contains EXEC_FLAG_REWIND or EXEC_FLAG_BACKWARD or EXEC_FLAG_MARK,	 * then this node is not eager free safe.	 */	scanState->ps.delayEagerFree =		((eflags & (EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)) != 0);	/* Currently, only SeqScan supports Mark/Restore. */	AssertImply((eflags & EXEC_FLAG_MARK) != 0, IsA(plan, SeqScan));}

extern TuplestoreScanState *ExecInitTuplestoreScan(TuplestoreScan *node, EState *estate, int eflags){	TuplestoreScanState *tss = makeNode(TuplestoreScanState);	tss->ss.ps.plan = (Plan *) node;	tss->ss.ps.state = estate;	tss->ss.ps.ps_ExprContext = CreateExprContext(estate);	ExecInitResultTupleSlot(estate, &tss->ss.ps);	ExecInitScanTupleSlot(estate, &tss->ss);	ExecSetSlotDescriptor(tss->ss.ss_ScanTupleSlot, node->desc);	ExecSetSlotDescriptor(tss->ss.ps.ps_ResultTupleSlot, node->desc);	tss->ss.ps.targetlist = node->scan.plan.targetlist;	tuplestore_rescan(node->store);	return tss;}

/* ---------------------------------------------------------------- *		ExecInitIndexOnlyScan * *		Initializes the index scan's state information, creates *		scan keys, and opens the base and index relations. * *		Note: index scans have 2 sets of state information because *			  we have to keep track of the base relation and the *			  index relation. * ---------------------------------------------------------------- */IndexOnlyScanState *ExecInitIndexOnlyScan(IndexOnlyScan *node, EState *estate, int eflags){	IndexOnlyScanState *indexstate;	Relation	currentRelation;	bool		relistarget;	TupleDesc	tupDesc;	/*	 * create state structure	 */	indexstate = makeNode(IndexOnlyScanState);	indexstate->ss.ps.plan = (Plan *) node;	indexstate->ss.ps.state = estate;	indexstate->ioss_HeapFetches = 0;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &indexstate->ss.ps);	indexstate->ss.ps.ps_TupFromTlist = false;	/*	 * initialize child expressions	 *	 * Note: we don't initialize all of the indexorderby expression, only the	 * sub-parts corresponding to runtime keys (see below).	 */	indexstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) indexstate);	indexstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) indexstate);	indexstate->indexqual = (List *)		ExecInitExpr((Expr *) node->indexqual,					 (PlanState *) indexstate);	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &indexstate->ss.ps);	ExecInitScanTupleSlot(estate, &indexstate->ss);	/*	 * open the base relation and acquire appropriate lock on it.	 */	currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);	indexstate->ss.ss_currentRelation = currentRelation;	indexstate->ss.ss_currentScanDesc = NULL;	/* no heap scan here */	/*	 * Build the scan tuple type using the indextlist generated by the	 * planner.  We use this, rather than the index's physical tuple	 * descriptor, because the latter contains storage column types not the	 * types of the original datums.  (It's the AM's responsibility to return	 * suitable data anyway.)	 */	tupDesc = ExecTypeFromTL(node->indextlist, false);	ExecAssignScanType(&indexstate->ss, tupDesc);	/*	 * Initialize result tuple type and projection info.  The node's	 * targetlist will contain Vars with varno = INDEX_VAR, referencing the	 * scan tuple.	 */	ExecAssignResultTypeFromTL(&indexstate->ss.ps);	ExecAssignScanProjectionInfoWithVarno(&indexstate->ss, INDEX_VAR);	/*	 * If we are just doing EXPLAIN (ie, aren't going to run the plan), stop	 * here.  This allows an index-advisor plugin to EXPLAIN a plan containing	 * references to nonexistent indexes.	 */	if (eflags & EXEC_FLAG_EXPLAIN_ONLY)		return indexstate;	/*	 * Open the index relation.	 *	 * If the parent table is one of the target relations of the query, then	 * InitPlan already opened and write-locked the index, so we can avoid	 * taking another lock here.  Otherwise we need a normal reader's lock.	 */	relistarget = ExecRelationIsTargetRelation(estate, node->scan.scanrelid);//.........这里部分代码省略.........

CustomScanState *ExecInitCustomScan(CustomScan *cscan, EState *estate, int eflags){	CustomScanState *css;	Relation	scan_rel = NULL;	Index		scanrelid = cscan->scan.scanrelid;	Index		tlistvarno;	/*	 * Allocate the CustomScanState object.  We let the custom scan provider	 * do the palloc, in case it wants to make a larger object that embeds	 * CustomScanState as the first field.  It must set the node tag and the	 * methods field correctly at this time.  Other standard fields should be	 * set to zero.	 */	css = (CustomScanState *) cscan->methods->CreateCustomScanState(cscan);	Assert(IsA(css, CustomScanState));	/* ensure flags is filled correctly */	css->flags = cscan->flags;	/* fill up fields of ScanState */	css->ss.ps.plan = &cscan->scan.plan;	css->ss.ps.state = estate;	/* create expression context for node */	ExecAssignExprContext(estate, &css->ss.ps);#ifdef PG95	css->ss.ps.ps_TupFromTlist = false;#endif	/* initialize child expressions */	css->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) cscan->scan.plan.targetlist,					 (PlanState *) css);	css->ss.ps.qual = (List *)		ExecInitExpr((Expr *) cscan->scan.plan.qual,					 (PlanState *) css);	/* tuple table initialization */#ifndef PG95	if (((Scan*)css->ss.ps.plan)->scanrelid) {		// For table scans		ExecInitScanTupleSlot(estate, &css->ss);	}	else {		// For tuple-table-slot scans (typically over Motion nodes)		css->ss.ss_ScanTupleSlot = ExecAllocTableSlot(&estate->es_tupleTable);	}#else	ExecInitScanTupleSlot(estate, &css->ss);#endif	ExecInitResultTupleSlot(estate, &css->ss.ps);	/*	 * open the base relation, if any, and acquire an appropriate lock on it	 */	if (scanrelid > 0)	{		scan_rel = ExecOpenScanRelation(estate										, scanrelid#ifdef PG95										, eflags#endif		);		css->ss.ss_currentRelation = scan_rel;	}	/*	 * Determine the scan tuple type.  If the custom scan provider provided a	 * targetlist describing the scan tuples, use that; else use base	 * relation's rowtype.	 */	if (cscan->custom_scan_tlist != NIL || scan_rel == NULL)	{		// index-only scan? GP doesn't define INDEX_VAR		TupleDesc	scan_tupdesc;		scan_tupdesc = ExecTypeFromTL(cscan->custom_scan_tlist, false);		ExecAssignScanType(&css->ss, scan_tupdesc);#ifdef PG95		/* Node's targetlist will contain Vars with varno = INDEX_VAR */		tlistvarno = INDEX_VAR;#endif	}	else	{		ExecAssignScanType(&css->ss, RelationGetDescr(scan_rel));		/* Node's targetlist will contain Vars with varno = scanrelid */		tlistvarno = scanrelid;	}	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&css->ss.ps);#ifdef PG95	ExecAssignScanProjectionInfoWithVarno(&css->ss, tlistvarno);#else//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitIndexScan * *		Initializes the index scan's state information, creates *		scan keys, and opens the base and index relations. * *		Note: index scans have 2 sets of state information because *			  we have to keep track of the base relation and the *			  index relation. * ---------------------------------------------------------------- */IndexScanState *ExecInitIndexScan(IndexScan *node, EState *estate, int eflags){    IndexScanState *indexstate;    Relation	currentRelation;    bool		relistarget;    /*     * create state structure     */    indexstate = makeNode(IndexScanState);    indexstate->ss.ps.plan = (Plan *) node;    indexstate->ss.ps.state = estate;    /*     * Miscellaneous initialization     *     * create expression context for node     */    ExecAssignExprContext(estate, &indexstate->ss.ps);    /*indexstate->ss.ps.ps_TupFromTlist = false;*/    /*     * initialize child expressions     *     * Note: we don't initialize all of the indexqual expression, only the     * sub-parts corresponding to runtime keys (see below).  The indexqualorig     * expression is always initialized even though it will only be used in     * some uncommon cases --- would be nice to improve that.  (Problem is     * that any SubPlans present in the expression must be found now...)     */    indexstate->ss.ps.targetlist = (List *)                                   ExecInitExpr((Expr *) node->scan.plan.targetlist,                                           (PlanState *) indexstate);    indexstate->ss.ps.qual = (List *)                             ExecInitExpr((Expr *) node->scan.plan.qual,                                          (PlanState *) indexstate);    indexstate->indexqualorig = (List *)                                ExecInitExpr((Expr *) node->indexqualorig,                                        (PlanState *) indexstate);#define INDEXSCAN_NSLOTS 2    /*     * tuple table initialization     */    ExecInitResultTupleSlot(estate, &indexstate->ss.ps);    ExecInitScanTupleSlot(estate, &indexstate->ss);    /*     * open the base relation and acquire appropriate lock on it.     */    currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid);    indexstate->ss.ss_currentRelation = currentRelation;    /*     * get the scan type from the relation descriptor.     */    ExecAssignScanType(&indexstate->ss, RelationGetDescr(currentRelation));    /*     * Open the index relation.     *     * If the parent table is one of the target relations of the query, then     * InitPlan already opened and write-locked the index, so we can avoid     * taking another lock here.  Otherwise we need a normal reader's lock.     */    relistarget = ExecRelationIsTargetRelation(estate, node->scan.scanrelid);    indexstate->iss_RelationDesc = index_open(node->indexid,                                   relistarget ? NoLock : AccessShareLock);    /*     * build the index scan keys from the index qualification     */    ExecIndexBuildScanKeys((PlanState *) indexstate,                           indexstate->iss_RelationDesc,                           node->indexqual,                           node->indexstrategy,                           node->indexsubtype,                           &indexstate->iss_ScanKeys,                           &indexstate->iss_NumScanKeys,                           &indexstate->iss_RuntimeKeys,                           &indexstate->iss_NumRuntimeKeys,                           NULL,	/* no ArrayKeys */                           NULL);    /*//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitBitmapHeapScan * *		Initializes the scan's state information. * ---------------------------------------------------------------- */BitmapHeapScanState *ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags){	BitmapHeapScanState *scanstate;	Relation	currentRelation;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * Assert caller didn't ask for an unsafe snapshot --- see comments at	 * head of file.	 */	Assert(IsMVCCSnapshot(estate->es_snapshot));	/*	 * create state structure	 */	scanstate = makeNode(BitmapHeapScanState);	scanstate->ss.ps.plan = (Plan *) node;	scanstate->ss.ps.state = estate;	scanstate->tbm = NULL;	scanstate->tbmiterator = NULL;	scanstate->tbmres = NULL;	scanstate->prefetch_iterator = NULL;	scanstate->prefetch_pages = 0;	scanstate->prefetch_target = 0;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ss.ps);	scanstate->ss.ps.ps_TupFromTlist = false;	/*	 * initialize child expressions	 */	scanstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) scanstate);	scanstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) scanstate);	scanstate->bitmapqualorig = (List *)		ExecInitExpr((Expr *) node->bitmapqualorig,					 (PlanState *) scanstate);	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &scanstate->ss.ps);	ExecInitScanTupleSlot(estate, &scanstate->ss);	/*	 * open the base relation and acquire appropriate lock on it.	 */	currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid);	scanstate->ss.ss_currentRelation = currentRelation;	/*	 * Even though we aren't going to do a conventional seqscan, it is useful	 * to create a HeapScanDesc --- most of the fields in it are usable.	 */	scanstate->ss.ss_currentScanDesc = heap_beginscan_bm(currentRelation,														 estate->es_snapshot,														 0,														 NULL);	/*	 * get the scan type from the relation descriptor.	 */	ExecAssignScanType(&scanstate->ss, RelationGetDescr(currentRelation));	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&scanstate->ss.ps);	ExecAssignScanProjectionInfo(&scanstate->ss);	/*	 * initialize child nodes	 *	 * We do this last because the child nodes will open indexscans on our	 * relation's indexes, and we want to be sure we have acquired a lock on	 * the relation first.	 */	outerPlanState(scanstate) = ExecInitNode(outerPlan(node), estate, eflags);	/*//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitSubqueryScan * ---------------------------------------------------------------- */SubqueryScanState *ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags){	SubqueryScanState *subquerystate;	/* check for unsupported flags */	Assert(!(eflags & EXEC_FLAG_MARK));	/* SubqueryScan should not have any "normal" children */	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create state structure	 */	subquerystate = makeNode(SubqueryScanState);	subquerystate->ss.ps.plan = (Plan *) node;	subquerystate->ss.ps.state = estate;	subquerystate->ss.ps.ExecProcNode = ExecSubqueryScan;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &subquerystate->ss.ps);	/*	 * initialize subquery	 */	subquerystate->subplan = ExecInitNode(node->subplan, estate, eflags);	/*	 * Initialize scan slot and type (needed by ExecAssignScanProjectionInfo)	 */	ExecInitScanTupleSlot(estate, &subquerystate->ss,						  ExecGetResultType(subquerystate->subplan),						  ExecGetResultSlotOps(subquerystate->subplan, NULL));	/*	 * The slot used as the scantuple isn't the slot above (outside of EPQ),	 * but the one from the node below.	 */	subquerystate->ss.ps.scanopsset = true;	subquerystate->ss.ps.scanops = ExecGetResultSlotOps(subquerystate->subplan,														&subquerystate->ss.ps.scanopsfixed);	subquerystate->ss.ps.resultopsset = true;	subquerystate->ss.ps.resultops = subquerystate->ss.ps.scanops;	subquerystate->ss.ps.resultopsfixed = subquerystate->ss.ps.scanopsfixed;	/*	 * Initialize result type and projection.	 */	ExecInitResultTypeTL(&subquerystate->ss.ps);	ExecAssignScanProjectionInfo(&subquerystate->ss);	/*	 * initialize child expressions	 */	subquerystate->ss.ps.qual =		ExecInitQual(node->scan.plan.qual, (PlanState *) subquerystate);	return subquerystate;}

/* ---------------------------------------------------------------- *		ExecInitMaterial * ---------------------------------------------------------------- */MaterialState *ExecInitMaterial(Material *node, EState *estate, int eflags){	MaterialState *matstate;	Plan	   *outerPlan;	/*	 * create state structure	 */	matstate = makeNode(MaterialState);	matstate->ss.ps.plan = (Plan *) node;	matstate->ss.ps.state = estate;	/*	 * We must have random access to the subplan output to do backward scan	 * or mark/restore.  We also prefer to materialize the subplan output	 * if we might be called on to rewind and replay it many times.	 * However, if none of these cases apply, we can skip storing the data.	 */	matstate->randomAccess = (eflags & (EXEC_FLAG_REWIND |										EXEC_FLAG_BACKWARD |										EXEC_FLAG_MARK)) != 0;	matstate->eof_underlying = false;	matstate->tuplestorestate = NULL;	/*	 * Miscellaneous initialization	 *	 * Materialization nodes don't need ExprContexts because they never call	 * ExecQual or ExecProject.	 */#define MATERIAL_NSLOTS 2	/*	 * tuple table initialization	 *	 * material nodes only return tuples from their materialized relation.	 */	ExecInitResultTupleSlot(estate, &matstate->ss.ps);	ExecInitScanTupleSlot(estate, &matstate->ss);	/*	 * initialize child nodes	 *	 * We shield the child node from the need to support REWIND, BACKWARD,	 * or MARK/RESTORE.	 */	eflags &= ~(EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK);	outerPlan = outerPlan(node);	outerPlanState(matstate) = ExecInitNode(outerPlan, estate, eflags);	/*	 * initialize tuple type.  no need to initialize projection info because	 * this node doesn't do projections.	 */	ExecAssignResultTypeFromTL(&matstate->ss.ps);	ExecAssignScanTypeFromOuterPlan(&matstate->ss);	matstate->ss.ps.ps_ProjInfo = NULL;	return matstate;}

//.........这里部分代码省略.........	 * Note: if we are in an EPQ recheck plan tree, it's likely that no access	 * to the tuplestore is needed at all, making this even more annoying.	 * It's not worth improving that as long as all the read pointers would	 * have REWIND anyway, but if we ever improve this logic then that aspect	 * should be considered too.	 */	eflags |= EXEC_FLAG_REWIND;	/*	 * CteScan should not have any children.	 */	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create new CteScanState for node	 */	scanstate = makeNode(CteScanState);	scanstate->ss.ps.plan = (Plan *) node;	scanstate->ss.ps.state = estate;	scanstate->eflags = eflags;	scanstate->cte_table = NULL;	scanstate->eof_cte = false;	/*	 * Find the already-initialized plan for the CTE query.	 */	scanstate->cteplanstate = (PlanState *) list_nth(estate->es_subplanstates,													 node->ctePlanId - 1);	/*	 * The Param slot associated with the CTE query is used to hold a pointer	 * to the CteState of the first CteScan node that initializes for this	 * CTE.  This node will be the one that holds the shared state for all the	 * CTEs, particularly the shared tuplestore.	 */	prmdata = &(estate->es_param_exec_vals[node->cteParam]);	Assert(prmdata->execPlan == NULL);	Assert(!prmdata->isnull);	scanstate->leader = (CteScanState *) DatumGetPointer(prmdata->value);	if (scanstate->leader == NULL)	{		/* I am the leader */		prmdata->value = PointerGetDatum(scanstate);		scanstate->leader = scanstate;		scanstate->cte_table = tuplestore_begin_heap(true, false, work_mem);		tuplestore_set_eflags(scanstate->cte_table, scanstate->eflags);		scanstate->readptr = 0;	}	else	{		/* Not the leader */		Assert(IsA(scanstate->leader, CteScanState));		/* Create my own read pointer, and ensure it is at start */		scanstate->readptr =			tuplestore_alloc_read_pointer(scanstate->leader->cte_table,										  scanstate->eflags);		tuplestore_select_read_pointer(scanstate->leader->cte_table,									   scanstate->readptr);		tuplestore_rescan(scanstate->leader->cte_table);	}	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ss.ps);	/*	 * initialize child expressions	 */	scanstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) scanstate);	scanstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) scanstate);	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &scanstate->ss.ps);	ExecInitScanTupleSlot(estate, &scanstate->ss);	/*	 * The scan tuple type (ie, the rowtype we expect to find in the work	 * table) is the same as the result rowtype of the CTE query.	 */	ExecAssignScanType(&scanstate->ss,					   ExecGetResultType(scanstate->cteplanstate));	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&scanstate->ss.ps);	ExecAssignScanProjectionInfo(&scanstate->ss);	return scanstate;}

/* ---------------------------------------------------------------- *		ExecInitFunctionScan * ---------------------------------------------------------------- */FunctionScanState *ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags){	FunctionScanState *scanstate;	Oid			funcrettype;	TypeFuncClass functypclass;	TupleDesc	tupdesc = NULL;	/* check for unsupported flags */	Assert(!(eflags & EXEC_FLAG_MARK));	/*	 * FunctionScan should not have any children.	 */	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create new ScanState for node	 */	scanstate = makeNode(FunctionScanState);	scanstate->ss.ps.plan = (Plan *) node;	scanstate->ss.ps.state = estate;	scanstate->eflags = eflags;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ss.ps);	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &scanstate->ss.ps);	ExecInitScanTupleSlot(estate, &scanstate->ss);	/*	 * initialize child expressions	 */	scanstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) scanstate);	scanstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) scanstate);	/*	 * Now determine if the function returns a simple or composite type, and	 * build an appropriate tupdesc.	 */	functypclass = get_expr_result_type(node->funcexpr,										&funcrettype,										&tupdesc);	if (functypclass == TYPEFUNC_COMPOSITE)	{		/* Composite data type, e.g. a table's row type */		Assert(tupdesc);		/* Must copy it out of typcache for safety */		tupdesc = CreateTupleDescCopy(tupdesc);	}	else if (functypclass == TYPEFUNC_SCALAR)	{		/* Base data type, i.e. scalar */		char	   *attname = strVal(linitial(node->funccolnames));		tupdesc = CreateTemplateTupleDesc(1, false);		TupleDescInitEntry(tupdesc,						   (AttrNumber) 1,						   attname,						   funcrettype,						   -1,						   0);	}	else if (functypclass == TYPEFUNC_RECORD)	{		tupdesc = BuildDescFromLists(node->funccolnames,									 node->funccoltypes,									 node->funccoltypmods);	}	else	{		/* crummy error message, but parser should have caught this */		elog(ERROR, "function in FROM has unsupported return type");	}	/*	 * For RECORD results, make sure a typmod has been assigned.  (The	 * function should do this for itself, but let's cover things in case it	 * doesn't.)	 */	BlessTupleDesc(tupdesc);	scanstate->tupdesc = tupdesc;//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitBitmapHeapScan * *		Initializes the scan's state information. * ---------------------------------------------------------------- */BitmapHeapScanState *ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags){	BitmapHeapScanState *scanstate;	Relation	currentRelation;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * Assert caller didn't ask for an unsafe snapshot --- see comments at	 * head of file.	 */	Assert(IsMVCCSnapshot(estate->es_snapshot));	/*	 * create state structure	 */	scanstate = makeNode(BitmapHeapScanState);	scanstate->ss.ps.plan = (Plan *) node;	scanstate->ss.ps.state = estate;	scanstate->tbm = NULL;	scanstate->tbmres = NULL;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ss.ps);	scanstate->ss.ps.ps_TupFromTlist = false;	/*	 * initialize child expressions	 */	scanstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) scanstate);	scanstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) scanstate);	scanstate->bitmapqualorig = (List *)		ExecInitExpr((Expr *) node->bitmapqualorig,					 (PlanState *) scanstate);#define BITMAPHEAPSCAN_NSLOTS 2	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &scanstate->ss.ps);	ExecInitScanTupleSlot(estate, &scanstate->ss);	/*	 * open the base relation and acquire appropriate lock on it.	 */	currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid);	scanstate->ss.ss_currentRelation = currentRelation;	/*	 * Even though we aren't going to do a conventional seqscan, it is useful	 * to create a HeapScanDesc --- this checks the relation size and sets up	 * statistical infrastructure for us.	 */	scanstate->ss.ss_currentScanDesc = heap_beginscan(currentRelation,													  estate->es_snapshot,													  0,													  NULL);	/*	 * One problem is that heap_beginscan counts a "sequential scan" start,	 * when we actually aren't doing any such thing.  Reverse out the added	 * scan count.	(Eventually we may want to count bitmap scans separately.)	 */	pgstat_discount_heap_scan(&scanstate->ss.ss_currentScanDesc->rs_pgstat_info);	/*	 * get the scan type from the relation descriptor.	 */	ExecAssignScanType(&scanstate->ss, RelationGetDescr(currentRelation));	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&scanstate->ss.ps);	ExecAssignScanProjectionInfo(&scanstate->ss);	/*	 * initialize child nodes	 *	 * We do this last because the child nodes will open indexscans on our//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitBitmapHeapScan * *		Initializes the scan's state information. * ---------------------------------------------------------------- */BitmapHeapScanState *ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags){	BitmapHeapScanState *scanstate;	Relation	currentRelation;	int			io_concurrency;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * Assert caller didn't ask for an unsafe snapshot --- see comments at	 * head of file.	 */	Assert(IsMVCCSnapshot(estate->es_snapshot));	/*	 * create state structure	 */	scanstate = makeNode(BitmapHeapScanState);	scanstate->ss.ps.plan = (Plan *) node;	scanstate->ss.ps.state = estate;	scanstate->tbm = NULL;	scanstate->tbmiterator = NULL;	scanstate->tbmres = NULL;	scanstate->exact_pages = 0;	scanstate->lossy_pages = 0;	scanstate->prefetch_iterator = NULL;	scanstate->prefetch_pages = 0;	scanstate->prefetch_target = 0;	/* may be updated below */	scanstate->prefetch_maximum = target_prefetch_pages;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ss.ps);	scanstate->ss.ps.ps_TupFromTlist = false;	/*	 * initialize child expressions	 */	scanstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) scanstate);	scanstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) scanstate);	scanstate->bitmapqualorig = (List *)		ExecInitExpr((Expr *) node->bitmapqualorig,					 (PlanState *) scanstate);	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &scanstate->ss.ps);	ExecInitScanTupleSlot(estate, &scanstate->ss);	/*	 * open the base relation and acquire appropriate lock on it.	 */	currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);	/*	 * Determine the maximum for prefetch_target.  If the tablespace has a	 * specific IO concurrency set, use that to compute the corresponding	 * maximum value; otherwise, we already initialized to the value computed	 * by the GUC machinery.	 */	io_concurrency =		get_tablespace_io_concurrency(currentRelation->rd_rel->reltablespace);	if (io_concurrency != effective_io_concurrency)	{		double		maximum;		if (ComputeIoConcurrency(io_concurrency, &maximum))			scanstate->prefetch_maximum = rint(maximum);	}	scanstate->ss.ss_currentRelation = currentRelation;	/*	 * Even though we aren't going to do a conventional seqscan, it is useful	 * to create a HeapScanDesc --- most of the fields in it are usable.	 */	scanstate->ss.ss_currentScanDesc = heap_beginscan_bm(currentRelation,														 estate->es_snapshot,														 0,														 NULL);//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitSeqScan * ---------------------------------------------------------------- */SeqScanState *ExecInitSeqScan(SeqScan *node, EState *estate, int eflags){	SeqScanState *scanstate;	/*	 * Once upon a time it was possible to have an outerPlan of a SeqScan, but	 * not any more.	 */	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create state structure	 */	scanstate = makeNode(SeqScanState);	scanstate->ps.plan = (Plan *) node;	scanstate->ps.state = estate;	scanstate->ss->scan_state = SCAN_INIT;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ps);	/*	 * initialize child expressions	 */	scanstate->ps.targetlist = (List *)		ExecInitExpr((Expr *) node->plan.targetlist,					 (PlanState *) scanstate);	scanstate->ps.qual = (List *)		ExecInitExpr((Expr *) node->plan.qual,					 (PlanState *) scanstate);#define SEQSCAN_NSLOTS 2	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &scanstate->ps);	ExecInitScanTupleSlot(estate, scanstate);	/*	 * initialize scan relation	 */	InitScanRelation(scanstate, estate);	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&scanstate->ps);	ExecAssignScanProjectionInfo(scanstate);	initGpmonPktForSeqScan((Plan *)node, &scanstate->ps.gpmon_pkt, estate);	/*	 * If eflag contains EXEC_FLAG_REWIND or EXEC_FLAG_BACKWARD or EXEC_FLAG_MARK,	 * then this node is not eager free safe.	 */	scanstate->ps.delayEagerFree =		((eflags & (EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)) != 0);	return scanstate;}

/* ----------------------------------------------------------------*		ExecInitExternalScan* ----------------------------------------------------------------*/ExternalScanState *ExecInitExternalScan(ExternalScan *node, EState *estate, int eflags){	ResultRelSegFileInfo *segfileinfo = NULL;	ExternalScanState *externalstate;	Relation	currentRelation;	FileScanDesc currentScanDesc;	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create state structure	 */	externalstate = makeNode(ExternalScanState);	externalstate->ss.ps.plan = (Plan *) node;	externalstate->ss.ps.state = estate;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &externalstate->ss.ps);	/*	 * initialize child expressions	 */	externalstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) externalstate);	externalstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) externalstate);	/* Check if targetlist or qual contains a var node referencing the ctid column */	externalstate->cdb_want_ctid = contain_ctid_var_reference(&node->scan);	ItemPointerSetInvalid(&externalstate->cdb_fake_ctid);#define EXTSCAN_NSLOTS 2	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &externalstate->ss.ps);	ExecInitScanTupleSlot(estate, &externalstate->ss);	/*	 * get the relation object id from the relid'th entry in the range table	 * and open that relation.	 */	currentRelation = ExecOpenScanExternalRelation(estate, node->scan.scanrelid);	if (Gp_role == GP_ROLE_EXECUTE && node->err_aosegfileinfos)	{		segfileinfo = (ResultRelSegFileInfo *)list_nth(node->err_aosegfileinfos, GetQEIndex());	}	else	{		segfileinfo = NULL;	}	currentScanDesc = external_beginscan(currentRelation,									 node->scan.scanrelid,									 node->scancounter,									 node->uriList,									 node->fmtOpts,									 node->fmtType,									 node->isMasterOnly,									 node->rejLimit,									 node->rejLimitInRows,									 node->fmterrtbl,									 segfileinfo,									 node->encoding,									 node->scan.plan.qual);	externalstate->ss.ss_currentRelation = currentRelation;	externalstate->ess_ScanDesc = currentScanDesc;	ExecAssignScanType(&externalstate->ss, RelationGetDescr(currentRelation));	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&externalstate->ss.ps);	ExecAssignScanProjectionInfo(&externalstate->ss);	/*	 * If eflag contains EXEC_FLAG_REWIND or EXEC_FLAG_BACKWARD or EXEC_FLAG_MARK,	 * then this node is not eager free safe.	 */	externalstate->ss.ps.delayEagerFree =		((eflags & (EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)) != 0);	initGpmonPktForExternalScan((Plan *)node, &externalstate->ss.ps.gpmon_pkt, estate);	return externalstate;//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitForeignScan * ---------------------------------------------------------------- */ForeignScanState *ExecInitForeignScan(ForeignScan *node, EState *estate, int eflags){	ForeignScanState *scanstate;	Relation	currentRelation;	FdwRoutine *fdwroutine;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * create state structure	 */	scanstate = makeNode(ForeignScanState);	scanstate->ss.ps.plan = (Plan *) node;	scanstate->ss.ps.state = estate;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ss.ps);	scanstate->ss.ps.ps_TupFromTlist = false;	/*	 * initialize child expressions	 */	scanstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) scanstate);	scanstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) scanstate);	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &scanstate->ss.ps);	ExecInitScanTupleSlot(estate, &scanstate->ss);	/*	 * open the base relation and acquire appropriate lock on it.	 */	currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid);	scanstate->ss.ss_currentRelation = currentRelation;	/*	 * get the scan type from the relation descriptor.	 */	ExecAssignScanType(&scanstate->ss, RelationGetDescr(currentRelation));	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&scanstate->ss.ps);	ExecAssignScanProjectionInfo(&scanstate->ss);	/*	 * Acquire function pointers from the FDW's handler, and init fdw_state.	 */	fdwroutine = GetFdwRoutineByRelId(RelationGetRelid(currentRelation));	scanstate->fdwroutine = fdwroutine;	scanstate->fdw_state = NULL;	/*	 * Tell the FDW to initiate the scan.	 */	fdwroutine->BeginForeignScan(scanstate, eflags);	return scanstate;}

/* ---------------------------------------------------------------- *		ExecInitMaterial * ---------------------------------------------------------------- */MaterialState *ExecInitMaterial(Material *node, EState *estate, int eflags){	MaterialState *matstate;	Plan	   *outerPlan;	/*	 * create state structure	 */	matstate = makeNode(MaterialState);	matstate->ss.ps.plan = (Plan *) node;	matstate->ss.ps.state = estate;	/*	 * We must have a tuplestore buffering the subplan output to do backward	 * scan or mark/restore.  We also prefer to materialize the subplan output	 * if we might be called on to rewind and replay it many times. However,	 * if none of these cases apply, we can skip storing the data.	 */	matstate->eflags = (eflags & (EXEC_FLAG_REWIND |								  EXEC_FLAG_BACKWARD |								  EXEC_FLAG_MARK));	/*	 * Tuplestore's interpretation of the flag bits is subtly different from	 * the general executor meaning: it doesn't think BACKWARD necessarily	 * means "backwards all the way to start".  If told to support BACKWARD we	 * must include REWIND in the tuplestore eflags, else tuplestore_trim	 * might throw away too much.	 */	if (eflags & EXEC_FLAG_BACKWARD)		matstate->eflags |= EXEC_FLAG_REWIND;	matstate->eof_underlying = false;	matstate->tuplestorestate = NULL;	/*	 * Miscellaneous initialization	 *	 * Materialization nodes don't need ExprContexts because they never call	 * ExecQual or ExecProject.	 */	/*	 * tuple table initialization	 *	 * material nodes only return tuples from their materialized relation.	 */	ExecInitResultTupleSlot(estate, &matstate->ss.ps);	ExecInitScanTupleSlot(estate, &matstate->ss);	/*	 * initialize child nodes	 *	 * We shield the child node from the need to support REWIND, BACKWARD, or	 * MARK/RESTORE.	 */	eflags &= ~(EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK);	outerPlan = outerPlan(node);	outerPlanState(matstate) = ExecInitNode(outerPlan, estate, eflags);	/*	 * initialize tuple type.  no need to initialize projection info because	 * this node doesn't do projections.	 */	ExecAssignResultTypeFromTL(&matstate->ss.ps);	ExecAssignScanTypeFromOuterPlan(&matstate->ss);	matstate->ss.ps.ps_ProjInfo = NULL;	return matstate;}

/* ---------------------------------------------------------------- *		ExecInitSort * *		Creates the run-time state information for the sort node *		produced by the planner and initializes its outer subtree. * ---------------------------------------------------------------- */SortState *ExecInitSort(Sort *node, EState *estate, int eflags){	SortState  *sortstate;	SO1_printf("ExecInitSort: %s/n",			   "initializing sort node");	/*	 * create state structure	 */	sortstate = makeNode(SortState);	sortstate->ss.ps.plan = (Plan *) node;	sortstate->ss.ps.state = estate;	/*	 * We must have random access to the sort output to do backward scan or	 * mark/restore.  We also prefer to materialize the sort output if we	 * might be called on to rewind and replay it many times.	 */	sortstate->randomAccess = (eflags & (EXEC_FLAG_REWIND |										 EXEC_FLAG_BACKWARD |										 EXEC_FLAG_MARK)) != 0;	sortstate->bounded = false;	sortstate->sort_Done = false;	sortstate->tuplesortstate = NULL;	/*	 * Miscellaneous initialization	 *	 * Sort nodes don't initialize their ExprContexts because they never call	 * ExecQual or ExecProject.	 */	/*	 * tuple table initialization	 *	 * sort nodes only return scan tuples from their sorted relation.	 */	ExecInitResultTupleSlot(estate, &sortstate->ss.ps);	ExecInitScanTupleSlot(estate, &sortstate->ss);	/*	 * initialize child nodes	 *	 * We shield the child node from the need to support REWIND, BACKWARD, or	 * MARK/RESTORE.	 */	eflags &= ~(EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK);	outerPlanState(sortstate) = ExecInitNode(outerPlan(node), estate, eflags);	/*	 * initialize tuple type.  no need to initialize projection info because	 * this node doesn't do projections.	 */	ExecAssignResultTypeFromTL(&sortstate->ss.ps);	ExecAssignScanTypeFromOuterPlan(&sortstate->ss);	sortstate->ss.ps.ps_ProjInfo = NULL;	SO1_printf("ExecInitSort: %s/n",			   "sort node initialized");	return sortstate;}

/* ---------------------------------------------------------------- *		ExecInitFunctionScan * ---------------------------------------------------------------- */FunctionScanState *ExecInitFunctionScan(FunctionScan *node, EState *estate, int eflags){	FunctionScanState *scanstate;	RangeTblEntry *rte;	Oid			funcrettype;	TypeFuncClass functypclass;	TupleDesc	tupdesc = NULL;	/*	 * FunctionScan should not have any children.	 */	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create new ScanState for node	 */	scanstate = makeNode(FunctionScanState);	scanstate->ss.ps.plan = (Plan *) node;	scanstate->ss.ps.state = estate;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &scanstate->ss.ps);#define FUNCTIONSCAN_NSLOTS 2	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &scanstate->ss.ps);	ExecInitScanTupleSlot(estate, &scanstate->ss);	/*	 * initialize child expressions	 */	scanstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) scanstate);	scanstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) scanstate);	/* Check if targetlist or qual contains a var node referencing the ctid column */	scanstate->cdb_want_ctid = contain_ctid_var_reference(&node->scan);    ItemPointerSet(&scanstate->cdb_fake_ctid, 0, 0);    ItemPointerSet(&scanstate->cdb_mark_ctid, 0, 0);	/*	 * get info about function	 */	rte = rt_fetch(node->scan.scanrelid, estate->es_range_table);	Assert(rte->rtekind == RTE_FUNCTION);	/*	 * Now determine if the function returns a simple or composite type, and	 * build an appropriate tupdesc.	 */	functypclass = get_expr_result_type(rte->funcexpr,										&funcrettype,										&tupdesc);	if (functypclass == TYPEFUNC_COMPOSITE)	{		/* Composite data type, e.g. a table's row type */		Assert(tupdesc);		/* Must copy it out of typcache for safety */		tupdesc = CreateTupleDescCopy(tupdesc);	}	else if (functypclass == TYPEFUNC_SCALAR)	{		/* Base data type, i.e. scalar */		char	   *attname = strVal(linitial(rte->eref->colnames));		tupdesc = CreateTemplateTupleDesc(1, false);		TupleDescInitEntry(tupdesc,						   (AttrNumber) 1,						   attname,						   funcrettype,						   -1,						   0);	}	else if (functypclass == TYPEFUNC_RECORD)	{		tupdesc = BuildDescFromLists(rte->eref->colnames,									 rte->funccoltypes,									 rte->funccoltypmods);	}	else	{		/* crummy error message, but parser should have caught this *///.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitSubqueryScan * ---------------------------------------------------------------- */SubqueryScanState *ExecInitSubqueryScan(SubqueryScan *node, EState *estate){	SubqueryScanState *subquerystate;	RangeTblEntry *rte;	EState	   *sp_estate;	MemoryContext oldcontext;	/*	 * SubqueryScan should not have any "normal" children.	 */	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create state structure	 */	subquerystate = makeNode(SubqueryScanState);	subquerystate->ss.ps.plan = (Plan *) node;	subquerystate->ss.ps.state = estate;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &subquerystate->ss.ps);	/*	 * initialize child expressions	 */	subquerystate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) subquerystate);	subquerystate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) subquerystate);#define SUBQUERYSCAN_NSLOTS 2	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &subquerystate->ss.ps);	ExecInitScanTupleSlot(estate, &subquerystate->ss);	/*	 * initialize subquery	 *	 * This should agree with ExecInitSubPlan	 */	rte = rt_fetch(node->scan.scanrelid, estate->es_range_table);	Assert(rte->rtekind == RTE_SUBQUERY);	/*	 * Do access checking on the rangetable entries in the subquery.	 */	ExecCheckRTPerms(rte->subquery->rtable);	/*	 * The subquery needs its own EState because it has its own rangetable. It	 * shares our Param ID space, however.	XXX if rangetable access were done	 * differently, the subquery could share our EState, which would eliminate	 * some thrashing about in this module...	 */	sp_estate = CreateExecutorState();	subquerystate->sss_SubEState = sp_estate;	oldcontext = MemoryContextSwitchTo(sp_estate->es_query_cxt);	sp_estate->es_range_table = rte->subquery->rtable;	sp_estate->es_param_list_info = estate->es_param_list_info;	sp_estate->es_param_exec_vals = estate->es_param_exec_vals;	sp_estate->es_tupleTable =		ExecCreateTupleTable(ExecCountSlotsNode(node->subplan) + 10);	sp_estate->es_snapshot = estate->es_snapshot;	sp_estate->es_crosscheck_snapshot = estate->es_crosscheck_snapshot;	sp_estate->es_instrument = estate->es_instrument;	/*	 * Start up the subplan (this is a very cut-down form of InitPlan())	 */	subquerystate->subplan = ExecInitNode(node->subplan, sp_estate);	MemoryContextSwitchTo(oldcontext);	subquerystate->ss.ps.ps_TupFromTlist = false;	/*	 * Initialize scan tuple type (needed by ExecAssignScanProjectionInfo)	 */	ExecAssignScanType(&subquerystate->ss,					   ExecGetResultType(subquerystate->subplan),					   false);	/*//.........这里部分代码省略.........

/* ----------------- * ExecInitGroup * *	Creates the run-time information for the group node produced by the *	planner and initializes its outer subtree * ----------------- */GroupState *ExecInitGroup(Group *node, EState *estate){	GroupState *grpstate;	/*	 * create state structure	 */	grpstate = makeNode(GroupState);	grpstate->ss.ps.plan = (Plan *) node;	grpstate->ss.ps.state = estate;	grpstate->grp_done = FALSE;	/*	 * create expression context	 */	ExecAssignExprContext(estate, &grpstate->ss.ps);#define GROUP_NSLOTS 2	/*	 * tuple table initialization	 */	ExecInitScanTupleSlot(estate, &grpstate->ss);	ExecInitResultTupleSlot(estate, &grpstate->ss.ps);	/*	 * initialize child expressions	 */	grpstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->plan.targetlist,					 (PlanState *) grpstate);	grpstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->plan.qual,					 (PlanState *) grpstate);	/*	 * initialize child nodes	 */	outerPlanState(grpstate) = ExecInitNode(outerPlan(node), estate);	/*	 * initialize tuple type.	 */	ExecAssignScanTypeFromOuterPlan(&grpstate->ss);	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&grpstate->ss.ps);	ExecAssignProjectionInfo(&grpstate->ss.ps, NULL);	/*	 * Precompute fmgr lookup data for inner loop	 */	grpstate->eqfunctions =		execTuplesMatchPrepare(ExecGetScanType(&grpstate->ss),							   node->numCols,							   node->grpColIdx);	return grpstate;}

/* ---------------------------------------------------------------- *		ExecInitIndexScan * *		Initializes the index scan's state information, creates *		scan keys, and opens the base and index relations. * *		Note: index scans have 2 sets of state information because *			  we have to keep track of the base relation and the *			  index relation. * ---------------------------------------------------------------- */IndexScanState *ExecInitIndexScan(IndexScan *node, EState *estate, int eflags){	IndexScanState *indexstate;	Relation	currentRelation;	bool		relistarget;	/*	 * create state structure	 */	indexstate = makeNode(IndexScanState);	indexstate->ss.ps.plan = (Plan *) node;	indexstate->ss.ps.state = estate;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &indexstate->ss.ps);	indexstate->ss.ps.ps_TupFromTlist = false;	/*	 * initialize child expressions	 *	 * Note: we don't initialize all of the indexqual expression, only the	 * sub-parts corresponding to runtime keys (see below).  Likewise for	 * indexorderby, if any.  But the indexqualorig expression is always	 * initialized even though it will only be used in some uncommon cases ---	 * would be nice to improve that.  (Problem is that any SubPlans present	 * in the expression must be found now...)	 */	indexstate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) indexstate);	indexstate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) indexstate);	indexstate->indexqualorig = (List *)		ExecInitExpr((Expr *) node->indexqualorig,					 (PlanState *) indexstate);	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &indexstate->ss.ps);	ExecInitScanTupleSlot(estate, &indexstate->ss);	/*	 * open the base relation and acquire appropriate lock on it.	 */	currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid);	indexstate->ss.ss_currentRelation = currentRelation;	indexstate->ss.ss_currentScanDesc = NULL;	/* no heap scan here */	/*	 * get the scan type from the relation descriptor.	 */	ExecAssignScanType(&indexstate->ss, RelationGetDescr(currentRelation));	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&indexstate->ss.ps);	ExecAssignScanProjectionInfo(&indexstate->ss);	/*	 * If we are just doing EXPLAIN (ie, aren't going to run the plan), stop	 * here.  This allows an index-advisor plugin to EXPLAIN a plan containing	 * references to nonexistent indexes.	 */	if (eflags & EXEC_FLAG_EXPLAIN_ONLY)		return indexstate;	/*	 * Open the index relation.	 *	 * If the parent table is one of the target relations of the query, then	 * InitPlan already opened and write-locked the index, so we can avoid	 * taking another lock here.  Otherwise we need a normal reader's lock.	 */	relistarget = ExecRelationIsTargetRelation(estate, node->scan.scanrelid);	indexstate->iss_RelationDesc = index_open(node->indexid,									 relistarget ? NoLock : AccessShareLock);	/*	 * Initialize index-specific scan state//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitSubqueryScan * ---------------------------------------------------------------- */SubqueryScanState *ExecInitSubqueryScan(SubqueryScan *node, EState *estate, int eflags){	SubqueryScanState *subquerystate;	/* check for unsupported flags */	Assert(!(eflags & EXEC_FLAG_MARK));	/* SubqueryScan should not have any "normal" children */	Assert(outerPlan(node) == NULL);	Assert(innerPlan(node) == NULL);	/*	 * create state structure	 */	subquerystate = makeNode(SubqueryScanState);	subquerystate->ss.ps.plan = (Plan *) node;	subquerystate->ss.ps.state = estate;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &subquerystate->ss.ps);	/*	 * initialize child expressions	 */	subquerystate->ss.ps.targetlist = (List *)		ExecInitExpr((Expr *) node->scan.plan.targetlist,					 (PlanState *) subquerystate);	subquerystate->ss.ps.qual = (List *)		ExecInitExpr((Expr *) node->scan.plan.qual,					 (PlanState *) subquerystate);	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &subquerystate->ss.ps);	ExecInitScanTupleSlot(estate, &subquerystate->ss);	/*	 * initialize subquery	 */	subquerystate->subplan = ExecInitNode(node->subplan, estate, eflags);	subquerystate->ss.ps.ps_TupFromTlist = false;	/*	 * Initialize scan tuple type (needed by ExecAssignScanProjectionInfo)	 */	ExecAssignScanType(&subquerystate->ss,					   ExecGetResultType(subquerystate->subplan));	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&subquerystate->ss.ps);	ExecAssignScanProjectionInfo(&subquerystate->ss);	return subquerystate;}