PostgreSQL数据库查询执行——控制节点Result

青旅半醒 2022-10-09 12:28 222阅读 0赞

![在这里插入图片描述][resize_m_lfit_w_962_pic_center]  
控制节点用于完成一些特殊的流程执行方式。由于PG为查询语句生成二叉树状的查询计划，其中大部分节点的执行过程需要两个以内的输入和一个输出。但有一些特殊的功能为了优化的需要，会含有特殊的执行方式和输入需求（例如需要两个以上的输入），这一类的节点被称为控制节点。Result节点类型处于nodeResult.c文件（src/backend/executor/nodeResult.c）中，处理含有**仅需一次计算的条件表达式**或**NSERT中仅有一个VALUES子句**。  
Result节点用于查询语句中没有扫描关系表的情况，当SELECT查询中没有FROM子句时或者INSERT语句只有一个VALUES子句时，执行查询计划不需要扫描表，执行器会直接计算SELECT的投影属性或者使用VALUES子句构造元组。比如：

1.  select 1 \* 2
2.  insert into emp values (‘mike’, 15000)

Result节点用于优化常量qualifications的查询，条件表达不依赖于扫描的数据，比如：  
select \* from emp where 2 > 1，其计划如下

Result	(with 2 > 1 qual)
    						/
    				   SeqScan (emp.*)

在运行时，结果节点计算常量表达式 一次，由 EXPLAIN 显示为一次性过滤器（One-Time Filter）。 如果它是假的，我们可以返回一个空的结果集，而根本不运行受控计划。 如果为真，我们正常运行受控计划并将结果传回。

## Result节点相关数据结构 ##

Result和ResultState：Result除了继承Plan节点的基本属性外，还扩展定义了resconstantqual字段（保存只需计算一次的常量表达式）。

## ExecInitResult函数 ##

ExecInitResult函数为resutl节点创建状态信息结构体，形参为指向Result节点的指针，QueryDesc结构体的estate指针成员和eflags标志。ExecInitResult函数会先初始化ResultState结构，通过判断Result节点的resconstantqual字段来判断是否有常量表达式，来判断是否设置rs\_checkqual字段以标记是否需要计算常量表达式。Result初始化过程在计划节点的标准初始化过程之外增加了几项检查：保证无右子节点；检查是否有常量表达式，有则将执行状态节点的rs\_checkqual设置为真，否则设置为假。

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); // 通过CreateExprContext函数为Result节点创建表达式上下文
    	/* 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, &TTSOpsVirtual);
    	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;
    }

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

## ExecResult函数 ##

在ExecResult中，首先判断rs\_check->qual是否为真，为真表示需要进行常量表达式计算，计算完成后将rs\_checkqual设置为假，下次执行不会再进行计算。如果表达式计算结果为假，表示没有满足条件的结果，则Result节点直接返回NULL。若表达式计算结果为真，则会检查是否有左子树，有则从其中获取元组；没有左子树表示为VALUES子句，则直接设置rs\_done为真，因为只有一个元组需要输出（这里的VALUES子句中只允许有一个元组）。最后**对结果元组执行投影操作**并返回TupleTableSlot结构体指针。

static TupleTableSlot *ExecResult(PlanState *pstate) { 
    	ResultState *node = castNode(ResultState, pstate);
    	TupleTableSlot *outerTupleSlot;
    	PlanState  *outerPlan;
    	ExprContext *econtext;
    	CHECK_FOR_INTERRUPTS();
    	econtext = node->ps.ps_ExprContext;
    	/* check constant qualifications like (2 > 1), if not already done */
    	if (node->rs_checkqual) { 
    		bool		qualResult = ExecQual(node->resconstantqual, econtext);
    		node->rs_checkqual = false;
    		if (!qualResult) { 
    			node->rs_done = true;
    			return NULL;
    		}
    	}
    	/* Reset per-tuple memory context to free any expression evaluation storage allocated in the previous tuple cycle. */
    	ResetExprContext(econtext);
    	/* if rs_done is true then it means that we were asked to return a constant tuple and we already did the last time ExecResult() was called, OR that we failed the constant qual check. Either way, now we are through. */
    	while (!node->rs_done){ 
    		outerPlan = outerPlanState(node);
    		if (outerPlan != NULL){ 
    			/* retrieve tuples from the outer plan until there are no more. */
    			outerTupleSlot = ExecProcNode(outerPlan);
    			if (TupIsNull(outerTupleSlot))
    				return NULL;
    			/* prepare to compute projection expressions, which will expect to access the input tuples as varno OUTER. */
    			econtext->ecxt_outertuple = outerTupleSlot;
    		}else{ 
    			/* if we don't have an outer plan, then we are just generating the results from a constant target list. Do it only once. */
    			node->rs_done = true;
    		}
    		/* form the result tuple using ExecProject(), and return it */
    		return ExecProject(node->ps.ps_ProjInfo);
    	}
    	return NULL;
    }

## ExecReScanResult函数 ##

void ExecReScanResult(ResultState *node) { 
    	node->rs_done = false;
    	node->rs_checkqual = (node->resconstantqual == NULL) ? false : true;
    	/* If chgParam of subnode is not null then plan will be re-scanned by first ExecProcNode. */
    	if (node->ps.lefttree && node->ps.lefttree->chgParam == NULL)
    		ExecReScan(node->ps.lefttree);
    }

## ExecEndResult函数 ##

ExecEndResult函数一次释放exprcontext内存、清除tuple table、关闭subplans。

void ExecEndResult(ResultState *node) { 
    	/* Free the exprcontext */
    	ExecFreeExprContext(&node->ps);
    	/* clean out the tuple table */
    	ExecClearTuple(node->ps.ps_ResultTupleSlot);
    	/* shut down subplans */
    	ExecEndNode(outerPlanState(node));
    }

[resize_m_lfit_w_962_pic_center]: /images/20221005/6fd4879148c94943a5ff4a93cd4b175d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FzbWFydGtpbGxlcg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/1dcc4573991d4d08a1f6e87d3182c499.png