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

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

/* * DynamicScan_InitExpr * 		Initialize ExprState for a new partition from the plan's expressions */static voidDynamicScan_InitExpr(ScanState* scanState){	MemoryContext oldCxt = NULL;	MemoryContext partCxt = DynamicScan_GetPartitionMemoryContext(scanState);	if (NULL != partCxt)	{		MemoryContextReset(partCxt);		/*		 * Switch to partition memory context to prevent memory leak for		 * per-partition data structures.		 */		oldCxt = MemoryContextSwitchTo(partCxt);	}	/*	 * We might have reset the memory context. Set these dangling	 * pointers to NULL so that we don't try to pfree them later	 */	scanState->ps.ps_ProjInfo = NULL;	scanState->ps.qual = NULL;	scanState->ps.targetlist = NULL;	/* Initialize child expressions */	scanState->ps.qual = (List*) ExecInitExpr((Expr*) scanState->ps.plan->qual,			(PlanState*) scanState);	scanState->ps.targetlist = (List*) ExecInitExpr(			(Expr*) scanState->ps.plan->targetlist, (PlanState*) scanState);	ExecAssignScanProjectionInfo(scanState);	if (NULL != oldCxt)	{		MemoryContextSwitchTo(oldCxt);	}}

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

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

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

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

/* * Prepares for scanning of a new partition/relation. */voidBitmapTableScanBeginPartition(ScanState *node, bool initExpressions){	Assert(node != NULL);	BitmapTableScanState *scanState = (BitmapTableScanState *)node;	Assert(SCAN_NEXT == scanState->ss.scan_state);	initBitmapState(scanState);	if (scanState->bitmapqualorig == NULL || initExpressions)	{		/* TODO rahmaf2 [JIRA: MPP-23293]: remap columns per-partition to handle dropped columns */		scanState->bitmapqualorig = (List *)			ExecInitExpr((Expr *) ((BitmapTableScan*)(node->ps.plan))->bitmapqualorig,						 (PlanState *) scanState);	}	scanState->needNewBitmapPage = true;	scanState->recheckTuples = true;	getBitmapTableScanMethod(node->tableType)->beginScanMethod(node);	/*	 * Prepare child node to produce new bitmaps for the new partition (and cleanup	 * any leftover state from old partition).	 */	ExecReScan(outerPlanState(node), NULL);}

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

/* * Executes default values for columns for which we can't map to remote * relation columns. * * This allows us to support tables which have more columns on the downstream * than on the upstream. */static voidslot_fill_defaults(LogicalRepRelMapEntry *rel, EState *estate,				   TupleTableSlot *slot){	TupleDesc	desc = RelationGetDescr(rel->localrel);	int			num_phys_attrs = desc->natts;	int			i;	int			attnum,				num_defaults = 0;	int		   *defmap;	ExprState **defexprs;	ExprContext *econtext;	econtext = GetPerTupleExprContext(estate);	/* We got all the data via replication, no need to evaluate anything. */	if (num_phys_attrs == rel->remoterel.natts)		return;	defmap = (int *) palloc(num_phys_attrs * sizeof(int));	defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(ExprState *));	for (attnum = 0; attnum < num_phys_attrs; attnum++)	{		Expr	   *defexpr;		if (TupleDescAttr(desc, attnum)->attisdropped)			continue;		if (rel->attrmap[attnum] >= 0)			continue;		defexpr = (Expr *) build_column_default(rel->localrel, attnum + 1);		if (defexpr != NULL)		{			/* Run the expression through planner */			defexpr = expression_planner(defexpr);			/* Initialize executable expression in copycontext */			defexprs[num_defaults] = ExecInitExpr(defexpr, NULL);			defmap[num_defaults] = attnum;			num_defaults++;		}	}	for (i = 0; i < num_defaults; i++)		slot->tts_values[defmap[i]] =			ExecEvalExpr(defexprs[i], econtext, &slot->tts_isnull[defmap[i]]);}

/* * InitScanStateRelationDetails *   Opens a relation and sets various relation specific ScanState fields. */voidInitScanStateRelationDetails(ScanState *scanState, Plan *plan, EState *estate){	Assert(NULL != scanState);	PlanState *planState = &scanState->ps;	/* Initialize child expressions */	planState->targetlist = (List *)ExecInitExpr((Expr *)plan->targetlist, planState);	planState->qual = (List *)ExecInitExpr((Expr *)plan->qual, planState);	Relation currentRelation = ExecOpenScanRelation(estate, ((Scan *)plan)->scanrelid);	scanState->ss_currentRelation = currentRelation;  if (RelationIsAoRows(currentRelation) || RelationIsParquet(currentRelation))  {    scanState->splits = GetFileSplitsOfSegment(estate->es_plannedstmt->scantable_splits,                    currentRelation->rd_id, GetQEIndex());  }	ExecAssignScanType(scanState, RelationGetDescr(currentRelation));	ExecAssignScanProjectionInfo(scanState);	scanState->tableType = getTableType(scanState->ss_currentRelation);}

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

/* * Prepare function call in FROM (ROWS FROM) for execution. * * This is used by nodeFunctionscan.c. */SetExprState *ExecInitTableFunctionResult(Expr *expr,							ExprContext *econtext, PlanState *parent){	SetExprState *state = makeNode(SetExprState);	state->funcReturnsSet = false;	state->expr = expr;	state->func.fn_oid = InvalidOid;	/*	 * Normally the passed expression tree will be a FuncExpr, since the	 * grammar only allows a function call at the top level of a table	 * function reference.  However, if the function doesn't return set then	 * the planner might have replaced the function call via constant-folding	 * or inlining.  So if we see any other kind of expression node, execute	 * it via the general ExecEvalExpr() code.  That code path will not	 * support set-returning functions buried in the expression, though.	 */	if (IsA(expr, FuncExpr))	{		FuncExpr   *func = (FuncExpr *) expr;		state->funcReturnsSet = func->funcretset;		state->args = ExecInitExprList(func->args, parent);		init_sexpr(func->funcid, func->inputcollid, expr, state, parent,				   econtext->ecxt_per_query_memory, func->funcretset, false);	}	else	{		state->elidedFuncState = ExecInitExpr(expr, parent);	}	return state;}

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

		 * Lookup the operators, and replace the data in the copied		 * operator nodes.		 */		op_mergejoin_crossops(ltop->opno,							  &ltop->opno,							  &gtop->opno,							  &ltop->opfuncid,							  &gtop->opfuncid);		ltcdr = lnext(ltcdr);	}	/*	 * Prepare both lists for execution.	 */	*ltQuals = (List *) ExecInitExpr((Expr *) ltexprs, parent);	*gtQuals = (List *) ExecInitExpr((Expr *) gtexprs, parent);}/* ---------------------------------------------------------------- *		MergeCompare * *		Compare the keys according to 'compareQual' which is of the *		form: { (key1a > key2a) (key1b > key2b) ... }. * *		(actually, it could also be of the form (key1a < key2a)...) * *		This is different from calling ExecQual because ExecQual returns *		true only if ALL the comparison clauses are satisfied. *		However, there is an order of significance among the keys with *		the first keys being most significant. Therefore, the clauses

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

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

/* ---------------------------------------------------------------- *		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->rs_done = false;	resstate->rs_checkqual = (node->resconstantqual == NULL) ? false : true;	/*	 * Miscellaneous initialization	 *	 * create expression context for node	 */	ExecAssignExprContext(estate, &resstate->ps);	resstate->ps.ps_TupFromTlist = false;	/*	 * 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, eflags);	/*	 * we don't use inner plan	 */	Assert(innerPlan(node) == NULL);	/*	 * initialize tuple type and projection info	 */	ExecAssignResultTypeFromTL(&resstate->ps);	ExecAssignProjectionInfo(&resstate->ps, NULL);	return resstate;}

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

TupleCheckStatusFilterInit(Filter *filter, TupleDesc desc, Oid collation){	int				i;	ParsedFunction	func;	HeapTuple		ftup;	HeapTuple		ltup;	Form_pg_proc	pp;	Form_pg_language	lp;	TupleCheckStatus	status = NEED_COERCION_CHECK;	if (filter->funcstr == NULL)		return NO_COERCION;	/* parse filter function */	func = ParseFunction(filter->funcstr, true);	filter->funcid = func.oid;	filter->nargs = func.nargs;	for (i = 0; i < filter->nargs; i++)	{		/* Check for polymorphic types and internal pseudo-type argument */		if (IsPolymorphicType(func.argtypes[i]) ||			func.argtypes[i] == INTERNALOID)			ereport(ERROR,					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),					 errmsg("filter function does not support a polymorphic function and having a internal pseudo-type argument function: %s",							get_func_name(filter->funcid))));		filter->argtypes[i] = func.argtypes[i];	}	ftup = SearchSysCache(PROCOID, ObjectIdGetDatum(filter->funcid), 0, 0, 0);	pp = (Form_pg_proc) GETSTRUCT(ftup);	if (pp->proretset)		ereport(ERROR,				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),				 errmsg("filter function must not return set")));	/* Check data type of the function result value */	if (pp->prorettype == desc->tdtypeid && pp->prorettype != RECORDOID)		status = NO_COERCION;	else if (pp->prorettype == RECORDOID)	{		TupleDesc	resultDesc = NULL;		/* Check for OUT parameters defining a RECORD result */		resultDesc = build_function_result_tupdesc_t(ftup);		if (resultDesc)		{			if (tupledesc_match(desc, resultDesc))				status = NO_COERCION;			FreeTupleDesc(resultDesc);		}	}	else if (get_typtype(pp->prorettype) != TYPTYPE_COMPOSITE)		ereport(ERROR,				(errcode(ERRCODE_DATATYPE_MISMATCH),				 errmsg("function return data type and target table data type do not match")));	/* Get default values */#if PG_VERSION_NUM >= 80400	filter->fn_ndargs = pp->pronargdefaults;	if (filter->fn_ndargs > 0)	{		Datum		proargdefaults;		bool		isnull;		char	   *str;		List	   *defaults;		ListCell   *l;		filter->defaultValues = palloc(sizeof(Datum) * filter->fn_ndargs);		filter->defaultIsnull = palloc(sizeof(bool) * filter->fn_ndargs);		proargdefaults = SysCacheGetAttr(PROCOID, ftup,										 Anum_pg_proc_proargdefaults,										 &isnull);		Assert(!isnull);		str = TextDatumGetCString(proargdefaults);		defaults = (List *) stringToNode(str);		Assert(IsA(defaults, List));		pfree(str);		filter->econtext = CreateStandaloneExprContext();		i = 0;		foreach(l, defaults)		{			Expr		   *expr = (Expr *) lfirst(l);			ExprState	   *argstate;			ExprDoneCond	thisArgIsDone;			argstate = ExecInitExpr(expr, NULL);			filter->defaultValues[i] = ExecEvalExpr(argstate,													filter->econtext,													&filter->defaultIsnull[i],													&thisArgIsDone);//.........这里部分代码省略.........

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

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

/* ---------------------------------------------------------------- *		ValuesNext * *		This is a workhorse for ExecValuesScan * ---------------------------------------------------------------- */static TupleTableSlot *ValuesNext(ValuesScanState *node){	TupleTableSlot *slot;	EState	   *estate;	ExprContext *econtext;	ScanDirection direction;	List	   *exprlist;	/*	 * get information from the estate and scan state	 */	estate = node->ss.ps.state;	direction = estate->es_direction;	slot = node->ss.ss_ScanTupleSlot;	econtext = node->rowcontext;	/*	 * Get the next tuple. Return NULL if no more tuples.	 */	if (ScanDirectionIsForward(direction))	{		if (node->curr_idx < node->array_len)			node->curr_idx++;		if (node->curr_idx < node->array_len)			exprlist = node->exprlists[node->curr_idx];		else			exprlist = NIL;	}	else	{		if (node->curr_idx >= 0)			node->curr_idx--;		if (node->curr_idx >= 0)			exprlist = node->exprlists[node->curr_idx];		else			exprlist = NIL;	}	/*	 * Always clear the result slot; this is appropriate if we are at the end	 * of the data, and if we're not, we still need it as the first step of	 * the store-virtual-tuple protocol.  It seems wise to clear the slot	 * before we reset the context it might have pointers into.	 */	ExecClearTuple(slot);	if (exprlist)	{		MemoryContext oldContext;		List	   *exprstatelist;		Datum	   *values;		bool	   *isnull;		ListCell   *lc;		int			resind;		/*		 * Get rid of any prior cycle's leftovers.  We use ReScanExprContext		 * not just ResetExprContext because we want any registered shutdown		 * callbacks to be called.		 */		ReScanExprContext(econtext);		/*		 * Build the expression eval state in the econtext's per-tuple memory.		 * This is a tad unusual, but we want to delete the eval state again		 * when we move to the next row, to avoid growth of memory		 * requirements over a long values list.		 */		oldContext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);		/*		 * Pass NULL, not my plan node, because we don't want anything in this		 * transient state linking into permanent state.  The only possibility		 * is a SubPlan, and there shouldn't be any (any subselects in the		 * VALUES list should be InitPlans).		 */		exprstatelist = (List *) ExecInitExpr((Expr *) exprlist, NULL);		/* parser should have checked all sublists are the same length */		Assert(list_length(exprstatelist) == slot->tts_tupleDescriptor->natts);		/*		 * Compute the expressions and build a virtual result tuple. We		 * already did ExecClearTuple(slot).		 */		values = slot->tts_values;		isnull = slot->tts_isnull;		resind = 0;		foreach(lc, exprstatelist)		{			ExprState  *estate = (ExprState *) lfirst(lc);//.........这里部分代码省略.........

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

//.........这里部分代码省略.........			if (rightop && IsA(rightop, RelabelType))				rightop = ((RelabelType *) rightop)->arg;			Assert(rightop != NULL);			if (IsA(rightop, Const))			{				/* OK, simple constant comparison value */				scanvalue = ((Const *) rightop)->constvalue;				if (((Const *) rightop)->constisnull)					flags |= SK_ISNULL;			}			else			{				/* Need to treat this one as a runtime key */				if (n_runtime_keys >= max_runtime_keys)				{					if (max_runtime_keys == 0)					{						max_runtime_keys = 8;						runtime_keys = (IndexRuntimeKeyInfo *)							palloc(max_runtime_keys * sizeof(IndexRuntimeKeyInfo));					}					else					{						max_runtime_keys *= 2;						runtime_keys = (IndexRuntimeKeyInfo *)							repalloc(runtime_keys, max_runtime_keys * sizeof(IndexRuntimeKeyInfo));					}				}				runtime_keys[n_runtime_keys].scan_key = this_scan_key;				runtime_keys[n_runtime_keys].key_expr =					ExecInitExpr(rightop, planstate);				runtime_keys[n_runtime_keys].key_toastable =					TypeIsToastable(op_righttype);				n_runtime_keys++;				scanvalue = (Datum) 0;			}			/*			 * initialize the scan key's fields appropriately			 */			ScanKeyEntryInitialize(this_scan_key,								   flags,								   varattno,	/* attribute number to scan */								   op_strategy, /* op's strategy */								   op_righttype,		/* strategy subtype */								   ((OpExpr *) clause)->inputcollid,	/* collation */								   opfuncid,	/* reg proc to use */								   scanvalue);	/* constant */		}		else if (IsA(clause, RowCompareExpr))		{			/* (indexkey, indexkey, ...) op (expression, expression, ...) */			RowCompareExpr *rc = (RowCompareExpr *) clause;			ListCell   *largs_cell = list_head(rc->largs);			ListCell   *rargs_cell = list_head(rc->rargs);			ListCell   *opnos_cell = list_head(rc->opnos);			ListCell   *collids_cell = list_head(rc->inputcollids);			ScanKey		first_sub_key;			int			n_sub_key;			Assert(!isorderby);			first_sub_key = (ScanKey)

/* * This function initializes a part and returns true if a new index has been prepared for scanning. */static boolinitNextIndexToScan(DynamicIndexScanState *node){	IndexScanState *indexState = &(node->indexScanState);	DynamicIndexScan *dynamicIndexScan = (DynamicIndexScan *)node->indexScanState.ss.ps.plan;	/* Load new index when the scanning of the previous index is done. */	if (indexState->ss.scan_state == SCAN_INIT ||		indexState->ss.scan_state == SCAN_DONE)	{		/* This is the oid of a partition of the table (*not* index) */		Oid *pid = hash_seq_search(&node->pidxStatus);		if (pid == NULL)		{			/* Return if all parts have been scanned. */			node->shouldCallHashSeqTerm = false;			return false;		}		/* Collect number of partitions scanned in EXPLAIN ANALYZE */		if(NULL != indexState->ss.ps.instrument)		{			Instrumentation *instr = indexState->ss.ps.instrument;			instr->numPartScanned ++;		}		DynamicIndexScan_ReMapColumns(node, *pid);		/*		 * The is the oid of the partition of an *index*. Note: a partitioned table		 * has a root and a set of partitions (may be multi-level). An index		 * on a partitioned table also has a root and a set of index partitions.		 * We started at table level, and now we are fetching the oid of an index		 * partition.		 */		Oid pindex = getPhysicalIndexRelid(dynamicIndexScan->logicalIndexInfo,					 *pid);		Assert(OidIsValid(pindex));		Relation currentRelation = OpenScanRelationByOid(*pid);		indexState->ss.ss_currentRelation = currentRelation;		for (int i=0; i < DYNAMICINDEXSCAN_NSLOTS; i++)		{			indexState->ss.ss_ScanTupleSlot[i].tts_tableOid = *pid;		}		ExecAssignScanType(&indexState->ss, RelationGetDescr(currentRelation));		ScanState *scanState = (ScanState *)node;		MemoryContextReset(node->partitionMemoryContext);		MemoryContext oldCxt = MemoryContextSwitchTo(node->partitionMemoryContext);		/* Initialize child expressions */		scanState->ps.qual = (List *)ExecInitExpr((Expr *)scanState->ps.plan->qual, (PlanState*)scanState);		scanState->ps.targetlist = (List *)ExecInitExpr((Expr *)scanState->ps.plan->targetlist, (PlanState*)scanState);		ExecAssignScanProjectionInfo(scanState);		EState *estate = indexState->ss.ps.state;		indexState->iss_RelationDesc =			OpenIndexRelation(estate, pindex, *pid);		/*		 * build the index scan keys from the index qualification		 */		ExecIndexBuildScanKeys((PlanState *) indexState,						   indexState->iss_RelationDesc,						   dynamicIndexScan->indexqual,						   dynamicIndexScan->indexstrategy,						   dynamicIndexScan->indexsubtype,						   &indexState->iss_ScanKeys,						   &indexState->iss_NumScanKeys,						   &indexState->iss_RuntimeKeys,						   &indexState->iss_NumRuntimeKeys,						   NULL,						   NULL);		MemoryContextSwitchTo(oldCxt);		ExprContext *econtext = indexState->iss_RuntimeContext;		/* context for runtime keys */		if (indexState->iss_NumRuntimeKeys != 0)		{			ExecIndexEvalRuntimeKeys(econtext,									 indexState->iss_RuntimeKeys,									 indexState->iss_NumRuntimeKeys);		}		indexState->iss_RuntimeKeysReady = true;		/*		 * Initialize result tuple type and projection info.//.........这里部分代码省略.........