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

/* * Initializes the BitmapTableScanState, including creation of the * scan description and the bitmapqualorig. */BitmapTableScanState *ExecInitBitmapTableScan(BitmapTableScan *node, EState *estate, int eflags){	/* 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.	 *	 * MPP-4703: the MVCC-snapshot restriction is required for correct results.	 * our test-mode may deliberately return incorrect results, but that's OK.	 */	Assert(IsMVCCSnapshot(estate->es_snapshot) || gp_select_invisible);	BitmapTableScanState *state = makeNode(BitmapTableScanState);	BitmapTableScanBegin(state, (Plan *) node, estate, eflags);	/*	 * 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(state) = ExecInitNode(outerPlan(node), estate, eflags);	initGpmonPktForBitmapTableScan((Plan *)node, &state->ss.ps.gpmon_pkt, estate);	return state;}

/* ---------------------------------------------------------------- *		ExecInitUnique * *		This initializes the unique node state structures and *		the node's subplan. * ---------------------------------------------------------------- */UniqueState *ExecInitUnique(Unique *node, EState *estate, int eflags){	UniqueState *uniquestate;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * create state structure	 */	uniquestate = makeNode(UniqueState);	uniquestate->ps.plan = (Plan *) node;	uniquestate->ps.state = estate;	/*	 * Miscellaneous initialization	 *	 * Unique nodes have no ExprContext initialization because they never call	 * ExecQual or ExecProject.  But they do need a per-tuple memory context	 * anyway for calling execTuplesMatch.	 */	uniquestate->tempContext =		AllocSetContextCreate(CurrentMemoryContext,							  "Unique",							  ALLOCSET_DEFAULT_MINSIZE,							  ALLOCSET_DEFAULT_INITSIZE,							  ALLOCSET_DEFAULT_MAXSIZE);#define UNIQUE_NSLOTS 1	/*	 * Tuple table initialization	 */	ExecInitResultTupleSlot(estate, &uniquestate->ps);	/*	 * then initialize outer plan	 */	outerPlanState(uniquestate) = ExecInitNode(outerPlan(node), estate, eflags);	/*	 * unique nodes do no projections, so initialize projection info for this	 * node appropriately	 */	ExecAssignResultTypeFromTL(&uniquestate->ps);	uniquestate->ps.ps_ProjInfo = NULL;	/*	 * Precompute fmgr lookup data for inner loop	 */	uniquestate->eqfunctions =		execTuplesMatchPrepare(ExecGetResultType(&uniquestate->ps),							   node->numCols,							   node->uniqColIdx);	initGpmonPktForUnique((Plan *)node, &uniquestate->ps.gpmon_pkt, estate);		return uniquestate;}

/* ---------------------------------------------------------------- *		ExecInitResult * *		Creates the run-time state information for the result node *		produced by the planner and initailizes outer relations *		(child nodes). * ---------------------------------------------------------------- */ResultState *ExecInitResult(Result *node, EState *estate){	ResultState *resstate;	/*	 * create state structure	 */	resstate = makeNode(ResultState);	resstate->ps.plan = (Plan *) node;	resstate->ps.state = estate;	resstate->rs_done = false;	resstate->rs_checkqual = (node->resconstantqual == NULL) ? false : true;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &resstate->ps);#define RESULT_NSLOTS 1	/*	 * tuple table initialization	 */	ExecInitResultTupleSlot(estate, &resstate->ps);	/*	 * initialize child expressions	 */	resstate->ps.targetlist = (List *)		ExecInitExpr((Expr *) node->plan.targetlist,					 (PlanState *) resstate);	resstate->ps.qual = (List *)		ExecInitExpr((Expr *) node->plan.qual,					 (PlanState *) resstate);	resstate->resconstantqual = ExecInitExpr((Expr *) node->resconstantqual,											 (PlanState *) resstate);	/*	 * initialize child nodes	 */	outerPlanState(resstate) = ExecInitNode(outerPlan(node), estate);	/*	 * we don't use inner plan	 */	Assert(innerPlan(node) == NULL);	/*	 * initialize tuple type and projection info	 */	ExecAssignResultTypeFromTL(&resstate->ps);	ExecAssignProjectionInfo(&resstate->ps);	return resstate;}

/* ----------------- * 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;}

/* ---------------------------------------------------------------- *		ExecInitLimit * *		This initializes the limit node state structures and *		the node's subplan. * ---------------------------------------------------------------- */LimitState *ExecInitLimit(Limit *node, EState *estate, int eflags){	LimitState *limitstate;	Plan	   *outerPlan;	/* check for unsupported flags */	Assert(!(eflags & EXEC_FLAG_MARK));	/*	 * create state structure	 */	limitstate = makeNode(LimitState);	limitstate->ps.plan = (Plan *) node;	limitstate->ps.state = estate;	limitstate->lstate = LIMIT_INITIAL;	/*	 * Miscellaneous initialization	 *	 * Limit nodes never call ExecQual or ExecProject, but they need an	 * exprcontext anyway to evaluate the limit/offset parameters in.	 */	ExecAssignExprContext(estate, &limitstate->ps);	/*	 * initialize child expressions	 */	limitstate->limitOffset = ExecInitExpr((Expr *) node->limitOffset,										   (PlanState *) limitstate);	limitstate->limitCount = ExecInitExpr((Expr *) node->limitCount,										  (PlanState *) limitstate);#define LIMIT_NSLOTS 1	/*	 * Tuple table initialization (XXX not actually used...)	 */	ExecInitResultTupleSlot(estate, &limitstate->ps);	/*	 * then initialize outer plan	 */	outerPlan = outerPlan(node);	outerPlanState(limitstate) = ExecInitNode(outerPlan, estate, eflags);	/*	 * limit nodes do no projections, so initialize projection info for this	 * node appropriately	 */	ExecAssignResultTypeFromTL(&limitstate->ps);	limitstate->ps.ps_ProjInfo = NULL;	initGpmonPktForLimit((Plan *)node, &limitstate->ps.gpmon_pkt, estate);		return limitstate;}

/** * Init nodeDML, which initializes the insert TupleTableSlot. * */DMLState*ExecInitDML(DML *node, EState *estate, int eflags){		/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK | EXEC_FLAG_REWIND)));		DMLState *dmlstate = makeNode(DMLState);	dmlstate->ps.plan = (Plan *)node;	dmlstate->ps.state = estate;	ExecInitResultTupleSlot(estate, &dmlstate->ps);	dmlstate->ps.targetlist = (List *)						ExecInitExpr((Expr *) node->plan.targetlist,						(PlanState *) dmlstate);	Plan *outerPlan  = outerPlan(node);	outerPlanState(dmlstate) = ExecInitNode(outerPlan, estate, eflags);	ExecAssignResultTypeFromTL(&dmlstate->ps);	/* Create expression evaluation context. This will be used for projections */	ExecAssignExprContext(estate, &dmlstate->ps);	/*	 * Create projection info from the child tuple descriptor and our target list	 * Projection will be placed in the ResultSlot	 */	TupleTableSlot *childResultSlot = outerPlanState(dmlstate)->ps_ResultTupleSlot;	ExecAssignProjectionInfo(&dmlstate->ps, childResultSlot->tts_tupleDescriptor);		/*	 * Initialize slot to insert/delete using output relation descriptor.	 */	dmlstate->cleanedUpSlot = ExecInitExtraTupleSlot(estate);	/*	 * Both input and output of the junk filter include dropped attributes, so	 * the junk filter doesn't need to do anything special there about them	 */	TupleDesc cleanTupType = CreateTupleDescCopy(dmlstate->ps.state->es_result_relation_info->ri_RelationDesc->rd_att); 	dmlstate->junkfilter = ExecInitJunkFilter(node->plan.targetlist,			cleanTupType,			dmlstate->cleanedUpSlot);	if (estate->es_instrument)	{	        dmlstate->ps.cdbexplainbuf = makeStringInfo();	        /* Request a callback at end of query. */	        dmlstate->ps.cdbexplainfun = ExecDMLExplainEnd;	}	initGpmonPktForDML((Plan *)node, &dmlstate->ps.gpmon_pkt, estate);		return dmlstate;}

/* ---------------------------------------------------------------- *		ExecInitHash * *		Init routine for Hash node * ---------------------------------------------------------------- */HashState *ExecInitHash(Hash *node, EState *estate, int eflags){	HashState  *hashstate;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * create state structure	 */	hashstate = makeNode(HashState);	hashstate->ps.plan = (Plan *) node;	hashstate->ps.state = estate;	hashstate->hashtable = NULL;	hashstate->hashkeys = NIL;	/* will be set by parent HashJoin */	/*CHANGED BY YASIN*/	if (eflags & EXEC_FLAG_INAROUND) hashstate->ps.ps_InAround = true;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &hashstate->ps);#define HASH_NSLOTS 1	/*	 * initialize our result slot	 */	ExecInitResultTupleSlot(estate, &hashstate->ps);	/*	 * initialize child expressions	 */	hashstate->ps.targetlist = (List *)		ExecInitExpr((Expr *) node->plan.targetlist,					 (PlanState *) hashstate);	hashstate->ps.qual = (List *)		ExecInitExpr((Expr *) node->plan.qual,					 (PlanState *) hashstate);	/*	 * initialize child nodes	 */	outerPlanState(hashstate) = ExecInitNode(outerPlan(node), estate, eflags);	/*	 * initialize tuple type. no need to initialize projection info because	 * this node doesn't do projections	 */	ExecAssignResultTypeFromTL(&hashstate->ps);	hashstate->ps.ps_ProjInfo = NULL;	return hashstate;}

/* ---------------------------------------------------------------- *   	ExecInitHash * *   	Init routine for Hash node * ---------------------------------------------------------------- */boolExecInitHash(Hash *node, EState *estate, Plan *parent){    HashState		*hashstate;    Plan		*outerPlan;        SO1_printf("ExecInitHash: %s/n",	       "initializing hash node");        /* ----------------     *  assign the node's execution state     * ----------------     */    node->plan.state = estate;        /* ----------------     * create state structure     * ----------------     */    hashstate = makeNode(HashState);    node->hashstate = hashstate;    hashstate->hashBatches = NULL;        /* ----------------     *  Miscellanious initialization     *     *	     +	assign node's base_id     *       +	assign debugging hooks and     *       +	create expression context for node     * ----------------     */    ExecAssignNodeBaseInfo(estate, &hashstate->cstate, parent);    ExecAssignExprContext(estate, &hashstate->cstate);    #define HASH_NSLOTS 1    /* ----------------     * initialize our result slot     * ----------------     */    ExecInitResultTupleSlot(estate, &hashstate->cstate);        /* ----------------     * initializes child nodes     * ----------------     */    outerPlan = outerPlan(node);    ExecInitNode(outerPlan, estate, (Plan *)node);        /* ----------------     * 	initialize tuple type. no need to initialize projection     *  info because this node doesn't do projections     * ----------------     */    ExecAssignResultTypeFromOuterPlan((Plan *) node, &hashstate->cstate);    hashstate->cstate.cs_ProjInfo = NULL;        return TRUE;}

/* ---------------------------------------------------------------- *		ExecInitHash * *		Init routine for Hash node * ---------------------------------------------------------------- */HashState *ExecInitHash(Hash *node, EState *estate){	HashState  *hashstate;	SO_printf("ExecInitHash: initializing hash node/n");	/*	 * create state structure	 */	hashstate = makeNode(HashState);	hashstate->ps.plan = (Plan *) node;	hashstate->ps.state = estate;	hashstate->hashtable = NULL;	hashstate->hashkeys = NIL;	/* will be set by parent HashJoin */	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &hashstate->ps);#define HASH_NSLOTS 1	/*	 * initialize our result slot	 */	ExecInitResultTupleSlot(estate, &hashstate->ps);	/*	 * initialize child expressions	 */	hashstate->ps.targetlist = (List *)		ExecInitExpr((Expr *) node->plan.targetlist,					 (PlanState *) hashstate);	hashstate->ps.qual = (List *)		ExecInitExpr((Expr *) node->plan.qual,					 (PlanState *) hashstate);	/*	 * initialize child nodes	 */	outerPlanState(hashstate) = ExecInitNode(outerPlan(node), estate);	/*	 * initialize tuple type. no need to initialize projection info	 * because this node doesn't do projections	 */	ExecAssignResultTypeFromOuterPlan(&hashstate->ps);	hashstate->ps.ps_ProjInfo = NULL;	return hashstate;}

/* ---------------------------------------------------------------- *		ExecInitLimit * *		This initializes the limit node state structures and *		the node's subplan. * ---------------------------------------------------------------- */LimitState *ExecInitLimit(Limit *node, EState *estate){	LimitState *limitstate;	Plan	   *outerPlan;	/*	 * create state structure	 */	limitstate = makeNode(LimitState);	limitstate->ps.plan = (Plan *) node;	limitstate->ps.state = estate;	limitstate->lstate = LIMIT_INITIAL;	/*	 * Miscellaneous initialization	 *	 * Limit nodes never call ExecQual or ExecProject, but they need an	 * exprcontext anyway to evaluate the limit/offset parameters in.	 */	ExecAssignExprContext(estate, &limitstate->ps);	/*	 * initialize child expressions	 */	limitstate->limitOffset = ExecInitExpr((Expr *) node->limitOffset,										   (PlanState *) limitstate);	limitstate->limitCount = ExecInitExpr((Expr *) node->limitCount,										  (PlanState *) limitstate);#define LIMIT_NSLOTS 1	/*	 * Tuple table initialization	 */	ExecInitResultTupleSlot(estate, &limitstate->ps);	/*	 * then initialize outer plan	 */	outerPlan = outerPlan(node);	outerPlanState(limitstate) = ExecInitNode(outerPlan, estate);	/*	 * limit nodes do no projections, so initialize projection info for	 * this node appropriately	 */	ExecAssignResultTypeFromOuterPlan(&limitstate->ps);	limitstate->ps.ps_ProjInfo = NULL;	return limitstate;}

/* ---------------------------------------------------------------- *		ExecInitResult * *		Creates the run-time state information for the result node *		produced by the planner and initializes outer relations *		(child nodes). * ---------------------------------------------------------------- */ResultState *ExecInitResult(Result *node, EState *estate, int eflags){	ResultState *resstate;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_MARK | EXEC_FLAG_BACKWARD)) ||		   outerPlan(node) != NULL);	/*	 * create state structure	 */	resstate = makeNode(ResultState);	resstate->ps.plan = (Plan *) node;	resstate->ps.state = estate;	resstate->ps.ExecProcNode = ExecResult;	resstate->rs_done = false;	resstate->rs_checkqual = (node->resconstantqual == NULL) ? false : true;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &resstate->ps);	/*	 * initialize child nodes	 */	outerPlanState(resstate) = ExecInitNode(outerPlan(node), estate, eflags);	/*	 * we don't use inner plan	 */	Assert(innerPlan(node) == NULL);	/*	 * Initialize result slot, type and projection.	 */	ExecInitResultTupleSlotTL(&resstate->ps);	ExecAssignProjectionInfo(&resstate->ps, NULL);	/*	 * initialize child expressions	 */	resstate->ps.qual =		ExecInitQual(node->plan.qual, (PlanState *) resstate);	resstate->resconstantqual =		ExecInitQual((List *) node->resconstantqual, (PlanState *) resstate);	return resstate;}

/* ---------------------------------------------------------------- *		ExecInitHash * *		Init routine for Hash node * ---------------------------------------------------------------- */HashState *ExecInitHash(Hash *node, EState *estate, int eflags){	HashState  *hashstate;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * create state structure	 */	hashstate = makeNode(HashState);	hashstate->ps.plan = (Plan *) node;	hashstate->ps.state = estate;	hashstate->ps.ExecProcNode = ExecHash;	hashstate->hashtable = NULL;	hashstate->hashkeys = NIL;	/* will be set by parent HashJoin */	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &hashstate->ps);	/*	 * initialize our result slot	 */	ExecInitResultTupleSlot(estate, &hashstate->ps);	/*	 * initialize child expressions	 */	hashstate->ps.qual =		ExecInitQual(node->plan.qual, (PlanState *) hashstate);	/*	 * initialize child nodes	 */	outerPlanState(hashstate) = ExecInitNode(outerPlan(node), estate, eflags);	/*	 * initialize tuple type. no need to initialize projection info because	 * this node doesn't do projections	 */	ExecAssignResultTypeFromTL(&hashstate->ps);	hashstate->ps.ps_ProjInfo = NULL;	return hashstate;}

/* ---------------------------------------------------------------- *		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;}

RepeatState *ExecInitRepeat(Repeat *node, EState *estate, int eflags){	RepeatState *repeatstate;	/* Check for unsupported flag */	Assert(!(eflags & (EXEC_FLAG_MARK | EXEC_FLAG_BACKWARD)) ||		   outerPlan(node) != NULL);	/*	 * Create state structure.	 */	repeatstate = makeNode(RepeatState);	repeatstate->ps.plan = (Plan *)node;	repeatstate->ps.state = estate;	/* Create expression context for the node. */	ExecAssignExprContext(estate, &repeatstate->ps);		ExecInitResultTupleSlot(estate, &repeatstate->ps);		/* Initialize child expressions */	repeatstate->ps.targetlist = (List *)		ExecInitExpr((Expr *)node->plan.targetlist,					 (PlanState *)repeatstate);	repeatstate->ps.qual = (List *)		ExecInitExpr((Expr *)node->plan.qual,					 (PlanState *)repeatstate);	repeatstate->expr_state =		ExecInitExpr(node->repeatCountExpr,					 (PlanState *)repeatstate);	/* Initialize child nodes */	outerPlanState(repeatstate) = ExecInitNode(outerPlan(node), estate, eflags);	/* Inner plan is not used. */	Assert(innerPlan(node) == NULL);		/* Initialize tuple type and projection info */	ExecAssignResultTypeFromTL(&repeatstate->ps);	ExecAssignProjectionInfo(&repeatstate->ps, NULL);	init_RepeatState(repeatstate);		initGpmonPktForRepeat((Plan *)node, &repeatstate->ps.gpmon_pkt, estate);		return repeatstate;}

/* ---------------------------------------------------------------- *		ExecInitPartitionSelector * *		Create the run-time state information for PartitionSelector node *		produced by Orca and initializes outer child if exists. * * ---------------------------------------------------------------- */PartitionSelectorState *ExecInitPartitionSelector(PartitionSelector *node, EState *estate, int eflags){	/* check for unsupported flags */	Assert (!(eflags & (EXEC_FLAG_MARK | EXEC_FLAG_BACKWARD)));	PartitionSelectorState *psstate = initPartitionSelection(node, estate);	/* tuple table initialization */	ExecInitResultTupleSlot(estate, &psstate->ps);	ExecAssignResultTypeFromTL(&psstate->ps);	ExecAssignProjectionInfo(&psstate->ps, NULL);	/* initialize child nodes */	/* No inner plan for PartitionSelector */	Assert(NULL == innerPlan(node));	if (NULL != outerPlan(node))	{		outerPlanState(psstate) = ExecInitNode(outerPlan(node), estate, eflags);	}	/*	 * Initialize projection, to produce a tuple that has the partitioning key	 * columns at the same positions as in the partitioned table.	 */	if (node->partTabTargetlist)	{		List	   *exprStates;		exprStates = (List *) ExecInitExpr((Expr *) node->partTabTargetlist,										   (PlanState *) psstate);		psstate->partTabDesc = ExecTypeFromTL(node->partTabTargetlist, false);		psstate->partTabSlot = MakeSingleTupleTableSlot(psstate->partTabDesc);		psstate->partTabProj = ExecBuildProjectionInfo(exprStates,													   psstate->ps.ps_ExprContext,													   psstate->partTabSlot,													   ExecGetResultType(&psstate->ps));	}	initGpmonPktForPartitionSelector((Plan *)node, &psstate->ps.gpmon_pkt, estate);	return psstate;}

TwiceState *ExecInitTwice(Twice *node, EState *estate, int eflags){	TwiceState *twicestate;	/*	 * create state structure	 */	twicestate = makeNode(TwiceState);	twicestate->ps.plan = (Plan *) node;	twicestate->ps.state = estate;	/*	 * Tuple table initialization	 */	ExecInitResultTupleSlot(estate, &twicestate->ps);	/*	 * then initialize outer plan	 */	outerPlanState(twicestate) = ExecInitNode(outerPlan(node),											  estate,											  eflags);	/*	 * twice nodes do no projections, so initialize projection info for this	 * node appropriately, i.e. keep all attributes as they are.	 */	ExecAssignResultTypeFromTL(&twicestate->ps);	twicestate->ps.ps_ProjInfo = NULL;	/*	 * Set output counter for each tuple to zero, s.t. we know that it is the	 * first output overall.	 */	twicestate->isFirst = true;	return twicestate;}

/* ---------------------------------------------------------------- *		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;}

/* ---------------------------------------------------------------- *		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;}

/* ---------------------------------------------------------------- *		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);	/*//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitSetOp * *		This initializes the setop node state structures and *		the node's subplan. * ---------------------------------------------------------------- */SetOpState *ExecInitSetOp(SetOp *node, EState *estate, int eflags){	SetOpState *setopstate;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * create state structure	 */	setopstate = makeNode(SetOpState);	setopstate->ps.plan = (Plan *) node;	setopstate->ps.state = estate;	setopstate->ps.ps_OuterTupleSlot = NULL;	setopstate->subplan_done = false;	setopstate->numOutput = 0;	/*	 * Miscellaneous initialization	 *	 * SetOp nodes have no ExprContext initialization because they never call	 * ExecQual or ExecProject.  But they do need a per-tuple memory context	 * anyway for calling execTuplesMatch.	 */	setopstate->tempContext =		AllocSetContextCreate(CurrentMemoryContext,							  "SetOp",							  ALLOCSET_DEFAULT_MINSIZE,							  ALLOCSET_DEFAULT_INITSIZE,							  ALLOCSET_DEFAULT_MAXSIZE);#define SETOP_NSLOTS 1	/*	 * Tuple table initialization	 */	ExecInitResultTupleSlot(estate, &setopstate->ps);	/*	 * then initialize outer plan	 */	outerPlanState(setopstate) = ExecInitNode(outerPlan(node), estate, eflags);	/*	 * setop nodes do no projections, so initialize projection info for this	 * node appropriately	 */	ExecAssignResultTypeFromTL(&setopstate->ps);	setopstate->ps.ps_ProjInfo = NULL;	/*	 * Precompute fmgr lookup data for inner loop	 */	setopstate->eqfunctions =		execTuplesMatchPrepare(ExecGetResultType(&setopstate->ps),							   node->numCols,							   node->dupColIdx);	return setopstate;}

//.........这里部分代码省略.........	/* CDB */ /* evaluate a limit as part of the sort */	{		/* pass node state to sort state */		sortstate->limitOffset = ExecInitExpr((Expr *) node->limitOffset,											  (PlanState *) sortstate);		sortstate->limitCount = ExecInitExpr((Expr *) node->limitCount,											 (PlanState *) sortstate);		sortstate->noduplicates = node->noduplicates;	}	/*	 * Miscellaneous initialization	 *	 * Sort nodes don't initialize their ExprContexts because they never call	 * ExecQual or ExecProject.	 */#define SORT_NSLOTS 2	/*	 * tuple table initialization	 *	 * sort nodes only return scan tuples from their sorted relation.	 */	ExecInitResultTupleSlot(estate, &sortstate->ss.ps);	sortstate->ss.ss_ScanTupleSlot = ExecInitExtraTupleSlot(estate);	/* 	 * CDB: Offer extra info for EXPLAIN ANALYZE.	 */	if (estate->es_instrument)	{		/* Allocate string buffer. */		sortstate->ss.ps.cdbexplainbuf = makeStringInfo();		/* Request a callback at end of query. */		sortstate->ss.ps.cdbexplainfun = ExecSortExplainEnd;	}	/*	 * If eflag contains EXEC_FLAG_REWIND or EXEC_FLAG_BACKWARD or EXEC_FLAG_MARK,	 * then this node is not eager free safe.	 */	sortstate->ss.ps.delayEagerFree =		((eflags & (EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)) != 0);	/*	 * initialize child nodes	 *	 * We shield the child node from the need to support BACKWARD, or	 * MARK/RESTORE.	 */	eflags &= ~(EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK);	/*	 * If Sort does not have any external parameters, then it	 * can shield the child node from being rescanned as well, hence	 * we can clear the EXEC_FLAG_REWIND as well. If there are parameters,	 * don't clear the REWIND flag, as the child will be rewound.	 */	if (node->plan.allParam == NULL || node->plan.extParam == NULL)	{		eflags &= ~EXEC_FLAG_REWIND;	}	outerPlanState(sortstate) = ExecInitNode(outerPlan(node), estate, eflags);	/*	 * If the child node of a Material is a Motion, then this Material node is	 * not eager free safe.	 */	if (IsA(outerPlan((Plan *)node), Motion))	{		sortstate->ss.ps.delayEagerFree = true;	}	/*	 * 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;	if(node->share_type != SHARE_NOTSHARED)	{		ShareNodeEntry *snEntry = ExecGetShareNodeEntry(estate, node->share_id, true);		snEntry->sharePlan = (Node *)node;		snEntry->shareState = (Node *)sortstate;	}	SO1_printf("ExecInitSort: %s/n",			   "sort node initialized");	initGpmonPktForSort((Plan *)node, &sortstate->ss.ps.gpmon_pkt, estate);	return sortstate;}

//.........这里部分代码省略.........	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);	/*	 * 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);	/*	 * all done.	 */	return scanstate;}

/* ---------------------------------------------------------------- *		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);	/*//.........这里部分代码省略.........

/* ----------------- * 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;}

/* ---------------------------------------------------------------- *		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;}

/* ---------------------------------------------------------------- *		ExecInitAppend * *		Begin all of the subscans of the append node. * *	   (This is potentially wasteful, since the entire result of the *		append node may not be scanned, but this way all of the *		structures get allocated in the executor's top level memory *		block instead of that of the call to ExecProcAppend.) * *		Special case: during an EvalPlanQual recheck query of an inherited *		target relation, we only want to initialize and scan the single *		subplan that corresponds to the target relation being checked. * ---------------------------------------------------------------- */AppendState *ExecInitAppend(Append *node, EState *estate){	AppendState *appendstate = makeNode(AppendState);	PlanState **appendplanstates;	int			nplans;	int			i;	Plan	   *initNode;	CXT1_printf("ExecInitAppend: context is %d/n", CurrentMemoryContext);	/*	 * Set up empty vector of subplan states	 */	nplans = length(node->appendplans);	appendplanstates = (PlanState **) palloc0(nplans * sizeof(PlanState *));	/*	 * create new AppendState for our append node	 */	appendstate->ps.plan = (Plan *) node;	appendstate->ps.state = estate;	appendstate->appendplans = appendplanstates;	appendstate->as_nplans = nplans;	/*	 * Do we want to scan just one subplan?  (Special case for	 * EvalPlanQual) XXX pretty dirty way of determining that this case	 * applies ...	 */	if (node->isTarget && estate->es_evTuple != NULL)	{		int			tplan;		tplan = estate->es_result_relation_info - estate->es_result_relations;		Assert(tplan >= 0 && tplan < nplans);		appendstate->as_firstplan = tplan;		appendstate->as_lastplan = tplan;	}	else	{		/* normal case, scan all subplans */		appendstate->as_firstplan = 0;		appendstate->as_lastplan = nplans - 1;	}	/*	 * Miscellaneous initialization	 *	 * Append plans don't have expression contexts because they never call	 * ExecQual or ExecProject.	 */#define APPEND_NSLOTS 1	/*	 * append nodes still have Result slots, which hold pointers to	 * tuples, so we have to initialize them.	 */	ExecInitResultTupleSlot(estate, &appendstate->ps);	/*	 * call ExecInitNode on each of the plans to be executed and save the	 * results into the array "appendplans".  Note we *must* set	 * estate->es_result_relation_info correctly while we initialize each	 * sub-plan; ExecContextForcesOids depends on that!	 */	for (i = appendstate->as_firstplan; i <= appendstate->as_lastplan; i++)	{		appendstate->as_whichplan = i;		exec_append_initialize_next(appendstate);		initNode = (Plan *) nth(i, node->appendplans);		appendplanstates[i] = ExecInitNode(initNode, estate);	}	/*	 * initialize tuple type	 */	ExecAssignResultTypeFromTL(&appendstate->ps);	appendstate->ps.ps_ProjInfo = NULL;	/*//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitSetOp * *		This initializes the setop node state structures and *		the node's subplan. * ---------------------------------------------------------------- */SetOpState *ExecInitSetOp(SetOp *node, EState *estate, int eflags){	SetOpState *setopstate;	/* check for unsupported flags */	Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * create state structure	 */	setopstate = makeNode(SetOpState);	setopstate->ps.plan = (Plan *) node;	setopstate->ps.state = estate;	setopstate->eqfunctions = NULL;	setopstate->hashfunctions = NULL;	setopstate->setop_done = false;	setopstate->numOutput = 0;	setopstate->pergroup = NULL;	setopstate->grp_firstTuple = NULL;	setopstate->hashtable = NULL;	setopstate->tableContext = NULL;	/*	 * Miscellaneous initialization	 *	 * SetOp nodes have no ExprContext initialization because they never call	 * ExecQual or ExecProject.  But they do need a per-tuple memory context	 * anyway for calling execTuplesMatch.	 */	setopstate->tempContext =		AllocSetContextCreate(CurrentMemoryContext,							  "SetOp",							  ALLOCSET_DEFAULT_MINSIZE,							  ALLOCSET_DEFAULT_INITSIZE,							  ALLOCSET_DEFAULT_MAXSIZE);	/*	 * If hashing, we also need a longer-lived context to store the hash	 * table.  The table can't just be kept in the per-query context because	 * we want to be able to throw it away in ExecReScanSetOp.	 */	if (node->strategy == SETOP_HASHED)		setopstate->tableContext =			AllocSetContextCreate(CurrentMemoryContext,								  "SetOp hash table",								  ALLOCSET_DEFAULT_MINSIZE,								  ALLOCSET_DEFAULT_INITSIZE,								  ALLOCSET_DEFAULT_MAXSIZE);	/*	 * Tuple table initialization	 */	ExecInitResultTupleSlot(estate, &setopstate->ps);	/*	 * initialize child nodes	 *	 * If we are hashing then the child plan does not need to handle REWIND	 * efficiently; see ExecReScanSetOp.	 */	if (node->strategy == SETOP_HASHED)		eflags &= ~EXEC_FLAG_REWIND;	outerPlanState(setopstate) = ExecInitNode(outerPlan(node), estate, eflags);	/*	 * setop nodes do no projections, so initialize projection info for this	 * node appropriately	 */	ExecAssignResultTypeFromTL(&setopstate->ps);	setopstate->ps.ps_ProjInfo = NULL;	/*	 * Precompute fmgr lookup data for inner loop. We need both equality and	 * hashing functions to do it by hashing, but only equality if not	 * hashing.	 */	if (node->strategy == SETOP_HASHED)		execTuplesHashPrepare(node->numCols,							  node->dupOperators,							  &setopstate->eqfunctions,							  &setopstate->hashfunctions);	else		setopstate->eqfunctions =			execTuplesMatchPrepare(node->numCols,								   node->dupOperators);	if (node->strategy == SETOP_HASHED)	{		build_hash_table(setopstate);		setopstate->table_filled = false;	}//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *   	ExecInitNestLoop *    *   	Creates the run-time state information for the nestloop node *   	produced by the planner and initailizes inner and outer relations  *   	(child nodes). * ----------------------------------------------------------------  	 */boolExecInitNestLoop(NestLoop *node, EState *estate, Plan *parent){    NestLoopState   *nlstate;    NL1_printf("ExecInitNestLoop: %s/n",	       "initializing node");	    /* ----------------     *	assign execution state to node     * ----------------     */    node->join.state = estate;    /* ----------------     *    create new nest loop state     * ----------------     */    nlstate = makeNode(NestLoopState);    nlstate->nl_PortalFlag = false;    node->nlstate = nlstate;    /* ----------------     *  Miscellanious initialization     *     *	     +	assign node's base_id     *       +	assign debugging hooks and     *       +	create expression context for node     * ----------------     */    ExecAssignNodeBaseInfo(estate, &nlstate->jstate, parent);    ExecAssignExprContext(estate, &nlstate->jstate);#define NESTLOOP_NSLOTS 1    /* ----------------     *	tuple table initialization     * ----------------     */    ExecInitResultTupleSlot(estate, &nlstate->jstate);    /* ----------------     *    now initialize children     * ----------------     */    ExecInitNode(outerPlan((Plan*)node), estate, (Plan*)node);    ExecInitNode(innerPlan((Plan*)node), estate, (Plan*)node);    /* ----------------     * 	initialize tuple type and projection info     * ----------------     */    ExecAssignResultTypeFromTL((Plan *) node, &nlstate->jstate);    ExecAssignProjectionInfo((Plan *) node, &nlstate->jstate);    /* ----------------     *  finally, wipe the current outer tuple clean.     * ----------------     */    nlstate->jstate.cs_OuterTupleSlot = NULL;    nlstate->jstate.cs_TupFromTlist = false;    NL1_printf("ExecInitNestLoop: %s/n",	       "node initialized");    return TRUE;}

/* ---------------------------------------------------------------- *		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 = node->cdb_strict ||							(eflags & (EXEC_FLAG_REWIND |										EXEC_FLAG_BACKWARD |										EXEC_FLAG_MARK)) != 0;	matstate->eof_underlying = false;	matstate->ts_state = palloc0(sizeof(GenericTupStore));	matstate->ts_pos = NULL;	matstate->ts_markpos = NULL;	matstate->share_lk_ctxt = NULL;	matstate->ts_destroyed = false;	ExecMaterialResetWorkfileState(matstate);	/*	 * 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);	matstate->ss.ss_ScanTupleSlot = ExecInitExtraTupleSlot(estate);	/*	 * If eflag contains EXEC_FLAG_REWIND or EXEC_FLAG_BACKWARD or EXEC_FLAG_MARK,	 * then this node is not eager free safe.	 */	matstate->ss.ps.delayEagerFree =		((eflags & (EXEC_FLAG_REWIND | EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)) != 0);	/*	 * initialize child nodes	 *	 * We shield the child node from the need to support BACKWARD, or	 * MARK/RESTORE.	 */	eflags &= ~(EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK);	/*	 * If Materialize does not have any external parameters, then it	 * can shield the child node from being rescanned as well, hence	 * we can clear the EXEC_FLAG_REWIND as well. If there are parameters,	 * don't clear the REWIND flag, as the child will be rewound.	 */	if (node->plan.allParam == NULL || node->plan.extParam == NULL)	{		eflags &= ~EXEC_FLAG_REWIND;	}	outerPlan = outerPlan(node);	/*	 * A very basic check to see if the optimizer requires the material to do a projection.	 * Ideally, this check would recursively compare all the target list expressions. However,	 * such a check is tricky because of the varno mismatch (outer plan may have a varno that	 * index into range table, while the material may refer to the same relation as "outer" varno)	 * [JIRA: MPP-25365]	 */	insist_log(list_length(node->plan.targetlist) == list_length(outerPlan->targetlist),			"Material operator does not support projection");	outerPlanState(matstate) = ExecInitNode(outerPlan, estate, eflags);	/*	 * If the child node of a Material is a Motion, then this Material node is	 * not eager free safe.	 */	if (IsA(outerPlan((Plan *)node), Motion))	{		matstate->ss.ps.delayEagerFree = true;	}//.........这里部分代码省略.........

/* ---------------------------------------------------------------- *		ExecInitGather * ---------------------------------------------------------------- */GatherState *ExecInitGather(Gather *node, EState *estate, int eflags){	GatherState *gatherstate;	Plan	   *outerNode;	bool		hasoid;	TupleDesc	tupDesc;	/* Gather node doesn't have innerPlan node. */	Assert(innerPlan(node) == NULL);	/*	 * create state structure	 */	gatherstate = makeNode(GatherState);	gatherstate->ps.plan = (Plan *) node;	gatherstate->ps.state = estate;	gatherstate->need_to_scan_locally = !node->single_copy;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &gatherstate->ps);	/*	 * initialize child expressions	 */	gatherstate->ps.targetlist = (List *)		ExecInitExpr((Expr *) node->plan.targetlist,					 (PlanState *) gatherstate);	gatherstate->ps.qual = (List *)		ExecInitExpr((Expr *) node->plan.qual,					 (PlanState *) gatherstate);	/*	 * tuple table initialization	 */	gatherstate->funnel_slot = ExecInitExtraTupleSlot(estate);	ExecInitResultTupleSlot(estate, &gatherstate->ps);	/*	 * now initialize outer plan	 */	outerNode = outerPlan(node);	outerPlanState(gatherstate) = ExecInitNode(outerNode, estate, eflags);	gatherstate->ps.ps_TupFromTlist = false;	/*	 * Initialize result tuple type and projection info.	 */	ExecAssignResultTypeFromTL(&gatherstate->ps);	ExecAssignProjectionInfo(&gatherstate->ps, NULL);	/*	 * Initialize funnel slot to same tuple descriptor as outer plan.	 */	if (!ExecContextForcesOids(&gatherstate->ps, &hasoid))		hasoid = false;	tupDesc = ExecTypeFromTL(outerNode->targetlist, hasoid);	ExecSetSlotDescriptor(gatherstate->funnel_slot, tupDesc);	return gatherstate;}