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

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

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

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

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

/* ---------------------------------------------------------------- *		ExecInitLimit * *		This initializes the limit node state structures and *		the node's subplan. * ---------------------------------------------------------------- */limit_ps *ExecInitLimit(limit_pl *node, exec_state_n *estate, int eflags){	limit_ps *limitstate;	plan_n *outerPlan;	/* check for unsupported flags */	ASSERT(!(eflags & EXEC_FLAG_MARK));	/*	 * create state structure	 */	limitstate = MK_N(LimitState,limit_ps);	limitstate->ps.plan = (plan_n *) node;	limitstate->ps.state = estate;	limitstate->lstate = LIMIT_INITIAL;	/*	 * Miscellaneous initialization	 *	 * limit_pl nodes never call exec_qual or exec_projection, but they need an	 * exprcontext anyway to evaluate the limit/offset parameters in.	 */	ExecAssignExprContext(estate, &limitstate->ps);	/*	 * initialize child expressions	 */	limitstate->limitOffset = exec_init_expr(		(expr_n*) node->limitOffset,		(plan_state_n*) limitstate);	limitstate->limitCount = exec_init_expr(		(expr_n*) node->limitCount,		(plan_state_n*) limitstate);	/*	 * Tuple table initialization (XXX not actually used...)	 */	exec_init_result_tupslot(estate, &limitstate->ps);	/*	 * then initialize outer plan	 */	outerPlan = OUTER_PLAN(node);	OUTER_PLAN_STATE(limitstate) = exec_init_node(outerPlan, estate, eflags);	/*	 * limit nodes do no projections, so initialize projection info for this	 * node appropriately	 */	ExecAssignResultTypeFromTL(&limitstate->ps);	limitstate->ps.ps_ProjInfo = NULL;	return limitstate;}

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

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

/* ---------------------------------------------------------------- *		ExecInitHash * *		Init routine for hash_pl node * ---------------------------------------------------------------- */hash_ps *ExecInitHash(hash_pl *node, exec_state_n *estate, int eflags){	hash_ps* hashstate;	/* check for unsupported flags */	ASSERT(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * create state structure	 */	hashstate = MK_N(HashState,hash_ps);	hashstate->ps.plan = (plan_n *) node;	hashstate->ps.state = estate;	hashstate->hashtable = NULL;	hashstate->hashkeys = NIL;	/* will be set by parent hash_join_jo */	/*	 * Miscellaneous initialization	 * create expression context for node	 */	ExecAssignExprContext(estate, &hashstate->ps);	/*	 * initialize our result slot	 */	exec_init_result_tupslot(estate, &hashstate->ps);	/*	 * initialize child expressions	 */	hashstate->ps.targetlist = (struct list*) exec_init_expr(		(expr_n*) node->plan.targetlist,		(plan_state_n*) hashstate);	hashstate->ps.qual = (struct list*) exec_init_expr(		(expr_n*) node->plan.qual,		(plan_state_n *) hashstate);	/*	 * initialize child nodes	 */	OUTER_PLAN_STATE(hashstate) = exec_init_node(OUTER_PLAN(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;}

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

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

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

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

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

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

//.........这里部分代码省略.........	 * initialize child expressions	 *	 * We don't need to initialize targetlist or qual since neither are used.	 *	 * Note: we don't initialize all of the indexqual expression, only the	 * sub-parts corresponding to runtime keys (see below).	 */	/*	 * We do not open or lock the base relation here.  We assume that an	 * ancestor BitmapHeapScan node is holding AccessShareLock (or better) on	 * the heap relation throughout the execution of the plan tree.	 */	indexstate->ss.ss_currentRelation = NULL;	indexstate->ss.ss_currentScanDesc = NULL;	/*	 * 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->biss_RelationDesc = index_open(node->indexid,									 relistarget ? NoLock : AccessShareLock);	/*	 * Initialize index-specific scan state	 */	indexstate->biss_RuntimeKeysReady = false;	indexstate->biss_RuntimeKeys = NULL;	indexstate->biss_NumRuntimeKeys = 0;	/*	 * build the index scan keys from the index qualification	 */	ExecIndexBuildScanKeys((PlanState *) indexstate,						   indexstate->biss_RelationDesc,						   node->indexqual,						   false,						   &indexstate->biss_ScanKeys,						   &indexstate->biss_NumScanKeys,						   &indexstate->biss_RuntimeKeys,						   &indexstate->biss_NumRuntimeKeys,						   &indexstate->biss_ArrayKeys,						   &indexstate->biss_NumArrayKeys);	/*	 * If we have runtime keys or array keys, we need an ExprContext to	 * evaluate them. We could just create a "standard" plan node exprcontext,	 * but to keep the code looking similar to nodeIndexscan.c, it seems	 * better to stick with the approach of using a separate ExprContext.	 */	if (indexstate->biss_NumRuntimeKeys != 0 ||		indexstate->biss_NumArrayKeys != 0)	{		ExprContext *stdecontext = indexstate->ss.ps.ps_ExprContext;		ExecAssignExprContext(estate, &indexstate->ss.ps);		indexstate->biss_RuntimeContext = indexstate->ss.ps.ps_ExprContext;		indexstate->ss.ps.ps_ExprContext = stdecontext;	}	else	{		indexstate->biss_RuntimeContext = NULL;	}	/*	 * Initialize scan descriptor.	 */	indexstate->biss_ScanDesc =		index_beginscan_bitmap(indexstate->biss_RelationDesc,							   estate->es_snapshot,							   indexstate->biss_NumScanKeys);	/*	 * If no run-time keys to calculate, go ahead and pass the scankeys to the	 * index AM.	 */	if (indexstate->biss_NumRuntimeKeys == 0 &&		indexstate->biss_NumArrayKeys == 0)		index_rescan(indexstate->biss_ScanDesc,					 indexstate->biss_ScanKeys, indexstate->biss_NumScanKeys,					 NULL, 0);	/*	 * all done.	 */	return indexstate;}

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

/* ---------------------------------------------------------------- *		ExecInitCteScan * ---------------------------------------------------------------- */CteScanState *ExecInitCteScan(CteScan *node, EState *estate, int eflags){	CteScanState *scanstate;	ParamExecData *prmdata;	/* check for unsupported flags */	Assert(!(eflags & EXEC_FLAG_MARK));	/*	 * For the moment we have to force the tuplestore to allow REWIND, because	 * we might be asked to rescan the CTE even though upper levels didn't	 * tell us to be prepared to do it efficiently.  Annoying, since this	 * prevents truncation of the tuplestore.  XXX FIXME	 *	 * 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//.........这里部分代码省略.........

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

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

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

/* ---------------------------------------------------------------- *		ExecInitForeignScan * ---------------------------------------------------------------- */foreign_ss *ExecInitForeignScan(foreign_scan_sc *node, exec_state_n *estate, int eflags){	foreign_ss* scanstate;	struct relation* currentRelation;	FdwRoutine *fdwroutine;	/* check for unsupported flags */	ASSERT(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));	/*	 * create state structure	 */	scanstate = MK_N(ForeignScanState,foreign_ss);	scanstate->ss.ps.plan = (plan_n *) 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 = (struct list *) exec_init_expr(						(expr_n *) node->scan.plan.targetlist,						(plan_state_n *) scanstate);	scanstate->ss.ps.qual = (struct list *) exec_init_expr(						(expr_n *) node->scan.plan.qual,						(plan_state_n *) scanstate);	/*	 * tuple table initialization	 */	exec_init_result_tupslot(estate, &scanstate->ss.ps);	exec_init_scan_tupslot(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, REL_DESC(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(REL_ID(currentRelation));	scanstate->fdwroutine = fdwroutine;	scanstate->fdw_state = NULL;	/*	 * Tell the FDW to initiate the scan.	 */	fdwroutine->BeginForeignScan(scanstate, eflags);	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;}

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