这篇文章主要介绍“PostgreSQL中make_rel_from_joinlist函数分析”,在日常操作中,相信很多人在PostgreSQL中make_rel_from_joinlist函数分析问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”PostgreSQL中make_rel_from_joinlist函数分析”的疑惑有所帮助!接下来,请跟着小编一起来学习吧!
创新互联主营咸丰网站建设的网络公司,主营网站建设方案,成都App制作,咸丰h5重庆小程序开发搭建,咸丰网站营销推广欢迎咸丰等地区企业咨询
make_rel_from_joinlist函数根据连接关系链表(joinlist)通过外部算法(钩子函数)/遗传算法/动态规划算法构建连接路径,其中joinlist链表在主函数中已通过调用deconstruct_jointree函数生成.
动态规划算法的实现standard_join_search函数以及遗传算法在后续章节再行介绍.
/* * make_rel_from_joinlist * Build access paths using a "joinlist" to guide the join path search. * 依据deconstruct_jointree函数构造的joinlist生成连接路径. * joinlist详细的数据结构参照deconstruct_jointree函数注释 * * See comments for deconstruct_jointree() for definition of the joinlist * data structure. */ static RelOptInfo * make_rel_from_joinlist(PlannerInfo *root, List *joinlist) { int levels_needed; List *initial_rels; ListCell *jl; /* * Count the number of child joinlist nodes. This is the depth of the * dynamic-programming algorithm we must employ to consider all ways of * joining the child nodes. * 计算joinlist链表中节点的个数。 * 确定使用的算法(动态规划算法 vs 遗传算法),如个数<阈值,则考虑所有连接的方式。 */ levels_needed = list_length(joinlist); if (levels_needed <= 0) return NULL; /* nothing to do? */ /* * Construct a list of rels corresponding to the child joinlist nodes. * This may contain both base rels and rels constructed according to * sub-joinlists. * 构造与joinlist中元素相对应的rels链表。 * 这可能包括base rels和通过子连接构造的base rels。 */ initial_rels = NIL; foreach(jl, joinlist)//遍历链表 { Node *jlnode = (Node *) lfirst(jl); RelOptInfo *thisrel; if (IsA(jlnode, RangeTblRef))//RTR { int varno = ((RangeTblRef *) jlnode)->rtindex; thisrel = find_base_rel(root, varno);//根据编号找到相应的RelOptInfo } else if (IsA(jlnode, List))//链表 { /* Recurse to handle subproblem */ thisrel = make_rel_from_joinlist(root, (List *) jlnode);//递归调用,形成新的base rel } else//其他类型,出错 { elog(ERROR, "unrecognized joinlist node type: %d", (int) nodeTag(jlnode)); thisrel = NULL; /* keep compiler quiet */ } initial_rels = lappend(initial_rels, thisrel);//添加到base rel链表中 } if (levels_needed == 1)//连接链表只有1个元素 { /* * Single joinlist node, so we're done. */ return (RelOptInfo *) linitial(initial_rels);//直接返回 } else//>1个元素 { /* * Consider the different orders in which we could join the rels, * using a plugin, GEQO, or the regular join search code. * 考虑不同的连接顺序->使用外部算法/GEQO遗传算法/动态规划算法。 * * We put the initial_rels list into a PlannerInfo field because * has_legal_joinclause() needs to look at it (ugly :-(). * */ root->initial_rels = initial_rels; if (join_search_hook)//调用钩子函数 return (*join_search_hook) (root, levels_needed, initial_rels); else if (enable_geqo && levels_needed >= geqo_threshold) return geqo(root, levels_needed, initial_rels);//遗传算法 else return standard_join_search(root, levels_needed, initial_rels);//动态规划算法 } } //----------------------------------------------------------------------- standard_join_search /* * standard_join_search * Find possible joinpaths for a query by successively finding ways * to join component relations into join relations. * 通过动态规划算法为查询语句构造连接路径. * * 'levels_needed' is the number of iterations needed, ie, the number of * independent jointree items in the query. This is > 1. * levels_needed-连接链表中的节点个数,>1 * * 'initial_rels' is a list of RelOptInfo nodes for each independent * jointree item. These are the components to be joined together. * Note that levels_needed == list_length(initial_rels). * initial_rels-与连接树每个元素相对应的RelOptInfo节点 * * Returns the final level of join relations, i.e., the relation that is * the result of joining all the original relations together. * At least one implementation path must be provided for this relation and * all required sub-relations. * 返回连接的最终关系(最顶层的Relation):将所有原始关系连接在一起的最终结果。 * 优化器为该关系及其所必需的子关系提供至少一个的实现路径。 * * To support loadable plugins that modify planner behavior by changing the * join searching algorithm, we provide a hook variable that lets a plugin * replace or supplement this function. Any such hook must return the same * final join relation as the standard code would, but it might have a * different set of implementation paths attached, and only the sub-joinrels * needed for these paths need have been instantiated. * 为了支持自定义函数,PG提供了一个钩子变量,允许外部插件替换或填充这个函数。 * 任何这样的钩子都必须返回与PG标准函数相同的最终连接关系, * 但是它可能附加了一组不同的实现路径,并且只实例化了这些路径所需的子连接。 * * Note to plugin authors: the functions invoked during standard_join_search() * modify root->join_rel_list and root->join_rel_hash. If you want to do more * than one join-order search, you'll probably need to save and restore the * original states of those data structures. See geqo_eval() for an example. */ RelOptInfo * standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels) { int lev; RelOptInfo *rel; /* * This function cannot be invoked recursively within any one planning * problem, so join_rel_level[] can't be in use already. */ Assert(root->join_rel_level == NULL);//验证 /* * We employ a simple "dynamic programming" algorithm: we first find all * ways to build joins of two jointree items, then all ways to build joins * of three items (from two-item joins and single items), then four-item * joins, and so on until we have considered all ways to join all the * items into one rel. * PG实现了一种简单的动态规划算法:首先为连接树中的两个Relation建立可能的连接路径 * 然后为三个Relation建立所有可能的连接路径,以此类推直至已为所有的Relation建立了 * 连接路径,从而得到最终的关系(final_rel) * * root->join_rel_level[j] is a list of all the j-item rels. Initially we * set root->join_rel_level[1] to represent all the single-jointree-item * relations. * 设置root->join_rel_level数组,[j]是所有j-item rels的链表(即1个item的放在[1]中) */ root->join_rel_level = (List **) palloc0((levels_needed + 1) * sizeof(List *)); root->join_rel_level[1] = initial_rels;//1个item对应的rel链表 for (lev = 2; lev <= levels_needed; lev++)//构造2->N个item对应的rel链表 { ListCell *lc; /* * Determine all possible pairs of relations to be joined at this * level, and build paths for making each one from every available * pair of lower-level relations. * 确定在此级别上要连接的所有可能的关系对,并构建访问路径, * 以从每一对可用的较低级关系中往上创建关系。 */ join_search_one_level(root, lev); /* * Run generate_partitionwise_join_paths() and generate_gather_paths() * for each just-processed joinrel. We could not do this earlier * because both regular and partial paths can get added to a * particular joinrel at multiple times within join_search_one_level. * 循环调用generate_partitionwise_join_paths()和generate_collect _paths()函数: * 参数为上一步骤生成的链表中的每个元素。 * 由于常规路径和部分路径都可以在join_search_one_level中多次添加joinrel,因此在此处调用。 * * After that, we're done creating paths for the joinrel, so run * set_cheapest(). * 在此之后,PG已为joinrel(连接生成的新关系)创建了访问路径,因此可以调用函数set_cheapest * */ foreach(lc, root->join_rel_level[lev])//遍历链表 { rel = (RelOptInfo *) lfirst(lc);//新生成的关系 /* Create paths for partitionwise joins. */ generate_partitionwise_join_paths(root, rel);//创建partitionwise路径 /* * Except for the topmost scan/join rel, consider gathering * partial paths. We'll do the same for the topmost scan/join rel * once we know the final targetlist (see grouping_planner). */ if (lev < levels_needed) generate_gather_paths(root, rel, false);//并行执行需考虑gathering /* Find and save the cheapest paths for this rel */ set_cheapest(rel);//从形成该joinrel的所有路径中找到成本最低的 #ifdef OPTIMIZER_DEBUG debug_print_rel(root, rel);//DEBUG信息 #endif } } /* * We should have a single rel at the final level. * 连接的最终结果,只有一个RelOptInfo */ if (root->join_rel_level[levels_needed] == NIL) elog(ERROR, "failed to build any %d-way joins", levels_needed); Assert(list_length(root->join_rel_level[levels_needed]) == 1); rel = (RelOptInfo *) linitial(root->join_rel_level[levels_needed]);//获取最终结果 root->join_rel_level = NULL;//重置 return rel;//返回 } //----------------------------------------------------------------------- geqo /* * geqo * solution of the query optimization problem * similar to a constrained Traveling Salesman Problem (TSP) * 遗传算法:可参考TSP的求解算法. * TSP-旅行推销员问题(最短路径问题): * 给定一系列城市和每对城市之间的距离,求解访问每一座城市一次并回到起始城市的最短回路。 */ RelOptInfo * geqo(PlannerInfo *root, int number_of_rels, List *initial_rels) { GeqoPrivateData private; int generation; Chromosome *momma; Chromosome *daddy; Chromosome *kid; Pool *pool; int pool_size, number_generations; #ifdef GEQO_DEBUG int status_interval; #endif Gene *best_tour; RelOptInfo *best_rel; #if defined(ERX) Edge *edge_table; /* list of edges */ int edge_failures = 0; #endif #if defined(CX) || defined(PX) || defined(OX1) || defined(OX2) City *city_table; /* list of cities */ #endif #if defined(CX) int cycle_diffs = 0; int mutations = 0; #endif /* set up private information */ root->join_search_private = (void *) &private; private.initial_rels = initial_rels; /* initialize private number generator */ geqo_set_seed(root, Geqo_seed); /* set GA parameters */ pool_size = gimme_pool_size(number_of_rels); number_generations = gimme_number_generations(pool_size); #ifdef GEQO_DEBUG status_interval = 10; #endif /* allocate genetic pool memory */ pool = alloc_pool(root, pool_size, number_of_rels); /* random initialization of the pool */ random_init_pool(root, pool); /* sort the pool according to cheapest path as fitness */ sort_pool(root, pool); /* we have to do it only one time, since all * kids replace the worst individuals in * future (-> geqo_pool.c:spread_chromo ) */ #ifdef GEQO_DEBUG elog(DEBUG1, "GEQO selected %d pool entries, best %.2f, worst %.2f", pool_size, pool->data[0].worth, pool->data[pool_size - 1].worth); #endif /* allocate chromosome momma and daddy memory */ momma = alloc_chromo(root, pool->string_length); daddy = alloc_chromo(root, pool->string_length); #if defined (ERX) #ifdef GEQO_DEBUG elog(DEBUG2, "using edge recombination crossover [ERX]"); #endif /* allocate edge table memory */ edge_table = alloc_edge_table(root, pool->string_length); #elif defined(PMX) #ifdef GEQO_DEBUG elog(DEBUG2, "using partially matched crossover [PMX]"); #endif /* allocate chromosome kid memory */ kid = alloc_chromo(root, pool->string_length); #elif defined(CX) #ifdef GEQO_DEBUG elog(DEBUG2, "using cycle crossover [CX]"); #endif /* allocate city table memory */ kid = alloc_chromo(root, pool->string_length); city_table = alloc_city_table(root, pool->string_length); #elif defined(PX) #ifdef GEQO_DEBUG elog(DEBUG2, "using position crossover [PX]"); #endif /* allocate city table memory */ kid = alloc_chromo(root, pool->string_length); city_table = alloc_city_table(root, pool->string_length); #elif defined(OX1) #ifdef GEQO_DEBUG elog(DEBUG2, "using order crossover [OX1]"); #endif /* allocate city table memory */ kid = alloc_chromo(root, pool->string_length); city_table = alloc_city_table(root, pool->string_length); #elif defined(OX2) #ifdef GEQO_DEBUG elog(DEBUG2, "using order crossover [OX2]"); #endif /* allocate city table memory */ kid = alloc_chromo(root, pool->string_length); city_table = alloc_city_table(root, pool->string_length); #endif /* my pain main part: */ /* iterative optimization */ for (generation = 0; generation < number_generations; generation++) { /* SELECTION: using linear bias function */ geqo_selection(root, momma, daddy, pool, Geqo_selection_bias); #if defined (ERX) /* EDGE RECOMBINATION CROSSOVER */ gimme_edge_table(root, momma->string, daddy->string, pool->string_length, edge_table); kid = momma; /* are there any edge failures ? */ edge_failures += gimme_tour(root, edge_table, kid->string, pool->string_length); #elif defined(PMX) /* PARTIALLY MATCHED CROSSOVER */ pmx(root, momma->string, daddy->string, kid->string, pool->string_length); #elif defined(CX) /* CYCLE CROSSOVER */ cycle_diffs = cx(root, momma->string, daddy->string, kid->string, pool->string_length, city_table); /* mutate the child */ if (cycle_diffs == 0) { mutations++; geqo_mutation(root, kid->string, pool->string_length); } #elif defined(PX) /* POSITION CROSSOVER */ px(root, momma->string, daddy->string, kid->string, pool->string_length, city_table); #elif defined(OX1) /* ORDER CROSSOVER */ ox1(root, momma->string, daddy->string, kid->string, pool->string_length, city_table); #elif defined(OX2) /* ORDER CROSSOVER */ ox2(root, momma->string, daddy->string, kid->string, pool->string_length, city_table); #endif /* EVALUATE FITNESS */ kid->worth = geqo_eval(root, kid->string, pool->string_length); /* push the kid into the wilderness of life according to its worth */ spread_chromo(root, kid, pool); #ifdef GEQO_DEBUG if (status_interval && !(generation % status_interval)) print_gen(stdout, pool, generation); #endif } #if defined(ERX) && defined(GEQO_DEBUG) if (edge_failures != 0) elog(LOG, "[GEQO] failures: %d, average: %d", edge_failures, (int) number_generations / edge_failures); else elog(LOG, "[GEQO] no edge failures detected"); #endif #if defined(CX) && defined(GEQO_DEBUG) if (mutations != 0) elog(LOG, "[GEQO] mutations: %d, generations: %d", mutations, number_generations); else elog(LOG, "[GEQO] no mutations processed"); #endif #ifdef GEQO_DEBUG print_pool(stdout, pool, 0, pool_size - 1); #endif #ifdef GEQO_DEBUG elog(DEBUG1, "GEQO best is %.2f after %d generations", pool->data[0].worth, number_generations); #endif /* * got the cheapest query tree processed by geqo; first element of the * population indicates the best query tree */ best_tour = (Gene *) pool->data[0].string; best_rel = gimme_tree(root, best_tour, pool->string_length); if (best_rel == NULL) elog(ERROR, "geqo failed to make a valid plan"); /* DBG: show the query plan */ #ifdef NOT_USED print_plan(best_plan, root); #endif /* ... free memory stuff */ free_chromo(root, momma); free_chromo(root, daddy); #if defined (ERX) free_edge_table(root, edge_table); #elif defined(PMX) free_chromo(root, kid); #elif defined(CX) free_chromo(root, kid); free_city_table(root, city_table); #elif defined(PX) free_chromo(root, kid); free_city_table(root, city_table); #elif defined(OX1) free_chromo(root, kid); free_city_table(root, city_table); #elif defined(OX2) free_chromo(root, kid); free_city_table(root, city_table); #endif free_pool(root, pool); /* ... clear root pointer to our private storage */ root->join_search_private = NULL; return best_rel; }
测试脚本以及执行计划如下:
testdb=# explain verbose select a.*,b.grbh,b.je testdb-# from t_dwxx a, testdb-# lateral (select t1.dwbh,t1.grbh,t2.je testdb(# from t_grxx t1 testdb(# inner join t_jfxx t2 on t1.dwbh = a.dwbh and t1.grbh = t2.grbh) b testdb-# where a.dwbh = '1001' testdb-# order by b.dwbh; QUERY PLAN ------------------------------------------------------------------------------------------------------ Nested Loop (cost=0.87..111.89 rows=10 width=37) Output: a.dwmc, a.dwbh, a.dwdz, t1.grbh, t2.je, t1.dwbh -> Nested Loop (cost=0.58..28.69 rows=10 width=29) Output: a.dwmc, a.dwbh, a.dwdz, t1.grbh, t1.dwbh -> Index Scan using t_dwxx_pkey on public.t_dwxx a (cost=0.29..8.30 rows=1 width=20) Output: a.dwmc, a.dwbh, a.dwdz Index Cond: ((a.dwbh)::text = '1001'::text) -> Index Scan using idx_t_grxx_dwbh on public.t_grxx t1 (cost=0.29..20.29 rows=10 width=9) Output: t1.dwbh, t1.grbh, t1.xm, t1.xb, t1.nl Index Cond: ((t1.dwbh)::text = '1001'::text) -> Index Scan using idx_t_jfxx_grbh on public.t_jfxx t2 (cost=0.29..8.31 rows=1 width=13) Output: t2.grbh, t2.ny, t2.je Index Cond: ((t2.grbh)::text = (t1.grbh)::text)
启动gdb跟踪
(gdb) b make_rel_from_joinlist Breakpoint 1 at 0x73f0d3: file allpaths.c, line 2617. (gdb) c Continuing. Breakpoint 1, make_rel_from_joinlist (root=0x176c750, joinlist=0x179e480) at allpaths.c:2617 2617 levels_needed = list_length(joinlist);
进入make_rel_from_joinlist函数,查看joinlist,链表中的Node为RangeTblRef,rindex分别是1/3/4
(gdb) p *joinlist $1 = {type = T_List, length = 3, head = 0x17a0448, tail = 0x17a0408} (gdb) p *(Node *)joinlist->head->data.ptr_value $2 = {type = T_RangeTblRef} (gdb) p *(RangeTblRef *)joinlist->head->data.ptr_value $3 = {type = T_RangeTblRef, rtindex = 1} (gdb) p *(RangeTblRef *)joinlist->head->next->data.ptr_value $4 = {type = T_RangeTblRef, rtindex = 3} (gdb) p *(RangeTblRef *)joinlist->head->next->next->data.ptr_value $5 = {type = T_RangeTblRef, rtindex = 4}
链表中的Node个数为3,levels_needed=3
(gdb) n 2619 if (levels_needed <= 0) (gdb) p levels_needed $6 = 3
遍历链表,构造RelOptInfo,添加到initial_rels中
(gdb) 2628 foreach(jl, joinlist) ... (gdb) 2637 thisrel = find_base_rel(root, varno); (gdb) 2651 initial_rels = lappend(initial_rels, thisrel);
完成遍历后,开始构造连接路径.
遗传算法的rels阈值为12(通过GUC参数配置)
2672 if (join_search_hook) (gdb) 2674 else if (enable_geqo && levels_needed >= geqo_threshold) (gdb) 2677 return standard_join_search(root, levels_needed, initial_rels); (gdb) p geqo_threshold $7 = 12
进入函数standard_join_search
(gdb) step standard_join_search (root=0x176c750, levels_needed=3, initial_rels=0x17a6308) at allpaths.c:2733 2733 root->join_rel_level = (List **) palloc0((levels_needed + 1) * sizeof(List *));
开始构造2->N个item对应的rel链表
... (gdb) 2746 join_search_one_level(root, lev); (gdb) n 2757 foreach(lc, root->join_rel_level[lev])
调用函数join_search_one_level,查看root->join_rel_level[j]
(gdb) p *root->join_rel_level[2] $10 = {type = T_List, length = 2, head = 0x17a67a8, tail = 0x17a6ec0}
查看链表中的RelOptInfo
(gdb) p *(RelOptInfo *)root->join_rel_level[2]->head->data.ptr_value $12 = {type = T_RelOptInfo, reloptkind = RELOPT_JOINREL, relids = 0x17a65d0, rows = 10, consider_startup = false, consider_param_startup = false, consider_parallel = true, reltarget = 0x17a65e8, pathlist = 0x17a68a8, ppilist = 0x0, partial_pathlist = 0x0, cheapest_startup_path = 0x0, cheapest_total_path = 0x0, cheapest_unique_path = 0x0, cheapest_parameterized_paths = 0x0, direct_lateral_relids = 0x0, lateral_relids = 0x0, relid = 0, reltablespace = 0, rtekind = RTE_JOIN, min_attr = 0, max_attr = 0, attr_needed = 0x0, attr_widths = 0x0, lateral_vars = 0x0, lateral_referencers = 0x0, indexlist = 0x0, statlist = 0x0, pages = 0, tuples = 0, allvisfrac = 0, subroot = 0x0, subplan_params = 0x0, rel_parallel_workers = -1, serverid = 0, userid = 0, useridiscurrent = false, fdwroutine = 0x0, fdw_private = 0x0, unique_for_rels = 0x0, non_unique_for_rels = 0x0, baserestrictinfo = 0x0, baserestrictcost = { startup = 0, per_tuple = 0}, baserestrict_min_security = 4294967295, joininfo = 0x0, has_eclass_joins = true, top_parent_relids = 0x0, part_scheme = 0x0, nparts = 0, boundinfo = 0x0, partition_qual = 0x0, part_rels = 0x0, partexprs = 0x0, nullable_partexprs = 0x0, partitioned_child_rels = 0x0} (gdb) p *(RelOptInfo *)root->join_rel_level[2]->head->next->data.ptr_value $13 = {type = T_RelOptInfo, reloptkind = RELOPT_JOINREL, relids = 0x17a68d8, rows = 10, consider_startup = false, consider_param_startup = false, consider_parallel = true, reltarget = 0x17a6cd0, pathlist = 0x17a7720, ppilist = 0x0, partial_pathlist = 0x0, cheapest_startup_path = 0x0, cheapest_total_path = 0x0, cheapest_unique_path = 0x0, cheapest_parameterized_paths = 0x0, direct_lateral_relids = 0x0, lateral_relids = 0x0, relid = 0, reltablespace = 0, rtekind = RTE_JOIN, min_attr = 0, max_attr = 0, attr_needed = 0x0, attr_widths = 0x0, lateral_vars = 0x0, lateral_referencers = 0x0, indexlist = 0x0, statlist = 0x0, pages = 0, tuples = 0, allvisfrac = 0, subroot = 0x0, subplan_params = 0x0, rel_parallel_workers = -1, serverid = 0, userid = 0, useridiscurrent = false, fdwroutine = 0x0, fdw_private = 0x0, unique_for_rels = 0x0, non_unique_for_rels = 0x0, baserestrictinfo = 0x0, baserestrictcost = { startup = 0, per_tuple = 0}, baserestrict_min_security = 4294967295, joininfo = 0x0, has_eclass_joins = true, top_parent_relids = 0x0, part_scheme = 0x0, nparts = 0, boundinfo = 0x0, partition_qual = 0x0, part_rels = 0x0, partexprs = 0x0, nullable_partexprs = 0x0, partitioned_child_rels = 0x0}
查看RelOptInfo中的relids
通过relids可知,第一个RelOptInfo是1/3号rel连接生成的Relation,第二个RelOptInfo是3/4号rel连接生成的Relation
(gdb) set $roi1=(RelOptInfo *)root->join_rel_level[2]->head->data.ptr_value (gdb) set $roi2=(RelOptInfo *)root->join_rel_level[2]->head->next->data.ptr_value (gdb) p *$roi1->relids $16 = {nwords = 1, words = 0x17a65d4} (gdb) p *$roi1->relids->words $17 = 10 -->2 + 8 --> 1/3 号rel (gdb) p *$roi2->relids->words $18 = 24 -->8 + 16 --> 3/4号rel
查看第一个RelOptInfo中的pathlist,该链表有2个Node,类型均为T_NestPath(嵌套连接),总成本分别是28.69和4308.57
(gdb) p *$roi1->pathlist $19 = {type = T_List, length = 2, head = 0x17a6888, tail = 0x17a6a10} (gdb) p *(Node *)$roi1->pathlist->head->data.ptr_value $20 = {type = T_NestPath} (gdb) p *(NestPath *)$roi1->pathlist->head->data.ptr_value $21 = {path = {type = T_NestPath, pathtype = T_NestLoop, parent = 0x17a63c0, pathtarget = 0x17a65e8, param_info = 0x0, parallel_aware = false, parallel_safe = true, parallel_workers = 0, rows = 10, startup_cost = 0.57750000000000001, total_cost = 28.688484322533327, pathkeys = 0x0}, jointype = JOIN_INNER, inner_unique = false, outerjoinpath = 0x17a2638, innerjoinpath = 0x17a2908, joinrestrictinfo = 0x0} (gdb) p *(Node *)$roi1->pathlist->head->next->data.ptr_value $22 = {type = T_NestPath} (gdb) p *(NestPath *)$roi1->pathlist->head->next->data.ptr_value $23 = {path = {type = T_NestPath, pathtype = T_NestLoop, parent = 0x17a63c0, pathtarget = 0x17a65e8, param_info = 0x0, parallel_aware = false, parallel_safe = true, parallel_workers = 0, rows = 10, startup_cost = 0.57750000000000001, total_cost = 4308.5748727883229, pathkeys = 0x17a3650}, jointype = JOIN_INNER, inner_unique = false, outerjoinpath = 0x17a3190, innerjoinpath = 0x17a68f0, joinrestrictinfo = 0x0}
查看第二个RelOptInfo中的pathlist,只有1个Node,类型为T_NestPath(嵌套连接),总成本为103.49
(gdb) p *$roi2->pathlist $24 = {type = T_List, length = 1, head = 0x17a7700, tail = 0x17a7700} (gdb) p *(Node *)$roi2->pathlist->head->data.ptr_value $27 = {type = T_NestPath} (gdb) p *(NestPath *)$roi2->pathlist->head->data.ptr_value $28 = {path = {type = T_NestPath, pathtype = T_NestLoop, parent = 0x17a6ac0, pathtarget = 0x17a6cd0, param_info = 0x0, parallel_aware = false, parallel_safe = true, parallel_workers = 0, rows = 10, startup_cost = 0.58499999999999996, total_cost = 103.48598432253331, pathkeys = 0x0}, jointype = JOIN_INNER, inner_unique = false, outerjoinpath = 0x17a2908, innerjoinpath = 0x17a5470, joinrestrictinfo = 0x0}
通过set_cheapest函数设置成本最低的访问路径,结果存储在cheapest_startup_path和cheapest_total_path中
(gdb) 2773 set_cheapest(rel); (gdb) 2757 foreach(lc, root->join_rel_level[lev]) ... (gdb) p *$roi1 $35 = ..., cheapest_startup_path = 0x17a67f8, cheapest_total_path = 0x17a67f8, ... (gdb) p *$roi2 $36 =..., cheapest_startup_path = 0x17a7750, cheapest_total_path = 0x17a7750, ...
继续循环,这时候lev=3
(gdb) n 2737 for (lev = 2; lev <= levels_needed; lev++) (gdb) n 2746 join_search_one_level(root, lev); (gdb) p lev $38 = 3
得到3张表连接的final_rel
(gdb) p *root->join_rel_level[3] $41 = {type = T_List, length = 1, head = 0x17a8090, tail = 0x17a8090} (gdb) p *(RelOptInfo *)root->join_rel_level[3]->head->data.ptr_value $42 = {type = T_RelOptInfo, reloptkind = RELOPT_JOINREL, relids = 0x17a74d8, rows = 10, consider_startup = false, consider_param_startup = false, consider_parallel = true, reltarget = 0x17a7e40, pathlist = 0x17a8258, ppilist = 0x0, partial_pathlist = 0x0, cheapest_startup_path = 0x0, cheapest_total_path = 0x0, cheapest_unique_path = 0x0, cheapest_parameterized_paths = 0x0, direct_lateral_relids = 0x0, lateral_relids = 0x0, relid = 0, reltablespace = 0, rtekind = RTE_JOIN, min_attr = 0, max_attr = 0, attr_needed = 0x0, attr_widths = 0x0, lateral_vars = 0x0, lateral_referencers = 0x0, indexlist = 0x0, statlist = 0x0, pages = 0, tuples = 0, allvisfrac = 0, subroot = 0x0, subplan_params = 0x0, rel_parallel_workers = -1, serverid = 0, userid = 0, useridiscurrent = false, fdwroutine = 0x0, fdw_private = 0x0, unique_for_rels = 0x0, non_unique_for_rels = 0x0, baserestrictinfo = 0x0, baserestrictcost = { startup = 0, per_tuple = 0}, baserestrict_min_security = 4294967295, joininfo = 0x0, has_eclass_joins = false, top_parent_relids = 0x0, part_scheme = 0x0, nparts = 0, boundinfo = 0x0, partition_qual = 0x0, part_rels = 0x0, partexprs = 0x0, nullable_partexprs = 0x0, partitioned_child_rels = 0x0}
查看pathlist,只有1个元素,类型为NestPath,该访问路径成本为111.89
(gdb) set $roi=(RelOptInfo *)root->join_rel_level[3]->head->data.ptr_value (gdb) p *$roi->pathlist $44 = {type = T_List, length = 1, head = 0x17a8238, tail = 0x17a8238} (gdb) p *(Node *)$roi->pathlist->head->data.ptr_value $45 = {type = T_NestPath} (gdb) p *(NestPath *)$roi->pathlist->head->data.ptr_value $46 = {path = {type = T_NestPath, pathtype = T_NestLoop, parent = 0x17a7c30, pathtarget = 0x17a7e40, param_info = 0x0, parallel_aware = false, parallel_safe = true, parallel_workers = 0, rows = 10, startup_cost = 0.87, total_cost = 111.88848432253332, pathkeys = 0x0}, jointype = JOIN_INNER, inner_unique = false, outerjoinpath = 0x17a67f8, innerjoinpath = 0x17a5470, joinrestrictinfo = 0x0}
获得最终结果
... 2792 return rel; (gdb) p *rel $47 = {type = T_RelOptInfo, reloptkind = RELOPT_JOINREL, relids = 0x17a74d8, rows = 10, consider_startup = false, consider_param_startup = false, consider_parallel = true, reltarget = 0x17a7e40, pathlist = 0x17a8258, ppilist = 0x0, partial_pathlist = 0x0, cheapest_startup_path = 0x17a8318, cheapest_total_path = 0x17a8318, cheapest_unique_path = 0x0, cheapest_parameterized_paths = 0x17a89b0, direct_lateral_relids = 0x0, lateral_relids = 0x0, relid = 0, reltablespace = 0, rtekind = RTE_JOIN, min_attr = 0, max_attr = 0, attr_needed = 0x0, attr_widths = 0x0, lateral_vars = 0x0, lateral_referencers = 0x0, indexlist = 0x0, statlist = 0x0, pages = 0, tuples = 0, allvisfrac = 0, subroot = 0x0, subplan_params = 0x0, rel_parallel_workers = -1, serverid = 0, userid = 0, useridiscurrent = false, fdwroutine = 0x0, fdw_private = 0x0, unique_for_rels = 0x0, non_unique_for_rels = 0x0, baserestrictinfo = 0x0, baserestrictcost = {startup = 0, per_tuple = 0}, baserestrict_min_security = 4294967295, joininfo = 0x0, has_eclass_joins = false, top_parent_relids = 0x0, part_scheme = 0x0, nparts = 0, boundinfo = 0x0, partition_qual = 0x0, part_rels = 0x0, partexprs = 0x0, nullable_partexprs = 0x0, partitioned_child_rels = 0x0} (gdb) p *rel->cheapest_total_path $48 = {type = T_NestPath, pathtype = T_NestLoop, parent = 0x17a7c30, pathtarget = 0x17a7e40, param_info = 0x0, parallel_aware = false, parallel_safe = true, parallel_workers = 0, rows = 10, startup_cost = 0.87, total_cost = 111.88848432253332, pathkeys = 0x0}
到此,关于“PostgreSQL中make_rel_from_joinlist函数分析”的学习就结束了,希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习,快去试试吧!若想继续学习更多相关知识,请继续关注创新互联网站,小编会继续努力为大家带来更多实用的文章!