PostgreSQL数据库查询执行——InitPlan函数分析

缺乏、安全感 2022-10-08 00:53 232阅读 0赞

InitPlan函数用于初始化查询计划，包括打开文件、分配存储和启动规则管理器。其主要步骤如下：

1.  对rangeTable做权限检查
2.  初始化节点执行状态
3.  初始化queryDesc->plannedstmt->resultRelations结果表信息数据结构体，并打开结果关系表
4.  从PlanRowMark(s)构建ExecRowMark数组
5.  为每个子计划SubPlan初始化private状态信息
6.  初始化查询树所有节点的private状态信息

static void InitPlan(QueryDesc *queryDesc, int eflags) { 
    	CmdType		operation = queryDesc->operation;
    	PlannedStmt *plannedstmt = queryDesc->plannedstmt;
    	Plan	   *plan = plannedstmt->planTree;
    	List	   *rangeTable = plannedstmt->rtable;
    	EState	   *estate = queryDesc->estate;
    	PlanState  *planstate;
    	TupleDesc	tupType;
    	ListCell   *l;
    	int			i;
    	/* Do permissions checks */
    	ExecCheckRTPerms(rangeTable, true);
    	/* initialize the node's execution state */
    	ExecInitRangeTable(estate, rangeTable);
    	estate->es_plannedstmt = plannedstmt;
    	/* Initialize ResultRelInfo data structures, and open the result rels. */
    	if (plannedstmt->resultRelations){ 
    		List	   *resultRelations = plannedstmt->resultRelations;
    		int			numResultRelations = list_length(resultRelations);
    		ResultRelInfo *resultRelInfos;
    		ResultRelInfo *resultRelInfo;
    		resultRelInfos = (ResultRelInfo *)palloc(numResultRelations * sizeof(ResultRelInfo));
    		resultRelInfo = resultRelInfos;
    		foreach(l, resultRelations){ 
    			Index		resultRelationIndex = lfirst_int(l);
    			Relation	resultRelation;
    			resultRelation = ExecGetRangeTableRelation(estate,resultRelationIndex);
    			InitResultRelInfo(resultRelInfo,resultRelation,resultRelationIndex,NULL,estate->es_instrument);
    			resultRelInfo++;
    		}
    		estate->es_result_relations = resultRelInfos;
    		estate->es_num_result_relations = numResultRelations;
    		/* es_result_relation_info is NULL except when within ModifyTable */
    		estate->es_result_relation_info = NULL;
    		/* In the partitioned result relation case, also build ResultRelInfos for all the partitioned table roots, because we will need them to fire statement-level triggers, if any. */
    		if (plannedstmt->rootResultRelations){ 
    			int			num_roots = list_length(plannedstmt->rootResultRelations);
    			resultRelInfos = (ResultRelInfo *)palloc(num_roots * sizeof(ResultRelInfo));
    			resultRelInfo = resultRelInfos;
    			foreach(l, plannedstmt->rootResultRelations){ 
    				Index		resultRelIndex = lfirst_int(l);
    				Relation	resultRelDesc;
    				resultRelDesc = ExecGetRangeTableRelation(estate,resultRelIndex);
    				InitResultRelInfo(resultRelInfo,resultRelDesc,resultRelIndex,NULL,estate->es_instrument);
    				resultRelInfo++;
    			}
    			estate->es_root_result_relations = resultRelInfos;
    			estate->es_num_root_result_relations = num_roots;
    		}else{ 
    			estate->es_root_result_relations = NULL;
    			estate->es_num_root_result_relations = 0;
    		}
    	}else{ 
    		/* if no result relation, then set state appropriately */
    		estate->es_result_relations = NULL;
    		estate->es_num_result_relations = 0;
    		estate->es_result_relation_info = NULL;
    		estate->es_root_result_relations = NULL;
    		estate->es_num_root_result_relations = 0;
    	}
    	/* Next, build the ExecRowMark array from the PlanRowMark(s), if any. */
    	if (plannedstmt->rowMarks){ 
    		estate->es_rowmarks = (ExecRowMark **)palloc0(estate->es_range_table_size * sizeof(ExecRowMark *));
    		foreach(l, plannedstmt->rowMarks){ 
    			PlanRowMark *rc = (PlanRowMark *) lfirst(l);
    			Oid			relid;
    			Relation	relation;
    			ExecRowMark *erm;
    			/* ignore "parent" rowmarks; they are irrelevant at runtime */
    			if (rc->isParent)
    				continue;
    			/* get relation's OID (will produce InvalidOid if subquery) */
    			relid = exec_rt_fetch(rc->rti, estate)->relid;
    			/* open relation, if we need to access it for this mark type */
    			switch (rc->markType){ 
    				case ROW_MARK_EXCLUSIVE:
    				case ROW_MARK_NOKEYEXCLUSIVE:
    				case ROW_MARK_SHARE:
    				case ROW_MARK_KEYSHARE:
    				case ROW_MARK_REFERENCE:
    					relation = ExecGetRangeTableRelation(estate, rc->rti);
    					break;
    				case ROW_MARK_COPY:
    					/* no physical table access is required */
    					relation = NULL;
    					break;
    				default:
    					elog(ERROR, "unrecognized markType: %d", rc->markType);
    					relation = NULL;	/* keep compiler quiet */
    					break;
    			}
    			/* Check that relation is a legal target for marking */
    			if (relation)
    				CheckValidRowMarkRel(relation, rc->markType);
    			erm = (ExecRowMark *) palloc(sizeof(ExecRowMark));
    			erm->relation = relation;
    			erm->relid = relid;
    			erm->rti = rc->rti;
    			erm->prti = rc->prti;
    			erm->rowmarkId = rc->rowmarkId;
    			erm->markType = rc->markType;
    			erm->strength = rc->strength;
    			erm->waitPolicy = rc->waitPolicy;
    			erm->ermActive = false;
    			ItemPointerSetInvalid(&(erm->curCtid));
    			erm->ermExtra = NULL;
    			Assert(erm->rti > 0 && erm->rti <= estate->es_range_table_size && estate->es_rowmarks[erm->rti - 1] == NULL);
    			estate->es_rowmarks[erm->rti - 1] = erm;
    		}
    	}
    	/* Initialize the executor's tuple table to empty. */
    	estate->es_tupleTable = NIL;
    	/* signal that this EState is not used for EPQ */
    	estate->es_epq_active = NULL;
    	/* Initialize private state information for each SubPlan. We must do this before running ExecInitNode on the main query tree, since ExecInitSubPlan expects to be able to find these entries. */
    	Assert(estate->es_subplanstates == NIL);
    	i = 1;						/* subplan indices count from 1 */
    	foreach(l, plannedstmt->subplans){ 
    		Plan	   *subplan = (Plan *) lfirst(l);
    		PlanState  *subplanstate;
    		int			sp_eflags;
    		/* A subplan will never need to do BACKWARD scan nor MARK/RESTORE. If it is a parameterless subplan (not initplan), we suggest that it be prepared to handle REWIND efficiently; otherwise there is no need. */
    		sp_eflags = eflags & (EXEC_FLAG_EXPLAIN_ONLY | EXEC_FLAG_WITH_NO_DATA);
    		if (bms_is_member(i, plannedstmt->rewindPlanIDs))
    			sp_eflags |= EXEC_FLAG_REWIND;
    		subplanstate = ExecInitNode(subplan, estate, sp_eflags);
    		estate->es_subplanstates = lappend(estate->es_subplanstates,subplanstate);
    		i++;
    	}
    	/* Initialize the private state information for all the nodes in the query tree. This opens files, allocates storage and leaves us ready to start processing tuples. */
    	planstate = ExecInitNode(plan, estate, eflags);
    	/* Get the tuple descriptor describing the type of tuples to return. */
    	tupType = ExecGetResultType(planstate);
    	/* Initialize the junk filter if needed. SELECT queries need a filter if there are any junk attrs in the top-level tlist. */
    	if (operation == CMD_SELECT){ 
    		bool		junk_filter_needed = false;
    		ListCell   *tlist;
    		foreach(tlist, plan->targetlist){ 
    			TargetEntry *tle = (TargetEntry *) lfirst(tlist);
    			if (tle->resjunk){ 
    				junk_filter_needed = true;
    				break;
    			}
    		}
    		if (junk_filter_needed){ 
    			JunkFilter *j;
    			TupleTableSlot *slot;
    			slot = ExecInitExtraTupleSlot(estate, NULL, &TTSOpsVirtual);
    			j = ExecInitJunkFilter(planstate->plan->targetlist,slot);
    			estate->es_junkFilter = j;
    			/* Want to return the cleaned tuple type */
    			tupType = j->jf_cleanTupType;
    		}
    	}
    	queryDesc->tupDesc = tupType;
    	queryDesc->planstate = planstate;
    }

## ExecCheckRTPerms函数 ##

ExecCheckRTPerms函数检查范围表中列出的所有关系的访问权限。如果权限足够，则返回 true。 否则，如果 ereport\_on\_violation 为真，则抛出适当的错误，否则仅返回假。请注意，这不解决行级安全策略（又名：RLS）。 如果由于此权限检查通过而将行返回给用户，则还需要咨询 RLS（和 check\_enable\_rls()）。

bool ExecCheckRTPerms(List *rangeTable, bool ereport_on_violation) { 
    	ListCell   *l;
    	bool		result = true;
    	foreach(l, rangeTable){ 
    		RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
    		result = ExecCheckRTEPerms(rte);
    		if (!result){ 
    			Assert(rte->rtekind == RTE_RELATION);
    			if (ereport_on_violation)
    				aclcheck_error(ACLCHECK_NO_PRIV, get_relkind_objtype(get_rel_relkind(rte->relid)), get_rel_name(rte->relid));
    			return false;
    		}
    	}
    	if (ExecutorCheckPerms_hook)
    		result = (*ExecutorCheckPerms_hook) (rangeTable, ereport_on_violation);
    	return result;
    }

函数逻辑是调用ExecCheckRTEPerms函数检查每个Range Table，图中左下角的结构体，然后会执行一下执行器检查权限的钩子ExecutorCheckPerms\_hook，这里我们可以使用钩子来定义不同的功能。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center]

### ExecInitRangeTable函数 ###

`ExecInitRangeTable(estate, rangeTable)`函数建立执行器range-table-related数据。我们从范围表列表构建一个数组，以允许 RTI 更快地查找。 （es\_range\_table 字段现在有些多余，但我们保留它以避免不必要地破坏外部代码。）这也是设置并行 es\_relations 数组的方便位置。

void ExecInitRangeTable(EState *estate, List *rangeTable) { 
    	Index		rti;
    	ListCell   *lc;
    	/* Remember the range table List as-is */
    	estate->es_range_table = rangeTable;
    	/* Set up the equivalent array representation */
    	estate->es_range_table_size = list_length(rangeTable);
    	estate->es_range_table_array = (RangeTblEntry **)palloc(estate->es_range_table_size * sizeof(RangeTblEntry *));
    	rti = 0;
    	foreach(lc, rangeTable){ 
    		estate->es_range_table_array[rti++] = lfirst_node(RangeTblEntry, lc);
    	}
    	/* Allocate an array to store an open Relation corresponding to each rangetable entry, and initialize entries to NULL. Relations are opened and stored here as needed. */
    	estate->es_relations = (Relation *)palloc0(estate->es_range_table_size * sizeof(Relation));
    	/* es_rowmarks is also parallel to the es_range_table_array, but it's allocated only if needed. */
    	estate->es_rowmarks = NULL;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center 1]

### ExecGetRangeTableRelation和InitResultRelInfo函数 ###

ExecGetRangeTableRelation函数为范围表条目打开关系表，就是通过检查estate->es\_relations中每个条目是否打开，没有则打开。

Relation ExecGetRangeTableRelation(EState *estate, Index rti) { 
    	Relation	rel;
    	Assert(rti > 0 && rti <= estate->es_range_table_size);
    	rel = estate->es_relations[rti - 1];
    	if (rel == NULL){ 
    		/* First time through, so open the relation */
    		RangeTblEntry *rte = exec_rt_fetch(rti, estate);
    		Assert(rte->rtekind == RTE_RELATION);
    		if (!IsParallelWorker()){ 
    			rel = table_open(rte->relid, NoLock);
    			Assert(rte->rellockmode == AccessShareLock || CheckRelationLockedByMe(rel, rte->rellockmode, false));
    		}else{ 
    			rel = table_open(rte->relid, rte->rellockmode);
    		}
    		estate->es_relations[rti - 1] = rel;
    	}
    	return rel;
    }

InitResultRelInfo函数为单个结果关系表初始化ResultRelInfo数据结构  
InitResultRelInfo(resultRelInfo,resultRelation,resultRelationIndex,NULL,estate->es\_instrument);

void InitResultRelInfo(ResultRelInfo *resultRelInfo, Relation resultRelationDesc, Index resultRelationIndex, ResultRelInfo *partition_root_rri, int instrument_options){ 
    	List	   *partition_check = NIL;
    	MemSet(resultRelInfo, 0, sizeof(ResultRelInfo));
    	resultRelInfo->type = T_ResultRelInfo;
    	resultRelInfo->ri_RangeTableIndex = resultRelationIndex;
    	resultRelInfo->ri_RelationDesc = resultRelationDesc;
    	resultRelInfo->ri_NumIndices = 0;
    	resultRelInfo->ri_IndexRelationDescs = NULL;
    	resultRelInfo->ri_IndexRelationInfo = NULL;
    	/* make a copy so as not to depend on relcache info not changing... */
    	resultRelInfo->ri_TrigDesc = CopyTriggerDesc(resultRelationDesc->trigdesc);
    	if (resultRelInfo->ri_TrigDesc){ 
    		int			n = resultRelInfo->ri_TrigDesc->numtriggers;
    		resultRelInfo->ri_TrigFunctions = (FmgrInfo *)palloc0(n * sizeof(FmgrInfo));
    		resultRelInfo->ri_TrigWhenExprs = (ExprState **)palloc0(n * sizeof(ExprState *));
    		if (instrument_options)
    			resultRelInfo->ri_TrigInstrument = InstrAlloc(n, instrument_options);
    	}else{ 
    		resultRelInfo->ri_TrigFunctions = NULL;
    		resultRelInfo->ri_TrigWhenExprs = NULL;
    		resultRelInfo->ri_TrigInstrument = NULL;
    	}
    	if (resultRelationDesc->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
    		resultRelInfo->ri_FdwRoutine = GetFdwRoutineForRelation(resultRelationDesc, true);
    	else
    		resultRelInfo->ri_FdwRoutine = NULL;
    	/* The following fields are set later if needed */
    	resultRelInfo->ri_FdwState = NULL;
    	resultRelInfo->ri_usesFdwDirectModify = false;
    	resultRelInfo->ri_ConstraintExprs = NULL;
    	resultRelInfo->ri_GeneratedExprs = NULL;
    	resultRelInfo->ri_junkFilter = NULL;
    	resultRelInfo->ri_projectReturning = NULL;
    	resultRelInfo->ri_onConflictArbiterIndexes = NIL;
    	resultRelInfo->ri_onConflict = NULL;
    	resultRelInfo->ri_ReturningSlot = NULL;
    	resultRelInfo->ri_TrigOldSlot = NULL;
    	resultRelInfo->ri_TrigNewSlot = NULL;
    	partition_check = RelationGetPartitionQual(resultRelationDesc);
    	resultRelInfo->ri_PartitionCheck = partition_check;
    	resultRelInfo->ri_RootResultRelInfo = partition_root_rri;
    	resultRelInfo->ri_PartitionInfo = NULL; /* may be set later */
    	resultRelInfo->ri_CopyMultiInsertBuffer = NULL;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center 2]

### ExecInitNode函数 ###

`planstate = ExecInitNode(plan, estate, eflags)`为所有的计划节点初始化private状态信息数据结构

PlanState *ExecInitNode(Plan *node, EState *estate, int eflags){ 
    	PlanState  *result;
    	List	   *subps;
    	ListCell   *l;
    	/* do nothing when we get to the end of a leaf on tree. */
    	if (node == NULL)	return NULL;
    	/* Make sure there's enough stack available. Need to check here, in addition to ExecProcNode() (via ExecProcNodeFirst()), to ensure the stack isn't overrun while initializing the node tree. */
    	check_stack_depth();
    	switch (nodeTag(node)){ 
    			/* control nodes */
    		case T_Result:
    			result = (PlanState *) ExecInitResult((Result *) node, estate, eflags);
    			break;
    		case T_ProjectSet:
    			result = (PlanState *) ExecInitProjectSet((ProjectSet *) node, estate, eflags);
    			break;
    		case T_ModifyTable:
    			result = (PlanState *) ExecInitModifyTable((ModifyTable *) node, estate, eflags);
    			break;
    		case T_Append:
    			result = (PlanState *) ExecInitAppend((Append *) node, estate, eflags);
    			break;
    		case T_MergeAppend:
    			result = (PlanState *) ExecInitMergeAppend((MergeAppend *) node, estate, eflags);
    			break;
    		case T_RecursiveUnion:
    			result = (PlanState *) ExecInitRecursiveUnion((RecursiveUnion *) node, estate, eflags);
    			break;
    		case T_BitmapAnd:
    			result = (PlanState *) ExecInitBitmapAnd((BitmapAnd *) node, estate, eflags);
    			break;
    		case T_BitmapOr:
    			result = (PlanState *) ExecInitBitmapOr((BitmapOr *) node, estate, eflags);
    			break;
    			/* scan nodes */
    		case T_SeqScan:
    			result = (PlanState *) ExecInitSeqScan((SeqScan *) node, estate, eflags);
    			break;
    		case T_SampleScan:
    			result = (PlanState *) ExecInitSampleScan((SampleScan *) node, estate, eflags);
    			break;
    		case T_IndexScan:
    			result = (PlanState *) ExecInitIndexScan((IndexScan *) node, estate, eflags);
    			break;
    		case T_IndexOnlyScan:
    			result = (PlanState *) ExecInitIndexOnlyScan((IndexOnlyScan *) node, estate, eflags);
    			break;
    		case T_BitmapIndexScan:
    			result = (PlanState *) ExecInitBitmapIndexScan((BitmapIndexScan *) node, estate, eflags);
    			break;
    		case T_BitmapHeapScan:
    			result = (PlanState *) ExecInitBitmapHeapScan((BitmapHeapScan *) node, estate, eflags);
    			break;
    		case T_TidScan:
    			result = (PlanState *) ExecInitTidScan((TidScan *) node, estate, eflags);
    			break;
    		case T_SubqueryScan:
    			result = (PlanState *) ExecInitSubqueryScan((SubqueryScan *) node, estate, eflags);
    			break;
    		case T_FunctionScan:
    			result = (PlanState *) ExecInitFunctionScan((FunctionScan *) node, estate, eflags);
    			break;
    		case T_TableFuncScan:
    			result = (PlanState *) ExecInitTableFuncScan((TableFuncScan *) node, estate, eflags);
    			break;
    		case T_ValuesScan:
    			result = (PlanState *) ExecInitValuesScan((ValuesScan *) node, estate, eflags);
    			break;
    		case T_CteScan:
    			result = (PlanState *) ExecInitCteScan((CteScan *) node, estate, eflags);
    			break;
    		case T_NamedTuplestoreScan:
    			result = (PlanState *) ExecInitNamedTuplestoreScan((NamedTuplestoreScan *) node, estate, eflags);
    			break;
    		case T_WorkTableScan:
    			result = (PlanState *) ExecInitWorkTableScan((WorkTableScan *) node, estate, eflags);
    			break;
    		case T_ForeignScan:
    			result = (PlanState *) ExecInitForeignScan((ForeignScan *) node, estate, eflags);
    			break;
    		case T_CustomScan:
    			result = (PlanState *) ExecInitCustomScan((CustomScan *) node, estate, eflags);
    			break;
    			/* join nodes */
    		case T_NestLoop:
    			result = (PlanState *) ExecInitNestLoop((NestLoop *) node, estate, eflags);
    			break;
    		case T_MergeJoin:
    			result = (PlanState *) ExecInitMergeJoin((MergeJoin *) node, estate, eflags);
    			break
    		case T_HashJoin:
    			result = (PlanState *) ExecInitHashJoin((HashJoin *) node, estate, eflags);
    			break;
    			/* materialization nodes */
    		case T_Material:
    			result = (PlanState *) ExecInitMaterial((Material *) node, estate, eflags);
    			break;
    		case T_Sort:
    			result = (PlanState *) ExecInitSort((Sort *) node, estate, eflags);
    			break;
    		case T_Group:
    			result = (PlanState *) ExecInitGroup((Group *) node, estate, eflags);
    			break;
    		case T_Agg:
    			result = (PlanState *) ExecInitAgg((Agg *) node, estate, eflags);
    			break;
    		case T_WindowAgg:
    			result = (PlanState *) ExecInitWindowAgg((WindowAgg *) node, estate, eflags);
    			break;
    		case T_Unique:
    			result = (PlanState *) ExecInitUnique((Unique *) node, estate, eflags);
    			break;
    		case T_Gather:
    			result = (PlanState *) ExecInitGather((Gather *) node, estate, eflags);
    			break;
    		case T_GatherMerge:
    			result = (PlanState *) ExecInitGatherMerge((GatherMerge *) node, estate, eflags);
    			break;
    		case T_Hash:
    			result = (PlanState *) ExecInitHash((Hash *) node, estate, eflags);
    			break;
    		case T_SetOp:
    			result = (PlanState *) ExecInitSetOp((SetOp *) node, estate, eflags);
    			break;
    		case T_LockRows:
    			result = (PlanState *) ExecInitLockRows((LockRows *) node, estate, eflags);
    			break;
    		case T_Limit:
    			result = (PlanState *) ExecInitLimit((Limit *) node, estate, eflags);
    			break;
    		default:
    			elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
    			result = NULL;		/* keep compiler quiet */
    			break;
    	}
    	ExecSetExecProcNode(result, result->ExecProcNode);
    	/* Initialize any initPlans present in this node. The planner put them in a separate list for us. */
    	subps = NIL;
    	foreach(l, node->initPlan){ 
    		SubPlan    *subplan = (SubPlan *) lfirst(l);
    		SubPlanState *sstate;
    		Assert(IsA(subplan, SubPlan));
    		sstate = ExecInitSubPlan(subplan, result);
    		subps = lappend(subps, sstate);
    	}
    	result->initPlan = subps;
    	/* Set up instrumentation for this node if requested */
    	if (estate->es_instrument)
    		result->instrument = InstrAlloc(1, estate->es_instrument);
    	return result;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/a8abcff4bf384cac94997770c677ce4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221005/e1d896b4c2c04c5ea568f6d421b3d09c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221005/9ac79136d2304fb2826dcf34e32e97f2.png