本节简单介绍了PG查询优化对表达式预处理中连接Var(RTE中的Var,其中RTE_KIND=RTE_JOIN)溯源的过程。处理逻辑在主函数subquery_planner中通过调用flatten_join_alias_vars函数实现，该函数位于src/backend/optimizer/util/var.c文件中。

一、基本概念

连接Var溯源，意思是把连接产生的中间结果（中间结果也是Relation关系的一种）的投影替换为实际存在的关系的列（在PG中通过Var表示）。
如下面的SQL语句：

select a.*,b.grbh,b.je
from t_dwxx a,lateral (select t1.dwbh,t1.grbh,t2.je from t_grxx t1 inner join t_jfxx t2 on t1.dwbh = a.dwbh and t1.grbh = t2.grbh) b;

b与a连接运算,查询树Query中的投影b.grbh和b.je这两列如需依赖关系b(子查询产生的中间结果),则需要把中间关系的投影列替换为实际的Relation的投影列,即t_grxx和t_jfxx的数据列.

PG源码中的注释：

     /** If the query has any join RTEs, replace join alias variables with* base-relation variables.  We must do this first, since any expressions* we may extract from the joinaliasvars lists have not been preprocessed.* For example, if we did this after sublink processing, sublinks expanded* out from join aliases would not get processed.  But we can skip this in* non-lateral RTE functions, VALUES lists, and TABLESAMPLE clauses, since* they can't contain any Vars of the current query level.*/if (root->hasJoinRTEs &&!(kind == EXPRKIND_RTFUNC ||kind == EXPRKIND_VALUES ||kind == EXPRKIND_TABLESAMPLE ||kind == EXPRKIND_TABLEFUNC))expr = flatten_join_alias_vars(root, expr);

二、源码解读

flatten_join_alias_vars

/** flatten_join_alias_vars*    Replace Vars that reference JOIN outputs with references to the original*    relation variables instead.  This allows quals involving such vars to be*    pushed down.  Whole-row Vars that reference JOIN relations are expanded*    into RowExpr constructs that name the individual output Vars.  This*    is necessary since we will not scan the JOIN as a base relation, which*    is the only way that the executor can directly handle whole-row Vars.** This also adjusts relid sets found in some expression node types to* substitute the contained base rels for any join relid.** If a JOIN contains sub-selects that have been flattened, its join alias* entries might now be arbitrary expressions, not just Vars.  This affects* this function in one important way: we might find ourselves inserting* SubLink expressions into subqueries, and we must make sure that their* Query.hasSubLinks fields get set to true if so.  If there are any* SubLinks in the join alias lists, the outer Query should already have* hasSubLinks = true, so this is only relevant to un-flattened subqueries.** NOTE: this is used on not-yet-planned expressions.  We do not expect it* to be applied directly to the whole Query, so if we see a Query to start* with, we do want to increment sublevels_up (this occurs for LATERAL* subqueries).*/Node *flatten_join_alias_vars(PlannerInfo *root, Node *node){flatten_join_alias_vars_context context;context.root = root;context.sublevels_up = 0;/* flag whether join aliases could possibly contain SubLinks */context.possible_sublink = root->parse->hasSubLinks;/* if hasSubLinks is already true, no need to work hard */context.inserted_sublink = root->parse->hasSubLinks;//调用flatten_join_alias_vars_mutator处理Varsreturn flatten_join_alias_vars_mutator(node, &context);}static Node *flatten_join_alias_vars_mutator(Node *node,flatten_join_alias_vars_context *context){if (node == NULL)return NULL;if (IsA(node, Var))//Var类型{Var        *var = (Var *) node;RangeTblEntry *rte;Node       *newvar;/* No change unless Var belongs to a JOIN of the target level */if (var->varlevelsup != context->sublevels_up)return node;        /* no need to copy, really */rte = rt_fetch(var->varno, context->root->parse->rtable);if (rte->rtekind != RTE_JOIN)return node;//在rte->rtekind == RTE_JOIN时才需要处理if (var->varattno == InvalidAttrNumber){/* Must expand whole-row reference */RowExpr    *rowexpr;List       *fields = NIL;List       *colnames = NIL;AttrNumber  attnum;ListCell   *lv;ListCell   *ln;attnum = 0;Assert(list_length(rte->joinaliasvars) == list_length(rte->eref->colnames));forboth(lv, rte->joinaliasvars, ln, rte->eref->colnames){newvar = (Node *) lfirst(lv);attnum++;/* Ignore dropped columns */if (newvar == NULL)continue;newvar = copyObject(newvar);/** If we are expanding an alias carried down from an upper* query, must adjust its varlevelsup fields.*/if (context->sublevels_up != 0)IncrementVarSublevelsUp(newvar, context->sublevels_up, 0);/* Preserve original Var's location, if possible */if (IsA(newvar, Var))((Var *) newvar)->location = var->location;/* Recurse in case join input is itself a join *//* (also takes care of setting inserted_sublink if needed) */newvar = flatten_join_alias_vars_mutator(newvar, context);fields = lappend(fields, newvar);/* We need the names of non-dropped columns, too */colnames = lappend(colnames, copyObject((Node *) lfirst(ln)));}rowexpr = makeNode(RowExpr);rowexpr->args = fields;rowexpr->row_typeid = var->vartype;rowexpr->row_format = COERCE_IMPLICIT_CAST;rowexpr->colnames = colnames;rowexpr->location = var->location;return (Node *) rowexpr;}/* Expand join alias reference *///扩展join alias VarAssert(var->varattno > 0);newvar = (Node *) list_nth(rte->joinaliasvars, var->varattno - 1);Assert(newvar != NULL);newvar = copyObject(newvar);/** If we are expanding an alias carried down from an upper query, must* adjust its varlevelsup fields.*/if (context->sublevels_up != 0)IncrementVarSublevelsUp(newvar, context->sublevels_up, 0);/* Preserve original Var's location, if possible */if (IsA(newvar, Var))((Var *) newvar)->location = var->location;/* Recurse in case join input is itself a join */newvar = flatten_join_alias_vars_mutator(newvar, context);/* Detect if we are adding a sublink to query */if (context->possible_sublink && !context->inserted_sublink)context->inserted_sublink = checkExprHasSubLink(newvar);return newvar;}if (IsA(node, PlaceHolderVar))//占位符{/* Copy the PlaceHolderVar node with correct mutation of subnodes */PlaceHolderVar *phv;phv = (PlaceHolderVar *) expression_tree_mutator(node,flatten_join_alias_vars_mutator,(void *) context);/* now fix PlaceHolderVar's relid sets */if (phv->phlevelsup == context->sublevels_up){phv->phrels = alias_relid_set(context->root,phv->phrels);}return (Node *) phv;}if (IsA(node, Query))//查询树{/* Recurse into RTE subquery or not-yet-planned sublink subquery */Query      *newnode;bool        save_inserted_sublink;context->sublevels_up++;save_inserted_sublink = context->inserted_sublink;context->inserted_sublink = ((Query *) node)->hasSubLinks;newnode = query_tree_mutator((Query *) node,flatten_join_alias_vars_mutator,(void *) context,QTW_IGNORE_JOINALIASES);newnode->hasSubLinks |= context->inserted_sublink;context->inserted_sublink = save_inserted_sublink;context->sublevels_up--;return (Node *) newnode;}/* Already-planned tree not supported */Assert(!IsA(node, SubPlan));/* Shouldn't need to handle these planner auxiliary nodes here */Assert(!IsA(node, SpecialJoinInfo));Assert(!IsA(node, PlaceHolderInfo));Assert(!IsA(node, MinMaxAggInfo));//其他表达式return expression_tree_mutator(node, flatten_join_alias_vars_mutator,(void *) context);}

query_tree_mutator

 /** query_tree_mutator --- initiate modification of a Query's expressions** This routine exists just to reduce the number of places that need to know* where all the expression subtrees of a Query are.  Note it can be used* for starting a walk at top level of a Query regardless of whether the* mutator intends to descend into subqueries.  It is also useful for* descending into subqueries within a mutator.** Some callers want to suppress mutating of certain items in the Query,* typically because they need to process them specially, or don't actually* want to recurse into subqueries.  This is supported by the flags argument,* which is the bitwise OR of flag values to suppress mutating of* indicated items.  (More flag bits may be added as needed.)** Normally the Query node itself is copied, but some callers want it to be* modified in-place; they must pass QTW_DONT_COPY_QUERY in flags.  All* modified substructure is safely copied in any case.*/Query *query_tree_mutator(Query *query,Node *(*mutator) (),void *context,int flags)//遍历查询树{Assert(query != NULL && IsA(query, Query));if (!(flags & QTW_DONT_COPY_QUERY)){Query      *newquery;FLATCOPY(newquery, query, Query);query = newquery;}MUTATE(query->targetList, query->targetList, List *);//投影列MUTATE(query->withCheckOptions, query->withCheckOptions, List *);MUTATE(query->onConflict, query->onConflict, OnConflictExpr *);MUTATE(query->returningList, query->returningList, List *);MUTATE(query->jointree, query->jointree, FromExpr *);MUTATE(query->setOperations, query->setOperations, Node *);MUTATE(query->havingQual, query->havingQual, Node *);MUTATE(query->limitOffset, query->limitOffset, Node *);MUTATE(query->limitCount, query->limitCount, Node *);if (!(flags & QTW_IGNORE_CTE_SUBQUERIES))MUTATE(query->cteList, query->cteList, List *);else                        /* else copy CTE list as-is */query->cteList = copyObject(query->cteList);query->rtable = range_table_mutator(query->rtable,mutator, context, flags);//RTEreturn query;}

range_table_mutator

 /** range_table_mutator is just the part of query_tree_mutator that processes* a query's rangetable.  This is split out since it can be useful on* its own.*/List *range_table_mutator(List *rtable,Node *(*mutator) (),void *context,int flags){List       *newrt = NIL;ListCell   *rt;foreach(rt, rtable)//遍历RTE{RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);RangeTblEntry *newrte;FLATCOPY(newrte, rte, RangeTblEntry);switch (rte->rtekind){case RTE_RELATION:MUTATE(newrte->tablesample, rte->tablesample,TableSampleClause *);/* we don't bother to copy eref, aliases, etc; OK? */break;case RTE_CTE:case RTE_NAMEDTUPLESTORE:/* nothing to do */break;case RTE_SUBQUERY:if (!(flags & QTW_IGNORE_RT_SUBQUERIES)){CHECKFLATCOPY(newrte->subquery, rte->subquery, Query);MUTATE(newrte->subquery, newrte->subquery, Query *);//遍历处理子查询}else{/* else, copy RT subqueries as-is */newrte->subquery = copyObject(rte->subquery);}break;case RTE_JOIN://连接,遍历处理joinaliasvarsif (!(flags & QTW_IGNORE_JOINALIASES))MUTATE(newrte->joinaliasvars, rte->joinaliasvars, List *);else{/* else, copy join aliases as-is */newrte->joinaliasvars = copyObject(rte->joinaliasvars);}break;case RTE_FUNCTION:MUTATE(newrte->functions, rte->functions, List *);break;case RTE_TABLEFUNC:MUTATE(newrte->tablefunc, rte->tablefunc, TableFunc *);break;case RTE_VALUES:MUTATE(newrte->values_lists, rte->values_lists, List *);break;}MUTATE(newrte->securityQuals, rte->securityQuals, List *);newrt = lappend(newrt, newrte);}return newrt;}

三、跟踪分析

在PG11中,没有进入"Expand join alias reference"的实现逻辑,猜测在上拉子查询的时候已作优化.

四、小结

1、优化过程：介绍了通过遍历的方式实现joinaliasvars链表变量中的处理；
2、遍历处理：通过统一的遍历方式，改变XX_mutator函数对Node进行处理。