/*------------------------------------------------------------------------- * * setrefs . c * Post - processing of a completed plan tree : fix references to subplan * vars , compute regproc values for operators , etc * * Portions Copyright ( c ) 1996 - 2025 , PostgreSQL Global Development Group * Portions Copyright ( c ) 1994 , Regents of the University of California * * * IDENTIFICATION * src / backend / optimizer / plan / setrefs . c * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "postgres.h" #include "access/transam.h" #include "catalog/pg_type.h" #include "nodes/makefuncs.h" #include "nodes/nodeFuncs.h" #include "optimizer/optimizer.h" #include "optimizer/pathnode.h" #include "optimizer/planmain.h" #include "optimizer/planner.h" #include "optimizer/subselect.h" #include "optimizer/tlist.h" #include "parser/parse_relation.h" #include "rewrite/rewriteManip.h" #include "tcop/utility.h" #include "utils/syscache.h" typedef enum /* expect exact match of nullingrels */ /* actual Var may have a subset of input */ /* actual Var may have a superset of input */ typedef struct int varno; /* RT index of Var */ /* attr number of Var */ /* TLE position of Var */ /* Var's varnullingrels */ typedef struct /* underlying target list */ int num_vars; /* number of plain Var tlist entries */ bool has_ph_vars; /* are there PlaceHolderVar entries? */ bool has_non_vars; /* are there other entries? */ /* has num_vars entries */ typedef struct int rtoffset;double num_exec;typedef struct int rtoffset;double num_exec;typedef struct int newvarno;int rtoffset;double num_exec;typedef struct int newvarno;/* Context info for flatten_rtes_walker() */ typedef struct /* * Selecting the best alternative in an AlternativeSubPlan expression requires * estimating how many times that expression will be evaluated . For an * expression in a plan node ' s targetlist , the plan ' s estimated number of * output rows is clearly what to use , but for an expression in a qual it ' s * far less clear . Since AlternativeSubPlans aren ' t heavily used , we don ' t * want to expend a lot of cycles making such estimates . What we use is twice * the number of output rows . That ' s not entirely unfounded : we know that * clause_selectivity ( ) would fall back to a default selectivity estimate * of 0 . 5 for any SubPlan , so if the qual containing the SubPlan is the last * to be applied ( which it likely would be , thanks to order_qual_clauses ( ) ) , * this matches what we could have estimated in a far more laborious fashion . * Obviously there are many other scenarios , but it ' s probably not worth the * trouble to try to improve on this estimate , especially not when we don ' t * have a better estimate for the selectivity of the SubPlan qual itself . #define NUM_EXEC_TLIST(parentplan) ((parentplan)->plan_rows)#define NUM_EXEC_QUAL(parentplan) ((parentplan)->plan_rows * 2 .0 )/* * Check if a Const node is a regclass value . We accept plain OID too , * since a regclass Const will get folded to that type if it ' s an argument * to oideq or similar operators . ( This might result in some extraneous * values in a plan ' s list of relation dependencies , but the worst result * would be occasional useless replans . ) #define ISREGCLASSCONST(con) \#define fix_scan_list(root, lst, rtoffset, num_exec) \static void add_rtes_to_flat_rtable(PlannerInfo *root, bool recursing);static void flatten_unplanned_rtes(PlannerGlobal *glob, RangeTblEntry *rte);static bool flatten_rtes_walker(Node *node, flatten_rtes_walker_context *cxt);static void add_rte_to_flat_rtable(PlannerGlobal *glob, List *rteperminfos,static Plan *set_plan_refs(PlannerInfo *root, Plan *plan, int rtoffset);static Plan *set_indexonlyscan_references(PlannerInfo *root,int rtoffset);static Plan *set_subqueryscan_references(PlannerInfo *root,int rtoffset);static Plan *clean_up_removed_plan_level(Plan *parent, Plan *child);static void set_foreignscan_references(PlannerInfo *root,int rtoffset);static void set_customscan_references(PlannerInfo *root,int rtoffset);static Plan *set_append_references(PlannerInfo *root,int rtoffset);static Plan *set_mergeappend_references(PlannerInfo *root,int rtoffset);static void set_hash_references(PlannerInfo *root, Plan *plan, int rtoffset);static Relids offset_relid_set(Relids relids, int rtoffset);static Node *fix_scan_expr(PlannerInfo *root, Node *node,int rtoffset, double num_exec);static Node *fix_scan_expr_mutator(Node *node, fix_scan_expr_context *context);static bool fix_scan_expr_walker(Node *node, fix_scan_expr_context *context);static void set_join_references(PlannerInfo *root, Join *join, int rtoffset);static void set_upper_references(PlannerInfo *root, Plan *plan, int rtoffset);static void set_param_references(PlannerInfo *root, Plan *plan);static Node *convert_combining_aggrefs(Node *node, void *context);static void set_dummy_tlist_references(Plan *plan, int rtoffset);static indexed_tlist *build_tlist_index(List *tlist);static Var *search_indexed_tlist_for_var(Var *var,int newvarno,int rtoffset,static Var *search_indexed_tlist_for_phv(PlaceHolderVar *phv,int newvarno,static Var *search_indexed_tlist_for_non_var(Expr *node,int newvarno);static Var *search_indexed_tlist_for_sortgroupref(Expr *node,int newvarno);static List *fix_join_expr(PlannerInfo *root,int rtoffset,double num_exec);static Node *fix_join_expr_mutator(Node *node,static Node *fix_upper_expr(PlannerInfo *root,int newvarno,int rtoffset,double num_exec);static Node *fix_upper_expr_mutator(Node *node,static List *set_returning_clause_references(PlannerInfo *root,int rtoffset);static List *set_windowagg_runcondition_references(PlannerInfo *root,/***************************************************************************** * * SUBPLAN REFERENCES * /* * set_plan_references * * This is the final processing pass of the planner / optimizer . The plan * tree is complete ; we just have to adjust some representational details * for the convenience of the executor : * * 1 . We flatten the various subquery rangetables into a single list , and * zero out RangeTblEntry fields that are not useful to the executor . * * 2 . We adjust Vars in scan nodes to be consistent with the flat rangetable . * * 3 . We adjust Vars in upper plan nodes to refer to the outputs of their * subplans . * * 4 . Aggrefs in Agg plan nodes need to be adjusted in some cases involving * partial aggregation or minmax aggregate optimization . * * 5 . PARAM_MULTIEXPR Params are replaced by regular PARAM_EXEC Params , * now that we have finished planning all MULTIEXPR subplans . * * 6 . AlternativeSubPlan expressions are replaced by just one of their * alternatives , using an estimate of how many times they ' ll be executed . * * 7 . We compute regproc OIDs for operators ( ie , we look up the function * that implements each op ) . * * 8 . We create lists of specific objects that the plan depends on . * This will be used by plancache . c to drive invalidation of cached plans . * Relation dependencies are represented by OIDs , and everything else by * PlanInvalItems ( this distinction is motivated by the shared - inval APIs ) . * Currently , relations , user - defined functions , and domains are the only * types of objects that are explicitly tracked this way . * * 9 . We assign every plan node in the tree a unique ID . * * We also perform one final optimization step , which is to delete * SubqueryScan , Append , and MergeAppend plan nodes that aren ' t doing * anything useful . The reason for doing this last is that * it can ' t readily be done before set_plan_references , because it would * break set_upper_references : the Vars in the child plan ' s top tlist * wouldn ' t match up with the Vars in the outer plan tree . A SubqueryScan * serves a necessary function as a buffer between outer query and subquery * variable numbering . . . but after we ' ve flattened the rangetable this is * no longer a problem , since then there ' s only one rtindex namespace . * Likewise , Append and MergeAppend buffer between the parent and child vars * of an appendrel , but we don ' t need to worry about that once we ' ve done * set_plan_references . * * set_plan_references recursively traverses the whole plan tree . * * The return value is normally the same Plan node passed in , but can be * different when the passed - in Plan is a node we decide isn ' t needed . * * The flattened rangetable entries are appended to root - > glob - > finalrtable . * Also , rowmarks entries are appended to root - > glob - > finalrowmarks , and the * RT indexes of ModifyTable result relations to root - > glob - > resultRelations , * and flattened AppendRelInfos are appended to root - > glob - > appendRelations . * Plan dependencies are appended to root - > glob - > relationOids ( for relations ) * and root - > glob - > invalItems ( for everything else ) . * * Notice that we modify Plan nodes in - place , but use expression_tree_mutator * to process targetlist and qual expressions . We can assume that the Plan * nodes were just built by the planner and are not multiply referenced , but * it ' s not so safe to assume that for expression tree nodes . int rtoffset = list_length(glob->finalrtable);/* * Add all the query ' s RTEs to the flattened rangetable . The live ones * will have their rangetable indexes increased by rtoffset . ( Additional * RTEs , not referenced by the Plan tree , might get added after those . ) false );/* * Adjust RT indexes of PlanRowMarks and add to final rowmarks list /* sanity check on existing row marks */ /* flat copy is enough since all fields are scalars */ sizeof (PlanRowMark));sizeof (PlanRowMark));/* adjust indexes ... but *not* the rowmarkId */ /* * Adjust RT indexes of AppendRelInfos and add to final appendrels list . * We assume the AppendRelInfos were built during planning and don ' t need * to be copied . /* adjust RT indexes */ /* * Rather than adjust the translated_vars entries , just drop ' em . * Neither the executor nor EXPLAIN currently need that data . /* If needed, create workspace for processing AlternativeSubPlans */ if (root->hasAlternativeSubPlans)bool *)sizeof (bool ));bool *)sizeof (bool ));/* Now fix the Plan tree */ /* * If we have AlternativeSubPlans , it is likely that we now have some * unreferenced subplans in glob - > subplans . To avoid expending cycles on * those subplans later , get rid of them by setting those list entries to * NULL . ( Note : we can ' t do this immediately upon processing an * AlternativeSubPlan , because there may be multiple copies of the * AlternativeSubPlan , and they can get resolved differently . ) if (root->hasAlternativeSubPlans)int ndx = foreach_current_index(lc);/* * If it was used by some AlternativeSubPlan in this query level , * but wasn ' t selected as best by any AlternativeSubPlan , then we * don ' t need it . Do not touch subplans that aren ' t parts of * AlternativeSubPlans . if (root->isAltSubplan[ndx] && !root->isUsedSubplan[ndx])return result;/* * Extract RangeTblEntries from the plan ' s rangetable , and add to flat rtable * * This can recurse into subquery plans ; " recursing " is true if so . * * This also seems like a good place to add the query ' s RTEPermissionInfos to * the flat rteperminfos . static void bool recursing)/* * Add the query ' s own RTEs to the flattened rangetable . * * At top level , we must add all RTEs so that their indexes in the * flattened rangetable match up with their original indexes . When * recursing , we only care about extracting relation RTEs ( and subquery * RTEs that were once relation RTEs ) . if (!recursing || rte->rtekind == RTE_RELATION ||/* * If there are any dead subqueries , they are not referenced in the Plan * tree , so we must add RTEs contained in them to the flattened rtable * separately . ( If we failed to do this , the executor would not perform * expected permission checks for tables mentioned in such subqueries . ) * * Note : this pass over the rangetable can ' t be combined with the previous * one , because that would mess up the numbering of the live RTEs in the * flattened rangetable . 1 ;/* * We should ignore inheritance - parent RTEs : their contents have been * pulled up into our rangetable already . Also ignore any subquery * RTEs without matching RelOptInfos , as they likewise have been * pulled up . if (rte->rtekind == RTE_SUBQUERY && !rte->inh &&if (rel != NULL)/* sanity check on array */ /* * The subquery might never have been planned at all , if it * was excluded on the basis of self - contradictory constraints * in our query level . In this case apply * flatten_unplanned_rtes . * * If it was planned but the result rel is dummy , we assume * that it has been omitted from our plan tree ( see * set_subquery_pathlist ) , and recurse to pull up its RTEs . * * Otherwise , it should be represented by a SubqueryScan node * somewhere in our plan tree , and we ' ll pull up its RTEs when * we process that plan node . * * However , if we ' re recursing , then we should pull up RTEs * whether the subquery is dummy or not , because we ' ve found * that some upper query level is treating this one as dummy , * and so we won ' t scan this level ' s plan tree at all . if (rel->subroot == NULL)else if (recursing ||true );/* * Extract RangeTblEntries from a subquery that was never planned at all static void /* Use query_tree_walker to find all RTEs in the parse tree */ void ) query_tree_walker(rte->subquery,static bool if (node == NULL)return false ;if (IsA(node, RangeTblEntry))/* As above, we need only save relation RTEs and former relations */ if (rte->rtekind == RTE_RELATION ||return false ;if (IsA(node, Query))/* * Recurse into subselects . Must update cxt - > query to this query so * that the rtable and rteperminfos correspond with each other . bool result;return result;return expression_tree_walker(node, flatten_rtes_walker, cxt);/* * Add ( a copy of ) the given RTE to the final rangetable and also the * corresponding RTEPermissionInfo , if any , to final rteperminfos . * * In the flat rangetable , we zero out substructure pointers that are not * needed by the executor ; this reduces the storage space and copying cost * for cached plans . We keep only the ctename , alias , eref Alias fields , * which are needed by EXPLAIN , and perminfoindex which is needed by the * executor to fetch the RTE ' s RTEPermissionInfo . static void /* flat copy to duplicate all the scalar fields */ sizeof (RangeTblEntry));sizeof (RangeTblEntry));/* zap unneeded sub-structure */ /* * If it ' s a plain relation RTE ( or a subquery that was once a view * reference ) , add the relation OID to relationOids . Also add its new RT * index to the set of relations to be potentially accessed during * execution . * * We do this even though the RTE might be unreferenced in the plan tree ; * this would correspond to cases such as views that were expanded , child * tables that were eliminated by constraint exclusion , etc . Schema * invalidation on such a rel must still force rebuilding of the plan . * * Note we don ' t bother to avoid making duplicate list entries . We could , * but it would probably cost more cycles than it would save . if (newrte->rtekind == RTE_RELATION ||/* * Add a copy of the RTEPermissionInfo , if any , corresponding to this RTE * to the flattened global list . if (rte->perminfoindex > 0 )/* Get the existing one from this query's rteperminfos. */ /* * Add a new one to finalrteperminfos and copy the contents of the * existing one into it . Note that addRTEPermissionInfo ( ) also * updates newrte - > perminfoindex to point to newperminfo in * finalrteperminfos . 0 ; /* expected by addRTEPermissionInfo() */ sizeof (RTEPermissionInfo));/* * set_plan_refs : recurse through the Plan nodes of a single subquery level static Plan *int rtoffset)if (plan == NULL)return NULL;/* Assign this node a unique ID. */ /* * Plan - type - specific fixes switch (nodeTag(plan))case T_SeqScan:break ;case T_SampleScan:1 );break ;case T_IndexScan:1 );1 );break ;case T_IndexOnlyScan:return set_indexonlyscan_references(root, splan, rtoffset);break ;case T_BitmapIndexScan:/* no need to fix targetlist and qual */ 1 );break ;case T_BitmapHeapScan:break ;case T_TidScan:1 );break ;case T_TidRangeScan:1 );break ;case T_SubqueryScan:/* Needs special treatment, see comments below */ return set_subqueryscan_references(root,case T_FunctionScan:1 );break ;case T_TableFuncScan:1 );break ;case T_ValuesScan:1 );break ;case T_CteScan:break ;case T_NamedTuplestoreScan:break ;case T_WorkTableScan:break ;case T_ForeignScan:break ;case T_CustomScan:break ;case T_NestLoop:case T_MergeJoin:case T_HashJoin:break ;case T_Gather:case T_GatherMerge:break ;case T_Hash:break ;case T_Memoize:/* * Memoize does not evaluate its targetlist . It just uses the * same targetlist from its outer subnode . break ;case T_Material:case T_Sort:case T_IncrementalSort:case T_Unique:case T_SetOp:/* * These plan types don ' t actually bother to evaluate their * targetlists , because they just return their unmodified input * tuples . Even though the targetlist won ' t be used by the * executor , we fix it up for possible use by EXPLAIN ( not to * mention ease of debugging - - - wrong varnos are very confusing ) . /* * Since these plan types don ' t check quals either , we should not * find any qual expression attached to them . break ;case T_LockRows:/* * Like the plan types above , LockRows doesn ' t evaluate its * tlist or quals . But we have to fix up the RT indexes in * its rowmarks . break ;case T_Limit:/* * Like the plan types above , Limit doesn ' t evaluate its tlist * or quals . It does have live expressions for limit / offset , * however ; and those cannot contain subplan variable refs , so * fix_scan_expr works for them . 1 );1 );break ;case T_Agg:/* * If this node is combining partial - aggregation results , we * must convert its Aggrefs to contain references to the * partial - aggregate subexpressions that will be available * from the child plan node . if (DO_AGGSPLIT_COMBINE(agg->aggsplit))break ;case T_Group:break ;case T_WindowAgg:/* * Adjust the WindowAgg ' s run conditions by swapping the * WindowFuncs references out to instead reference the Var in * the scan slot so that when the executor evaluates the * runCondition , it receives the WindowFunc ' s value from the * slot that the result has just been stored into rather than * evaluating the WindowFunc all over again . /* * Like Limit node limit / offset expressions , WindowAgg has * frame offset expressions , which cannot contain subplan * variable refs , so fix_scan_expr works for them . 1 );1 );break ;case T_Result:/* * Result may or may not have a subplan ; if not , it ' s more * like a scan node than an upper node . if (splan->plan.lefttree != NULL)else /* * The tlist of a childless Result could contain * unresolved ROWID_VAR Vars , in case it ' s representing a * target relation which is completely empty because of * constraint exclusion . Replace any such Vars by null * constants , as though they ' d been resolved for a leaf * scan node that doesn ' t support them . We could have * fix_scan_expr do this , but since the case is only * expected to occur here , it seems safer to special - case * it here and keep the assertions that ROWID_VARs * shouldn ' t be seen by fix_scan_expr . if (var && IsA(var, Var) && var->varno == ROWID_VAR)/* resconstantqual can't contain any subplan variable refs */ 1 );break ;case T_ProjectSet:break ;case T_ModifyTable:1 );if (splan->returningLists)/* * Pass each per - resultrel returningList through * set_returning_clause_references ( ) . /* * Set up the visible plan targetlist as being the same as * the first RETURNING list . This is mostly for the use * of EXPLAIN ; the executor won ' t execute that targetlist , * although it does use it to prepare the node ' s result * tuple slot . We postpone this step until here so that * we don ' t have to do set_returning_clause_references ( ) * twice on identical targetlists . /* * We treat ModifyTable with ON CONFLICT as a form of ' pseudo * join ' , where the inner side is the EXCLUDED tuple . * Therefore use fix_join_expr to setup the relevant variables * to INNER_VAR . We explicitly don ' t create any OUTER_VARs as * those are already used by RETURNING and it seems better to * be non - conflicting . if (splan->onConflictSet)1 );/* * The MERGE statement produces the target rows by performing * a right join between the target relation and the source * relation ( which could be a plain relation or a subquery ) . * The INSERT and UPDATE actions of the MERGE statement * require access to the columns from the source relation . We * arrange things so that the source relation attributes are * available as INNER_VAR and the target relation attributes * are available from the scan tuple . if (splan->mergeActionLists != NIL)/* * Fix the targetList of individual action nodes so that * the so - called " source relation " Vars are referenced as * INNER_VAR . Note that for this to work correctly during * execution , the ecxt_innertuple must be set to the tuple * obtained by executing the subplan , which is what * constitutes the " source relation " . * * We leave the Vars from the result relation ( i . e . the * target relation ) unchanged i . e . those Vars would be * picked from the scan slot . So during execution , we must * ensure that ecxt_scantuple is setup correctly to refer * to the tuple from the target relation . /* Fix targetList of each action. */ /* Fix quals too. */ /* Fix join condition too. */ if (splan->rootRelation)/* * Append this ModifyTable node ' s final result relation RT * index ( es ) to the global list for the plan . if (splan->rootRelation)break ;case T_Append:/* Needs special treatment, see comments below */ return set_append_references(root,case T_MergeAppend:/* Needs special treatment, see comments below */ return set_mergeappend_references(root,case T_RecursiveUnion:/* This doesn't evaluate targetlist or check quals either */ break ;case T_BitmapAnd:/* BitmapAnd works like Append, but has no tlist */ break ;case T_BitmapOr:/* BitmapOr works like Append, but has no tlist */ break ;default :"unrecognized node type: %d" ,int ) nodeTag(plan));break ;/* * Now recurse into child plans , if any * * NOTE : it is essential that we recurse into child plans AFTER we set * subplan references in this plan ' s tlist and quals . If we did the * reference - adjustments bottom - up , then we would fail to match this * plan ' s var nodes against the already - modified nodes of the children . return plan;/* * set_indexonlyscan_references * Do set_plan_references processing on an IndexOnlyScan * * This is unlike the handling of a plain IndexScan because we have to * convert Vars referencing the heap into Vars referencing the index . * We can use the fix_upper_expr machinery for that , by working from a * targetlist describing the index columns . static Plan *int rtoffset)/* * Vars in the plan node ' s targetlist , qual , and recheckqual must only * reference columns that the index AM can actually return . To ensure * this , remove non - returnable columns ( which are marked as resjunk ) from * the indexed tlist . We can just drop them because the indexed_tlist * machinery pays attention to TLE resnos , not physical list position . if (!indextle->resjunk)/* indexqual is already transformed to reference index columns */ 1 );/* indexorderby is already transformed to reference index columns */ 1 );/* indextlist must NOT be transformed to reference index columns */ return (Plan *) plan;/* * set_subqueryscan_references * Do set_plan_references processing on a SubqueryScan * * We try to strip out the SubqueryScan entirely ; if we can ' t , we have * to do the normal processing on it . static Plan *int rtoffset)/* Need to look up the subquery's RelOptInfo, since we need its subroot */ /* Recursively process the subplan */ if (trivial_subqueryscan(plan))/* * We can omit the SubqueryScan node and just pull up the subplan . else /* * Keep the SubqueryScan node . We have to do the processing that * set_plan_references would otherwise have done on it . Notice we do * not do set_upper_references ( ) here , because a SubqueryScan will * always have been created with correct references to its subplan ' s * outputs to begin with . return result;/* * trivial_subqueryscan * Detect whether a SubqueryScan can be deleted from the plan tree . * * We can delete it if it has no qual to check and the targetlist just * regurgitates the output of the child plan . * * This can be called from mark_async_capable_plan ( ) , a helper function for * create_append_plan ( ) , before set_subqueryscan_references ( ) , to determine * triviality of a SubqueryScan that is a child of an Append node . So we * cache the result in the SubqueryScan node to avoid repeated computation . * * Note : when called from mark_async_capable_plan ( ) , we determine the result * before running finalize_plan ( ) on the SubqueryScan node ( if needed ) and * set_plan_references ( ) on the subplan tree , but this would be safe , because * 1 ) finalize_plan ( ) doesn ' t modify the tlist or quals for the SubqueryScan * node ( or that for any plan node in the subplan tree ) , and * 2 ) set_plan_references ( ) modifies the tlist for every plan node in the * subplan tree , but keeps const / resjunk columns as const / resjunk ones and * preserves the length and order of the tlist , and * 3 ) set_plan_references ( ) might delete the topmost plan node like an Append * or MergeAppend from the subplan tree and pull up the child plan node , * but in that case , the tlist for the child plan node exactly matches the * parent . bool int attrno;/* We might have detected this already; in which case reuse the result */ if (plan->scanstatus == SUBQUERY_SCAN_TRIVIAL)return true ;if (plan->scanstatus == SUBQUERY_SCAN_NONTRIVIAL)return false ;/* Initially, mark the SubqueryScan as non-deletable from the plan tree */ if (plan->scan.plan.qual != NIL)return false ;if (list_length(plan->scan.plan.targetlist) !=return false ; /* tlists not same length */ 1 ;if (ptle->resjunk != ctle->resjunk)return false ; /* tlist doesn't match junk status */ /* * We accept either a Var referencing the corresponding element of the * subplan tlist , or a Const equaling the subplan element . See * generate_setop_tlist ( ) for motivation . if (ptle->expr && IsA(ptle->expr, Var))0 );if (var->varattno != attrno)return false ; /* out of order */ else if (ptle->expr && IsA(ptle->expr, Const ))if (!equal(ptle->expr, ctle->expr))return false ;else return false ;/* Re-mark the SubqueryScan as deletable from the plan tree */ return true ;/* * clean_up_removed_plan_level * Do necessary cleanup when we strip out a SubqueryScan , Append , etc * * We are dropping the " parent " plan in favor of returning just its " child " . * A few small tweaks are needed . static Plan */* * We have to be sure we don ' t lose any initplans , so move any that were * attached to the parent plan to the child . If any are parallel - unsafe , * the child is no longer parallel - safe . As a cosmetic matter , also add * the initplans ' run costs to the child ' s costs . if (parent->initPlan)bool unsafe_initplans;if (unsafe_initplans)false ;/* * Attach plans this way so that parent ' s initplans are processed * before any pre - existing initplans of the child . Probably doesn ' t * matter , but let ' s preserve the ordering just in case . /* * We also have to transfer the parent ' s column labeling info into the * child , else columns sent to client will be improperly labeled if this * is the topmost plan level . resjunk and so on may be important too . return child;/* * set_foreignscan_references * Do set_plan_references processing on a ForeignScan static void int rtoffset)/* Adjust scanrelid if it's valid */ if (fscan->scan.scanrelid > 0 )if (fscan->fdw_scan_tlist != NIL || fscan->scan.scanrelid == 0 )/* * Adjust tlist , qual , fdw_exprs , fdw_recheck_quals to reference * foreign scan tuple /* fdw_scan_tlist itself just needs fix_scan_list() adjustments */ else /* * Adjust tlist , qual , fdw_exprs , fdw_recheck_quals in the standard * way /* Adjust resultRelation if it's valid */ if (fscan->resultRelation > 0 )/* * set_customscan_references * Do set_plan_references processing on a CustomScan static void int rtoffset)/* Adjust scanrelid if it's valid */ if (cscan->scan.scanrelid > 0 )if (cscan->custom_scan_tlist != NIL || cscan->scan.scanrelid == 0 )/* Adjust tlist, qual, custom_exprs to reference custom scan tuple */ /* custom_scan_tlist itself just needs fix_scan_list() adjustments */ else /* Adjust tlist, qual, custom_exprs in the standard way */ /* Adjust child plan-nodes recursively, if needed */ /* * register_partpruneinfo * Subroutine for set_append_references and set_mergeappend_references * * Add the PartitionPruneInfo from root - > partPruneInfos at the given index * into PlannerGlobal - > partPruneInfos and return its index there . * * Also update the RT indexes present in PartitionedRelPruneInfos to add the * offset . * * Finally , if there are initial pruning steps , add the RT indexes of the * leaf partitions to the set of relations that are prunable at execution * startup time . static int int part_prune_index, int rtoffset)0 &&int i;1 );1 );for (i = 0 ; i < prelinfo->nparts; i++)/* * Non - leaf partitions and partitions that do not have a * subplan are not included in this map as mentioned in * make_partitionedrel_pruneinfo ( ) . if (prelinfo->leafpart_rti_map[i])if (prelinfo->initial_pruning_steps)return list_length(glob->partPruneInfos) - 1 ;/* * set_append_references * Do set_plan_references processing on an Append * * We try to strip out the Append entirely ; if we can ' t , we have * to do the normal processing on it . static Plan *int rtoffset)/* * Append , like Sort et al , doesn ' t actually evaluate its targetlist or * check quals . If it ' s got exactly one child plan , then it ' s not doing * anything useful at all , and we can strip it out . /* First, we gotta recurse on the children */ /* * See if it ' s safe to get rid of the Append entirely . For this to be * safe , there must be only one child plan and that child plan ' s parallel * awareness must match the Append ' s . The reason for the latter is that * if the Append is parallel aware and the child is not , then the calling * plan may execute the non - parallel aware child multiple times . ( If you * change these rules , update create_append_path to match . ) if (list_length(aplan->appendplans) == 1 )if (p->parallel_aware == aplan->plan.parallel_aware)return clean_up_removed_plan_level((Plan *) aplan, p);/* * Otherwise , clean up the Append as needed . It ' s okay to do this after * recursing to the children , because set_dummy_tlist_references doesn ' t * look at those . /* * Add PartitionPruneInfo , if any , to PlannerGlobal and update the index . * Also update the RT indexes present in it to add the offset . if (aplan->part_prune_index >= 0 )/* We don't need to recurse to lefttree or righttree ... */ return (Plan *) aplan;/* * set_mergeappend_references * Do set_plan_references processing on a MergeAppend * * We try to strip out the MergeAppend entirely ; if we can ' t , we have * to do the normal processing on it . static Plan *int rtoffset)/* * MergeAppend , like Sort et al , doesn ' t actually evaluate its targetlist * or check quals . If it ' s got exactly one child plan , then it ' s not * doing anything useful at all , and we can strip it out . /* First, we gotta recurse on the children */ /* * See if it ' s safe to get rid of the MergeAppend entirely . For this to * be safe , there must be only one child plan and that child plan ' s * parallel awareness must match the MergeAppend ' s . The reason for the * latter is that if the MergeAppend is parallel aware and the child is * not , then the calling plan may execute the non - parallel aware child * multiple times . ( If you change these rules , update * create_merge_append_path to match . ) if (list_length(mplan->mergeplans) == 1 )if (p->parallel_aware == mplan->plan.parallel_aware)return clean_up_removed_plan_level((Plan *) mplan, p);/* * Otherwise , clean up the MergeAppend as needed . It ' s okay to do this * after recursing to the children , because set_dummy_tlist_references * doesn ' t look at those . /* * Add PartitionPruneInfo , if any , to PlannerGlobal and update the index . * Also update the RT indexes present in it to add the offset . if (mplan->part_prune_index >= 0 )/* We don't need to recurse to lefttree or righttree ... */ return (Plan *) mplan;/* * set_hash_references * Do set_plan_references processing on a Hash node static void int rtoffset)/* * Hash ' s hashkeys are used when feeding tuples into the hashtable , * therefore have them reference Hash ' s outer plan ( which itself is the * inner plan of the HashJoin ) . /* Hash doesn't project */ /* Hash nodes don't have their own quals */ /* * offset_relid_set * Apply rtoffset to the members of a Relids set . static Relidsint rtoffset)int rtindex;/* If there's no offset to apply, we needn't recompute the value */ if (rtoffset == 0 )return relids;1 ;while ((rtindex = bms_next_member(relids, rtindex)) >= 0 )return result;/* * copyVar * Copy a Var node . * * fix_scan_expr and friends do this enough times that it ' s worth having * a bespoke routine instead of using the generic copyObject ( ) function . static inline Var *sizeof (Var));return newvar;/* * fix_expr_common * Do generic set_plan_references processing on an expression node * * This is code that is common to all variants of expression - fixing . * We must look up operator opcode info for OpExpr and related nodes , * add OIDs from regclass Const nodes into root - > glob - > relationOids , and * add PlanInvalItems for user - defined functions into root - > glob - > invalItems . * We also fill in column index lists for GROUPING ( ) expressions . * * We assume it ' s okay to update opcode info in - place . So this could possibly * scribble on the planner ' s input data structures , but it ' s OK . static void /* We assume callers won't call us on a NULL pointer */ if (IsA(node, Aggref))else if (IsA(node, WindowFunc))else if (IsA(node, FuncExpr))else if (IsA(node, OpExpr))else if (IsA(node, DistinctExpr))/* rely on struct equivalence */ else if (IsA(node, NullIfExpr))/* rely on struct equivalence */ else if (IsA(node, ScalarArrayOpExpr))if (OidIsValid(saop->hashfuncid))if (OidIsValid(saop->negfuncid))else if (IsA(node, Const ))Const *con = (Const *) node;/* Check for regclass reference */ if (ISREGCLASSCONST(con))else if (IsA(node, GroupingFunc))/* If there are no grouping sets, we don't need this. */ if (grouping_map)if (!g->cols)/* * fix_param_node * Do set_plan_references processing on a Param * * If it ' s a PARAM_MULTIEXPR , replace it with the appropriate Param from * root - > multiexpr_params ; otherwise no change is needed . * Just for paranoia ' s sake , we make a copy of the node in either case . static Node *if (p->paramkind == PARAM_MULTIEXPR)int subqueryid = p->paramid >> 16 ;int colno = p->paramid & 0 xFFFF;if (subqueryid <= 0 ||"unexpected PARAM_MULTIEXPR ID: %d" , p->paramid);1 );if (colno <= 0 || colno > list_length(params))"unexpected PARAM_MULTIEXPR ID: %d" , p->paramid);return copyObject(list_nth(params, colno - 1 ));return (Node *) copyObject(p);/* * fix_alternative_subplan * Do set_plan_references processing on an AlternativeSubPlan * * Choose one of the alternative implementations and return just that one , * discarding the rest of the AlternativeSubPlan structure . * Note : caller must still recurse into the result ! * * We don ' t make any attempt to fix up cost estimates in the parent plan * node or higher - level nodes . static Node *double num_exec)0 ;/* * Compute the estimated cost of each subplan assuming num_exec * executions , and keep the cheapest one . In event of exact equality of * estimates , we prefer the later plan ; this is a bit arbitrary , but in * current usage it biases us to break ties against fast - start subplans . if (bestplan == NULL || curcost <= bestcost)/* Also mark all subplans that are in AlternativeSubPlans */ 1 ] = true ;/* Mark the subplan we selected */ 1 ] = true ;return (Node *) bestplan;/* * fix_scan_expr * Do set_plan_references processing on a scan - level expression * * This consists of incrementing all Vars ' varnos by rtoffset , * replacing PARAM_MULTIEXPR Params , expanding PlaceHolderVars , * replacing Aggref nodes that should be replaced by initplan output Params , * choosing the best implementation for AlternativeSubPlans , * looking up operator opcode info for OpExpr and related nodes , * and adding OIDs from regclass Const nodes into root - > glob - > relationOids . * * ' node ' : the expression to be modified * ' rtoffset ' : how much to increment varnos by * ' num_exec ' : estimated number of executions of expression * * The expression tree is either copied - and - modified , or modified in - place * if that seems safe . static Node *int rtoffset, double num_exec)if (rtoffset != 0 ||0 ||return fix_scan_expr_mutator(node, &context);else /* * If rtoffset = = 0 , we don ' t need to change any Vars , and if there * are no MULTIEXPR subqueries then we don ' t need to replace * PARAM_MULTIEXPR Params , and if there are no placeholders anywhere * we won ' t need to remove them , and if there are no minmax Aggrefs we * won ' t need to replace them , and if there are no AlternativeSubPlans * we won ' t need to remove them . Then it ' s OK to just scribble on the * input node tree instead of copying ( since the only change , filling * in any unset opfuncid fields , is harmless ) . This saves just enough * cycles to be noticeable on trivial queries . void ) fix_scan_expr_walker(node, &context);return node;static Node *if (node == NULL)return NULL;if (IsA(node, Var))0 );/* * We should not see Vars marked INNER_VAR , OUTER_VAR , or ROWID_VAR . * But an indexqual expression could contain INDEX_VAR Vars . if (!IS_SPECIAL_VARNO(var->varno))if (var->varnosyn > 0 )return (Node *) var;if (IsA(node, Param))return fix_param_node(context->root, (Param *) node);if (IsA(node, Aggref))/* See if the Aggref should be replaced by a Param */ if (aggparam != NULL)/* Make a copy of the Param for paranoia's sake */ return (Node *) copyObject(aggparam);/* If no match, just fall through to process it normally */ if (IsA(node, CurrentOfExpr))return (Node *) cexpr;if (IsA(node, PlaceHolderVar))/* At scan level, we should always just evaluate the contained expr */ /* XXX can we assert something about phnullingrels? */ return fix_scan_expr_mutator((Node *) phv->phexpr, context);if (IsA(node, AlternativeSubPlan))return fix_scan_expr_mutator(fix_alternative_subplan(context->root,return expression_tree_mutator(node, fix_scan_expr_mutator, context);static bool if (node == NULL)return false ;return expression_tree_walker(node, fix_scan_expr_walker, context);/* * set_join_references * Modify the target list and quals of a join node to reference its * subplans , by setting the varnos to OUTER_VAR or INNER_VAR and setting * attno values to the result domain number of either the corresponding * outer or inner join tuple item . Also perform opcode lookup for these * expressions , and add regclass OIDs to root - > glob - > relationOids . static void int rtoffset)/* * First process the joinquals ( including merge or hash clauses ) . These * are logically below the join so they can always use all values * available from the input tlists . It ' s okay to also handle * NestLoopParams now , because those couldn ' t refer to nullable * subexpressions . 0 ,/* Now do join-type-specific stuff */ if (IsA(join, NestLoop))/* * Because we don ' t reparameterize parameterized paths to match * the outer - join level at which they are used , Vars seen in the * NestLoopParam expression may have nullingrels that are just a * subset of those in the Vars actually available from the outer * side . ( Lateral references can also cause this , as explained in * the comments for identify_current_nestloop_params . ) Not * checking this exactly is a bit grotty , but the work needed to * make things match up perfectly seems well out of proportion to * the value . /* Check we replaced any PlaceHolderVar with simple Var */ if (!(IsA(nlp->paramval, Var) &&"NestLoopParam was not reduced to a simple Var" );else if (IsA(join, MergeJoin))0 ,else if (IsA(join, HashJoin))0 ,/* * HashJoin ' s hashkeys are used to look for matching tuples from its * outer plan ( not the Hash node ! ) in the hashtable . /* * Now we need to fix up the targetlist and qpqual , which are logically * above the join . This means that , if it ' s not an inner join , any Vars * and PHVs appearing here should have nullingrels that include the * effects of the outer join , ie they will have nullingrels equal to the * input Vars ' nullingrels plus the bit added by the outer join . We don ' t * currently have enough info available here to identify what that should * be , so we just tell fix_join_expr to accept superset nullingrels * matches instead of exact ones . 0 ,0 ,/* * set_upper_references * Update the targetlist and quals of an upper - level plan node * to refer to the tuples returned by its lefttree subplan . * Also perform opcode lookup for these expressions , and * add regclass OIDs to root - > glob - > relationOids . * * This is used for single - input plan types like Agg , Group , Result . * * In most cases , we have to match up individual Vars in the tlist and * qual expressions with elements of the subplan ' s tlist ( which was * generated by flattening these selfsame expressions , so it should have all * the required variables ) . There is an important exception , however : * depending on where we are in the plan tree , sort / group columns may have * been pushed into the subplan tlist unflattened . If these values are also * needed in the output then we want to reference the subplan tlist element * rather than recomputing the expression . static void int rtoffset)/* * If it ' s a grouping node with grouping sets , any Vars and PHVs appearing * in the targetlist and quals should have nullingrels that include the * effects of the grouping step , ie they will have nullingrels equal to * the input Vars / PHVs ' nullingrels plus the RT index of the grouping * step . In order to perform exact nullingrels matches , we remove the RT * index of the grouping step first . if (IsA(plan, Agg) &&0 &&/* If it's a sort/group item, first try to match by sortref */ if (tle->ressortgroupref != 0 )if (!newexpr)else /* * set_param_references * Initialize the initParam list in Gather or Gather merge node such that * it contains reference of all the params that needs to be evaluated * before execution of the node . It contains the initplan params that are * being passed to the plan nodes below it . static void if (plan->lefttree->extParam)for (proot = root; proot != NULL; proot = proot->parent_root)/* * Remember the list of all external initplan params that are used by * the children of Gather or Gather merge node . if (IsA(plan, Gather))else /* * Recursively scan an expression tree and convert Aggrefs to the proper * intermediate form for combining aggregates . This means ( 1 ) replacing each * one ' s argument list with a single argument that is the original Aggref * modified to show partial aggregation and ( 2 ) changing the upper Aggref to * show combining aggregation . * * After this step , set_upper_references will replace the partial Aggrefs * with Vars referencing the lower Agg plan node ' s outputs , so that the final * form seen by the executor is a combining Aggref with a Var as input . * * It ' s rather messy to postpone this step until setrefs . c ; ideally it ' d be * done in createplan . c . The difficulty is that once we modify the Aggref * expressions , they will no longer be equal ( ) to their original form and * so cross - plan - node - level matches will fail . So this has to happen after * the plan node above the Agg has resolved its subplan references . static Node *void *context)if (node == NULL)return NULL;if (IsA(node, Aggref))/* Assert we've not chosen to partial-ize any unsupported cases */ /* * Since aggregate calls can ' t be nested , we needn ' t recurse into the * arguments . But for safety , flat - copy the Aggref node itself rather * than modifying it in - place . sizeof (Aggref));/* * For the parent Aggref , we want to copy all the fields of the * original aggregate * except * the args list , which we ' ll replace * below , and the aggfilter expression , which should be applied only * by the child not the parent . Rather than explicitly knowing about * all the other fields here , we can momentarily modify child_agg to * provide a suitable source for copyObject . /* * Now , set up child_agg to represent the first phase of partial * aggregation . For now , assume serialization is required . /* * And set up parent_agg to represent the second phase . 1 , NULL, false ));return (Node *) parent_agg;return expression_tree_mutator(node, convert_combining_aggrefs, context);/* * set_dummy_tlist_references * Replace the targetlist of an upper - level plan node with a simple * list of OUTER_VAR references to its child . * * This is used for plan types like Sort and Append that don ' t evaluate * their targetlists . Although the executor doesn ' t care at all what ' s in * the tlist , EXPLAIN needs it to be realistic . * * Note : we could almost use set_upper_references ( ) here , but it fails for * Append for lack of a lefttree subplan . Single - purpose code is faster * anyway . static void int rtoffset)/* * As in search_indexed_tlist_for_non_var ( ) , we prefer to keep Consts * as Consts , not Vars referencing Consts . Here , there ' s no speed * advantage to be had , but it makes EXPLAIN output look cleaner , and * again it avoids confusing the executor . if (IsA(oldvar, Const ))/* just reuse the existing TLE node */ continue ;0 );if (IsA(oldvar, Var) &&0 )else 0 ; /* wasn't ever a plain Var */ 0 ;/* We don't touch plan->qual here */ /* * build_tlist_index - - - build an index data structure for a child tlist * * In most cases , subplan tlists will be " flat " tlists with only Vars , * so we try to optimize that case by extracting information about Vars * in advance . Matching a parent tlist to a child is still an O ( N ^ 2 ) * operation , but at least with a much smaller constant factor than plain * tlist_member ( ) searches . * * The result of this function is an indexed_tlist struct to pass to * search_indexed_tlist_for_var ( ) and siblings . * When done , the indexed_tlist may be freed with a single pfree ( ) . static indexed_tlist */* Create data structure with enough slots for all tlist entries */ sizeof (tlist_vinfo));false ;false ;/* Find the Vars and fill in the index array */ if (tle->expr && IsA(tle->expr, Var))else if (tle->expr && IsA(tle->expr, PlaceHolderVar))true ;else true ;return itlist;/* * build_tlist_index_other_vars - - - build a restricted tlist index * * This is like build_tlist_index , but we only index tlist entries that * are Vars belonging to some rel other than the one specified . We will set * has_ph_vars ( allowing PlaceHolderVars to be matched ) , but not has_non_vars * ( so nothing other than Vars and PlaceHolderVars can be matched ) . static indexed_tlist *int ignore_rel)/* Create data structure with enough slots for all tlist entries */ sizeof (tlist_vinfo));false ;false ;/* Find the desired Vars and fill in the index array */ if (tle->expr && IsA(tle->expr, Var))if (var->varno != ignore_rel)else if (tle->expr && IsA(tle->expr, PlaceHolderVar))true ;return itlist;/* * search_indexed_tlist_for_var - - - find a Var in an indexed tlist * * If a match is found , return a copy of the given Var with suitably * modified varno / varattno ( to wit , newvarno and the resno of the TLE entry ) . * Also ensure that varnosyn is incremented by rtoffset . * If no match , return NULL . * * We cross - check the varnullingrels of the subplan output Var based on * nrm_match . Most call sites should pass NRM_EQUAL indicating we expect * an exact match . However , there are places where we haven ' t cleaned * things up completely , and we have to settle for allowing subset or * superset matches . static Var *int newvarno, int rtoffset,int varno = var->varno;int i;while (i-- > 0 )if (vinfo->varno == varno && vinfo->varattno == varattno)/* Found a match */ /* * Verify that we kept all the nullingrels machinations straight . * * XXX we skip the check for system columns and whole - row Vars . * That ' s because such Vars might be row identity Vars , which are * generated without any varnullingrels . It ' d be hard to do * otherwise , since they ' re normally made very early in planning , * when we haven ' t looked at the jointree yet and don ' t know which * joins might null such Vars . Doesn ' t seem worth the expense to * make them fully valid . ( While it ' s slightly annoying that we * thereby lose checking for user - written references to such * columns , it seems unlikely that a bug in nullingrels logic * would affect only system columns . ) if (!(varattno <= 0 ||"wrong varnullingrels %s (expected %s) for Var %d/%d" ,if (newvar->varnosyn > 0 )return newvar;return NULL; /* no match */ /* * search_indexed_tlist_for_phv - - - find a PlaceHolderVar in an indexed tlist * * If a match is found , return a Var constructed to reference the tlist item . * If no match , return NULL . * * Cross - check phnullingrels as in search_indexed_tlist_for_var . * * NOTE : it is a waste of time to call this unless itlist - > has_ph_vars . static Var *int newvarno,if (tle->expr && IsA(tle->expr, PlaceHolderVar))/* * Analogously to search_indexed_tlist_for_var , we match on phid * only . We don ' t use equal ( ) , partially for speed but mostly * because phnullingrels might not be exactly equal . if (phv->phid != subphv->phid)continue ;/* Verify that we kept all the nullingrels machinations straight */ if (!(nrm_match == NRM_SUBSET ?"wrong phnullingrels %s (expected %s) for PlaceHolderVar %d" ,/* Found a matching subplan output expression */ 0 ; /* wasn't ever a plain Var */ 0 ;return newvar;return NULL; /* no match */ /* * search_indexed_tlist_for_non_var - - - find a non - Var / PHV in an indexed tlist * * If a match is found , return a Var constructed to reference the tlist item . * If no match , return NULL . * * NOTE : it is a waste of time to call this unless itlist - > has_non_vars . static Var *int newvarno)/* * If it ' s a simple Const , replacing it with a Var is silly , even if there * happens to be an identical Const below ; a Var is more expensive to * execute than a Const . What ' s more , replacing it could confuse some * places in the executor that expect to see simple Consts for , eg , * dropped columns . if (IsA(node, Const ))return NULL;if (tle)/* Found a matching subplan output expression */ 0 ; /* wasn't ever a plain Var */ 0 ;return newvar;return NULL; /* no match */ /* * search_indexed_tlist_for_sortgroupref - - - find a sort / group expression * * If a match is found , return a Var constructed to reference the tlist item . * If no match , return NULL . * * This is needed to ensure that we select the right subplan TLE in cases * where there are multiple textually - equal ( ) - but - volatile sort expressions . * And it ' s also faster than search_indexed_tlist_for_non_var . static Var *int newvarno)/* * Usually the equal ( ) check is redundant , but in setop plans it may * not be , since prepunion . c assigns ressortgroupref equal to the * column resno without regard to whether that matches the topmost * level ' s sortgrouprefs and without regard to whether any implicit * coercions are added in the setop tree . We might have to clean that * up someday ; but for now , just ignore any false matches . if (tle->ressortgroupref == sortgroupref &&/* Found a matching subplan output expression */ 0 ; /* wasn't ever a plain Var */ 0 ;return newvar;return NULL; /* no match */ /* * fix_join_expr * Create a new set of targetlist entries or join qual clauses by * changing the varno / varattno values of variables in the clauses * to reference target list values from the outer and inner join * relation target lists . Also perform opcode lookup and add * regclass OIDs to root - > glob - > relationOids . * * This is used in four different scenarios : * 1 ) a normal join clause , where all the Vars in the clause * must * be * replaced by OUTER_VAR or INNER_VAR references . In this case * acceptable_rel should be zero so that any failure to match a Var will be * reported as an error . * 2 ) RETURNING clauses , which may contain both Vars of the target relation * and Vars of other relations . In this case we want to replace the * other - relation Vars by OUTER_VAR references , while leaving target Vars * alone . Thus inner_itlist = NULL and acceptable_rel = the ID of the * target relation should be passed . * 3 ) ON CONFLICT UPDATE SET / WHERE clauses . Here references to EXCLUDED are * to be replaced with INNER_VAR references , while leaving target Vars ( the * to - be - updated relation ) alone . Correspondingly inner_itlist is to be * EXCLUDED elements , outer_itlist = NULL and acceptable_rel the target * relation . * 4 ) MERGE . In this case , references to the source relation are to be * replaced with INNER_VAR references , leaving Vars of the target * relation ( the to - be - modified relation ) alone . So inner_itlist is to be * the source relation elements , outer_itlist = NULL and acceptable_rel * the target relation . * * ' clauses ' is the targetlist or list of join clauses * ' outer_itlist ' is the indexed target list of the outer join relation , * or NULL * ' inner_itlist ' is the indexed target list of the inner join relation , * or NULL * ' acceptable_rel ' is either zero or the rangetable index of a relation * whose Vars may appear in the clause without provoking an error * ' rtoffset ' : how much to increment varnos by * ' nrm_match ' : as for search_indexed_tlist_for_var ( ) * ' num_exec ' : estimated number of executions of expression * * Returns the new expression tree . The original clause structure is * not modified . static List *int rtoffset,double num_exec)return (List *) fix_join_expr_mutator((Node *) clauses, &context);static Node *if (node == NULL)return NULL;if (IsA(node, Var))/* * Verify that Vars with non - default varreturningtype only appear in * the RETURNING list , and refer to the target relation . if (var->varreturningtype != VAR_RETURNING_DEFAULT)if (context->inner_itlist != NULL ||0 )"variable returning old/new found outside RETURNING list" );if (var->varno != context->acceptable_rel)"wrong varno %d (expected %d) for variable returning old/new" ,/* Look for the var in the input tlists, first in the outer */ if (context->outer_itlist)if (newvar)return (Node *) newvar;/* then in the inner. */ if (context->inner_itlist)if (newvar)return (Node *) newvar;/* If it's for acceptable_rel, adjust and return it */ if (var->varno == context->acceptable_rel)if (var->varnosyn > 0 )return (Node *) var;/* No referent found for Var */ "variable not found in subplan target lists" );if (IsA(node, PlaceHolderVar))/* See if the PlaceHolderVar has bubbled up from a lower plan node */ if (context->outer_itlist && context->outer_itlist->has_ph_vars)if (newvar)return (Node *) newvar;if (context->inner_itlist && context->inner_itlist->has_ph_vars)if (newvar)return (Node *) newvar;/* If not supplied by input plans, evaluate the contained expr */ /* XXX can we assert something about phnullingrels? */ return fix_join_expr_mutator((Node *) phv->phexpr, context);/* Try matching more complex expressions too, if tlists have any */ if (context->outer_itlist && context->outer_itlist->has_non_vars)if (newvar)return (Node *) newvar;if (context->inner_itlist && context->inner_itlist->has_non_vars)if (newvar)return (Node *) newvar;/* Special cases (apply only AFTER failing to match to lower tlist) */ if (IsA(node, Param))return fix_param_node(context->root, (Param *) node);if (IsA(node, AlternativeSubPlan))return fix_join_expr_mutator(fix_alternative_subplan(context->root,return expression_tree_mutator(node, fix_join_expr_mutator, context);/* * fix_upper_expr * Modifies an expression tree so that all Var nodes reference outputs * of a subplan . Also looks for Aggref nodes that should be replaced * by initplan output Params . Also performs opcode lookup , and adds * regclass OIDs to root - > glob - > relationOids . * * This is used to fix up target and qual expressions of non - join upper - level * plan nodes , as well as index - only scan nodes . * * An error is raised if no matching var can be found in the subplan tlist * - - - so this routine should only be applied to nodes whose subplans ' * targetlists were generated by flattening the expressions used in the * parent node . * * If itlist - > has_non_vars is true , then we try to match whole subexpressions * against elements of the subplan tlist , so that we can avoid recomputing * expressions that were already computed by the subplan . ( This is relatively * expensive , so we don ' t want to try it in the common case where the * subplan tlist is just a flattened list of Vars . ) * * ' node ' : the tree to be fixed ( a target item or qual ) * ' subplan_itlist ' : indexed target list for subplan ( or index ) * ' newvarno ' : varno to use for Vars referencing tlist elements * ' rtoffset ' : how much to increment varnos by * ' nrm_match ' : as for search_indexed_tlist_for_var ( ) * ' num_exec ' : estimated number of executions of expression * * The resulting tree is a copy of the original in which all Var nodes have * varno = newvarno , varattno = resno of corresponding targetlist element . * The original tree is not modified . static Node *int newvarno,int rtoffset,double num_exec)return fix_upper_expr_mutator(node, &context);static Node *if (node == NULL)return NULL;if (IsA(node, Var))if (!newvar)"variable not found in subplan target list" );return (Node *) newvar;if (IsA(node, PlaceHolderVar))/* See if the PlaceHolderVar has bubbled up from a lower plan node */ if (context->subplan_itlist->has_ph_vars)if (newvar)return (Node *) newvar;/* If not supplied by input plan, evaluate the contained expr */ /* XXX can we assert something about phnullingrels? */ return fix_upper_expr_mutator((Node *) phv->phexpr, context);/* Try matching more complex expressions too, if tlist has any */ if (context->subplan_itlist->has_non_vars)if (newvar)return (Node *) newvar;/* Special cases (apply only AFTER failing to match to lower tlist) */ if (IsA(node, Param))return fix_param_node(context->root, (Param *) node);if (IsA(node, Aggref))/* See if the Aggref should be replaced by a Param */ if (aggparam != NULL)/* Make a copy of the Param for paranoia's sake */ return (Node *) copyObject(aggparam);/* If no match, just fall through to process it normally */ if (IsA(node, AlternativeSubPlan))return fix_upper_expr_mutator(fix_alternative_subplan(context->root,return expression_tree_mutator(node, fix_upper_expr_mutator, context);/* * set_returning_clause_references * Perform setrefs . c ' s work on a RETURNING targetlist * * If the query involves more than just the result table , we have to * adjust any Vars that refer to other tables to reference junk tlist * entries in the top subplan ' s targetlist . Vars referencing the result * table should be left alone , however ( the executor will evaluate them * using the actual heap tuple , after firing triggers if any ) . In the * adjusted RETURNING list , result - table Vars will have their original * varno ( plus rtoffset ) , but Vars for other rels will have varno OUTER_VAR . * * We also must perform opcode lookup and add regclass OIDs to * root - > glob - > relationOids . * * ' rlist ' : the RETURNING targetlist to be fixed * ' topplan ' : the top subplan node that will be just below the ModifyTable * node ( note it ' s not yet passed through set_plan_refs ) * ' resultRelation ' : RT index of the associated result relation * ' rtoffset ' : how much to increment varnos by * * Note : the given ' root ' is for the parent query level , not the ' topplan ' . * This does not matter currently since we only access the dependency - item * lists in root - > glob , but it would need some hacking if we wanted a root * that actually matches the subplan . * * Note : resultRelation is not yet adjusted by rtoffset . static List *int rtoffset)/* * We can perform the desired Var fixup by abusing the fix_join_expr * machinery that formerly handled inner indexscan fixup . We search the * top plan ' s targetlist for Vars of non - result relations , and use * fix_join_expr to convert RETURNING Vars into references to those tlist * entries , while leaving result - rel Vars as - is . * * PlaceHolderVars will also be sought in the targetlist , but no * more - complex expressions will be . Note that it is not possible for a * PlaceHolderVar to refer to the result relation , since the result is * never below an outer join . If that case could happen , we ' d have to be * prepared to pick apart the PlaceHolderVar and evaluate its contained * expression instead . return rlist;/* * fix_windowagg_condition_expr_mutator * Mutator function for replacing WindowFuncs with the corresponding Var * in the targetlist which references that WindowFunc . static Node *if (node == NULL)return NULL;if (IsA(node, WindowFunc))if (newvar)return (Node *) newvar;"WindowFunc not found in subplan target lists" );return expression_tree_mutator(node,/* * fix_windowagg_condition_expr * Converts references in ' runcondition ' so that any WindowFunc * references are swapped out for a Var which references the matching * WindowFunc in ' subplan_itlist ' . static List *0 ;return (List *) fix_windowagg_condition_expr_mutator((Node *) runcondition,/* * set_windowagg_runcondition_references * Converts references in ' runcondition ' so that any WindowFunc * references are swapped out for a Var which references the matching * WindowFunc in ' plan ' targetlist . static List *return newlist;/* * find_minmax_agg_replacement_param * If the given Aggref is one that we are optimizing into a subquery * ( cf . planagg . c ) , then return the Param that should replace it . * Else return NULL . * * This is exported so that SS_finalize_plan can use it before setrefs . c runs . * Note that it will not find anything until we have built a Plan from a * MinMaxAggPath , as root - > minmax_aggs will never be filled otherwise . if (root->minmax_aggs != NIL &&1 )if (mminfo->aggfnoid == aggref->aggfnoid &&return mminfo->param;return NULL;/***************************************************************************** * QUERY DEPENDENCY MANAGEMENT /* * record_plan_function_dependency * Mark the current plan as depending on a particular function . * * This is exported so that the function - inlining code can record a * dependency on a function that it ' s removed from the plan tree . void /* * For performance reasons , we don ' t bother to track built - in functions ; * we just assume they ' ll never change ( or at least not in ways that ' d * invalidate plans using them ) . For this purpose we can consider a * built - in function to be one with OID less than FirstUnpinnedObjectId . * Note that the OID generator guarantees never to generate such an OID * after startup , even at OID wraparound . if (funcid >= (Oid) FirstUnpinnedObjectId)/* * It would work to use any syscache on pg_proc , but the easiest is * PROCOID since we already have the function ' s OID at hand . Note * that plancache . c knows we use PROCOID . /* * record_plan_type_dependency * Mark the current plan as depending on a particular type . * * This is exported so that eval_const_expressions can record a * dependency on a domain that it ' s removed a CoerceToDomain node for . * * We don ' t currently need to record dependencies on domains that the * plan contains CoerceToDomain nodes for , though that might change in * future . Hence , this isn ' t actually called in this module , though * someday fix_expr_common might call it . void /* * As in record_plan_function_dependency , ignore the possibility that * someone would change a built - in domain . if (typid >= (Oid) FirstUnpinnedObjectId)/* * It would work to use any syscache on pg_type , but the easiest is * TYPEOID since we already have the type ' s OID at hand . Note that * plancache . c knows we use TYPEOID . /* * extract_query_dependencies * Given a rewritten , but not yet planned , query or queries * ( i . e . a Query node or list of Query nodes ) , extract dependencies * just as set_plan_references would do . Also detect whether any * rewrite steps were affected by RLS . * * This is needed by plancache . c to handle invalidation of cached unplanned * queries . * * Note : this does not go through eval_const_expressions , and hence doesn ' t * reflect its additions of inlined functions and elided CoerceToDomain nodes * to the invalItems list . This is obviously OK for functions , since we ' ll * see them in the original query tree anyway . For domains , it ' s OK because * we don ' t care about domains unless they get elided . That is , a plan might * have domain dependencies that the query tree doesn ' t . void bool *hasRowSecurity)/* Make up dummy planner state so we can use this module's machinery */ 0 , sizeof (glob));/* Hack: we use glob.dependsOnRole to collect hasRowSecurity flags */ false ;0 , sizeof (root));void ) extract_query_dependencies_walker(query, &root);/* * Tree walker for extract_query_dependencies . * * This is exported so that expression_planner_with_deps can call it on * simple expressions ( post - planning , not before planning , in that case ) . * In that usage , glob . dependsOnRole isn ' t meaningful , but the relationOids * and invalItems lists are added to as needed . bool if (node == NULL)return false ;if (IsA(node, Query))if (query->commandType == CMD_UTILITY)/* * This logic must handle any utility command for which parse * analysis was nontrivial ( cf . stmt_requires_parse_analysis ) . * * Notably , CALL requires its own processing . if (IsA(query->utilityStmt, CallStmt))/* We need not examine funccall, just the transformed exprs */ void ) extract_query_dependencies_walker((Node *) callstmt->funcexpr,void ) extract_query_dependencies_walker((Node *) callstmt->outargs,return false ;/* * Ignore other utility statements , except those ( such as EXPLAIN ) * that contain a parsed - but - not - planned query . For those , we * just need to transfer our attention to the contained query . if (query == NULL)return false ;/* Remember if any Query has RLS quals applied by rewriter */ if (query->hasRowSecurity)true ;/* Collect relation OIDs in this Query's rtable */ if (rte->rtekind == RTE_RELATION ||/* And recurse into the query's subexpressions */ return query_tree_walker(query, extract_query_dependencies_walker,0 );/* Extract function dependencies and check for regclass Consts */ return expression_tree_walker(node, extract_query_dependencies_walker,
Messung V0.5 in Prozent C=94 H=99 G=96
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.388Bemerkung:
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-09-27)
¤ *Bot Zugriff
