本篇内容介绍了“postgresql中create_plan函数连接计划的实现过程是什么”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望
本篇内容介绍了“postgresql中create_plan函数连接计划的实现过程是什么”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！
Plan
所有计划节点通过将Plan结构作为第一个字段从Plan结构“派生”。这确保了在将节点转换为计划节点时能正常工作。(在执行器中以通用方式传递时，节点指针经常被转换为Plan *)
typedef struct Plan
{
nodeTag type;//节点类型
Cost startup_cost;
Cost total_cost;
double plan_rows;
int plan_width;
bool parallel_aware;
bool parallel_safe;
int plan_node_id;
List *targetlist;
List *qual;
struct Plan *lefttree;
struct Plan *righttree;
List *initPlan;
Bitmapset *extParam;
Bitmapset *allParam;
} Plan;create_join_plan函数创建Join Plan节点.Join可以分为Merge Join/Hash Join/NestLoop Join三种,相应的实现函数是create_nestloop_plan/create_mergejoin_plan/create_hashjoin_plan.
//------------------------------------------------------------------ create_join_plan
static Plan *
create_join_plan(PlannerInfo *root, JoinPath *best_path)
{
Plan *plan;
List *gating_clauses;
switch (best_path->path.pathtype)
{
case T_MergeJoin://Merge Join
plan = (Plan *) create_mergejoin_plan(root,
(MergePath *) best_path);
break;
case T_HashJoin://Hash Join
plan = (Plan *) create_hashjoin_plan(root,
(HashPath *) best_path);
break;
case T_NestLoop://NestLoop Join
plan = (Plan *) create_nestloop_plan(root,
(NestPath *) best_path);
break;
default://目前仅支持上述三种
elog(ERROR, "unrecognized node type: %d",
(int) best_path->path.pathtype);
plan = NULL;
break;
}
gating_clauses = get_gating_quals(root, best_path->joinrestrictinfo);
if (gating_clauses)
plan = create_gating_plan(root, (Path *) best_path, plan,
gating_clauses);
#ifdef NOT_USED
if (get_loc_restrictinfo(best_path) != NIL)
set_qpqual((Plan) plan,
list_concat(get_qpqual((Plan) plan),
get_actual_clauses(get_loc_restrictinfo(best_path))));
#endif
return plan;
}
//------------------------------------------ create_nestloop_plan
static NestLoop *
create_nestloop_plan(PlannerInfo *root,
NestPath *best_path)
{
NestLoop *join_plan;
Plan *outer_plan;
Plan *inner_plan;
List *tlist = build_path_tlist(root, &best_path->path);
List *joinrestrictclauses = best_path->joinrestrictinfo;
List *joinclauses;
List *otherclauses;
Relids outerrelids;
List *nestParams;
Relids saveOuterRels = root->curOuterRels;
ListCell *cell;
ListCell *prev;
ListCell *next;
//NestLoop可以执行投影操作,所以不需要关心子计划的tlists
//递归调用生成外表计划
outer_plan = create_plan_recurse(root, best_path->outerjoinpath, 0);
//对于nestloop,对应内侧的curOuterRels中需要包含外表的relids
root->curOuterRels = bms_uNIOn(root->curOuterRels,
best_path->outerjoinpath->parent->relids);
//递归调用生成内表计划
inner_plan = create_plan_recurse(root, best_path->innerjoinpath, 0);
//恢复curOuterRels
bms_free(root->curOuterRels);
root->curOuterRels = saveOuterRels;
//排序连接条件
joinrestrictclauses = order_qual_clauses(root, joinrestrictclauses);
//获取连接条件子句,在这里,会忽略伪常量
if (IS_OUTER_JOIN(best_path->jointype))
{
extract_actual_join_clauses(joinrestrictclauses,
best_path->path.parent->relids,
&joinclauses, &otherclauses);//外连接
}
else
{
//内连接
joinclauses = extract_actual_clauses(joinrestrictclauses, false);
otherclauses = NIL;
}
//使用nestloop参数替代外表变量
if (best_path->path.param_info)
{
joinclauses = (List *)
replace_nestloop_params(root, (Node *) joinclauses);
otherclauses = (List *)
replace_nestloop_params(root, (Node *) otherclauses);
}
outerrelids = best_path->outerjoinpath->parent->relids;
nestParams = NIL;
prev = NULL;
for (cell = list_head(root->curOuterParams); cell; cell = next)//遍历curOuterParams
{
NestLoopParam *NLP = (NestLoopParam *) lfirst(cell);//获取参数
next = lnext(cell);
if (IsA(nlp->paramval, Var) &&
bms_is_member(nlp->paramval->varno, outerrelids))//Var变量,而且是外层的relids
{
root->curOuterParams = list_delete_cell(root->curOuterParams,
cell, prev);
nestParams = lappend(nestParams, nlp);
}
else if (IsA(nlp->paramval, PlaceHolderVar) &&//PHV
bms_overlap(((PlaceHolderVar *) nlp->paramval)->phrels,
outerrelids) &&
bms_is_subset(find_placeholder_info(root,
(PlaceHolderVar *) nlp->paramval,
false)->ph_eval_at,
outerrelids))
{
root->curOuterParams = list_delete_cell(root->curOuterParams,
cell, prev);
nestParams = lappend(nestParams, nlp);
}
else
prev = cell;//直接赋值
}
join_plan = make_nestloop(tlist,
joinclauses,
otherclauses,
nestParams,
outer_plan,
inner_plan,
best_path->jointype,
best_path->inner_unique);//构造nestloop访问节点
copy_generic_path_info(&join_plan->join.plan, &best_path->path);
return join_plan;
}
//------------------------------------------ create_mergejoin_plan
static MergeJoin *
create_mergejoin_plan(PlannerInfo *root,
MergePath *best_path)
{
MergeJoin *join_plan;
Plan *outer_plan;
Plan *inner_plan;
List *tlist = build_path_tlist(root, &best_path->jpath.path);
List *joinclauses;
List *otherclauses;
List *mergeclauses;
List *outerpathkeys;
List *innerpathkeys;
int nClauses;
Oid *mergefamilies;
Oid *mergecollations;
int *mergestrategies;
bool *mergenullsfirst;
PathKey *opathkey;
EquivalenceClass *opeclass;
int i;
ListCell *lc;
ListCell *lop;
ListCell *lip;
Path *outer_path = best_path->jpath.outerjoinpath;
Path *inner_path = best_path->jpath.innerjoinpath;
//对外表生成计划Plan
outer_plan = create_plan_recurse(root, best_path->jpath.outerjoinpath,
(best_path->outersorTKEys != NIL) ? CP_SMALL_TLIST : 0);
//对内部生成计划Plan
inner_plan = create_plan_recurse(root, best_path->jpath.innerjoinpath,
(best_path->innersortkeys != NIL) ? CP_SMALL_TLIST : 0);
//排序连接条件
joinclauses = order_qual_clauses(root, best_path->jpath.joinrestrictinfo);
//获取连接约束条件子句(以扁平化的形式)
if (IS_OUTER_JOIN(best_path->jpath.jointype))
{
extract_actual_join_clauses(joinclauses,
best_path->jpath.path.parent->relids,
&joinclauses, &otherclauses);
}
else
{
//以内连接的方式处理所有条件子句
joinclauses = extract_actual_clauses(joinclauses, false);
otherclauses = NIL;
}
mergeclauses = get_actual_clauses(best_path->path_mergeclauses);
joinclauses = list_difference(joinclauses, mergeclauses);
if (best_path->jpath.path.param_info)
{
joinclauses = (List *)
replace_nestloop_params(root, (Node *) joinclauses);//连接条件
otherclauses = (List *)
replace_nestloop_params(root, (Node *) otherclauses);//其他条件
}
mergeclauses = get_switched_clauses(best_path->path_mergeclauses,
best_path->jpath.outerjoinpath->parent->relids);
if (best_path->outersortkeys)
{
Relids outer_relids = outer_path->parent->relids;
Sort *sort = make_sort_from_pathkeys(outer_plan,
best_path->outersortkeys,
outer_relids);
label_sort_with_costsize(root, sort, -1.0);
outer_plan = (Plan *) sort;
outerpathkeys = best_path->outersortkeys;
}
else
outerpathkeys = best_path->jpath.outerjoinpath->pathkeys;
if (best_path->innersortkeys)
{
Relids inner_relids = inner_path->parent->relids;
Sort *sort = make_sort_from_pathkeys(inner_plan,
best_path->innersortkeys,
inner_relids);
label_sort_with_costsize(root, sort, -1.0);
inner_plan = (Plan *) sort;
innerpathkeys = best_path->innersortkeys;
}
else
innerpathkeys = best_path->jpath.innerjoinpath->pathkeys;
if (best_path->materialize_inner)
{
Plan *matplan = (Plan *) make_material(inner_plan);
copy_plan_costsize(matplan, inner_plan);
matplan->total_cost += cpu_operator_cost * matplan->plan_rows;
inner_plan = matplan;
}
nClauses = list_length(mergeclauses);
Assert(nClauses == list_length(best_path->path_mergeclauses));
mergefamilies = (Oid *) palloc(nClauses * sizeof(Oid));//申请内存
mergecollations = (Oid *) palloc(nClauses * sizeof(Oid));
mergestrategies = (int *) palloc(nClauses * sizeof(int));
mergenullsfirst = (bool *) palloc(nClauses * sizeof(bool));
opathkey = NULL;
opeclass = NULL;
lop = list_head(outerpathkeys);
lip = list_head(innerpathkeys);
i = 0;
foreach(lc, best_path->path_mergeclauses)//遍历条件
{
RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
EquivalenceClass *oeclass;
EquivalenceClass *ieclass;
PathKey *ipathkey = NULL;
EquivalenceClass *ipeclass = NULL;
bool first_inner_match = false;
//从mergeclause中获取outer/inner等价类
if (rinfo->outer_is_left)
{
oeclass = rinfo->left_ec;
ieclass = rinfo->right_ec;
}
else
{
oeclass = rinfo->right_ec;
ieclass = rinfo->left_ec;
}
Assert(oeclass != NULL);
Assert(ieclass != NULL);
if (oeclass != opeclass)
{
//与当前的opathkey不匹配,那么必须与接下来的匹配
if (lop == NULL)
elog(ERROR, "outer pathkeys do not match mergeclauses");
opathkey = (PathKey *) lfirst(lop);
opeclass = opathkey->pk_eclass;
lop = lnext(lop);
if (oeclass != opeclass)
elog(ERROR, "outer pathkeys do not match mergeclauses");
}
if (lip)
{
ipathkey = (PathKey *) lfirst(lip);
ipeclass = ipathkey->pk_eclass;
if (ieclass == ipeclass)
{
//成功匹配
lip = lnext(lip);
first_inner_match = true;
}
}
if (!first_inner_match)
{
//多余的条件子句,必须在lip前匹配某些pathkey
ListCell *l2;
foreach(l2, innerpathkeys)
{
if (l2 == lip)
break;
ipathkey = (PathKey *) lfirst(l2);
ipeclass = ipathkey->pk_eclass;
if (ieclass == ipeclass)
break;
}
if (ieclass != ipeclass)
elog(ERROR, "inner pathkeys do not match mergeclauses");
}
if (opathkey->pk_opfamily != ipathkey->pk_opfamily ||
opathkey->pk_eclass->ec_collation != ipathkey->pk_eclass->ec_collation)
elog(ERROR, "left and right pathkeys do not match in mergejoin");
if (first_inner_match &&
(opathkey->pk_strategy != ipathkey->pk_strategy ||
opathkey->pk_nulls_first != ipathkey->pk_nulls_first))
elog(ERROR, "left and right pathkeys do not match in mergejoin");
mergefamilies[i] = opathkey->pk_opfamily;
mergecollations[i] = opathkey->pk_eclass->ec_collation;
mergestrategies[i] = opathkey->pk_strategy;
mergenullsfirst[i] = opathkey->pk_nulls_first;
i++;
}
join_plan = make_mergejoin(tlist,
joinclauses,
otherclauses,
mergeclauses,
mergefamilies,
mergecollations,
mergestrategies,
mergenullsfirst,
outer_plan,
inner_plan,
best_path->jpath.jointype,
best_path->jpath.inner_unique,
best_path->skip_mark_restore);
//排序和物化步骤一包含在访问路径的成本中
copy_generic_path_info(&join_plan->join.plan, &best_path->jpath.path);
return join_plan;
}
//------------------------------------------ create_hashjoin_plan
static HashJoin *
create_hashjoin_plan(PlannerInfo *root,
HashPath *best_path)
{
HashJoin *join_plan;
Hash *hash_plan;
Plan *outer_plan;
Plan *inner_plan;
List *tlist = build_path_tlist(root, &best_path->jpath.path);
List *joinclauses;
List *otherclauses;
List *hashclauses;
Oid skewTable = InvalidOid;
AttrNumber skewColumn = InvalidAttrNumber;
bool skewInherit = false;
outer_plan = create_plan_recurse(root, best_path->jpath.outerjoinpath,
(best_path->num_batches > 1) ? CP_SMALL_TLIST : 0);
inner_plan = create_plan_recurse(root, best_path->jpath.innerjoinpath,
CP_SMALL_TLIST);
joinclauses = order_qual_clauses(root, best_path->jpath.joinrestrictinfo);
if (IS_OUTER_JOIN(best_path->jpath.jointype))
{
extract_actual_join_clauses(joinclauses,
best_path->jpath.path.parent->relids,
&joinclauses, &otherclauses);
}
else
{
joinclauses = extract_actual_clauses(joinclauses, false);
otherclauses = NIL;
}
hashclauses = get_actual_clauses(best_path->path_hashclauses);
joinclauses = list_difference(joinclauses, hashclauses);
if (best_path->jpath.path.param_info)
{
joinclauses = (List *)
replace_nestloop_params(root, (Node *) joinclauses);
otherclauses = (List *)
replace_nestloop_params(root, (Node *) otherclauses);
}
hashclauses = get_switched_clauses(best_path->path_hashclauses,
best_path->jpath.outerjoinpath->parent->relids);
if (list_length(hashclauses) == 1)
{
OpExpr *clause = (OpExpr *) linitial(hashclauses);
Node *node;
Assert(is_opclause(clause));
node = (Node *) linitial(clause->args);
if (IsA(node, RelabelType))
node = (Node *) ((RelabelType *) node)->arg;
if (IsA(node, Var))
{
Var *var = (Var *) node;
RangeTblEntry *rte;
rte = root->simple_rte_array[var->varno];
if (rte->rtekind == RTE_RELATION)
{
skewTable = rte->relid;
skewColumn = var->varattno;
skewInherit = rte->inh;
}
}
}
hash_plan = make_hash(inner_plan,
skewTable,
skewColumn,
skewInherit);//为内表创建hash表
copy_plan_costsize(&hash_plan->plan, inner_plan);
hash_plan->plan.startup_cost = hash_plan->plan.total_cost;
if (best_path->jpath.path.parallel_aware)
{
hash_plan->plan.parallel_aware = true;
hash_plan->rows_total = best_path->inner_rows_total;
}
join_plan = make_hashjoin(tlist,
joinclauses,
otherclauses,
hashclauses,
outer_plan,
(Plan *) hash_plan,
best_path->jpath.jointype,
best_path->jpath.inner_unique);//创建hash join节点
copy_generic_path_info(&join_plan->join.plan, &best_path->jpath.path);
return join_plan;
}测试脚本如下
testdb=# explain select dw.*,grjf.grbh,grjf.xm,grjf.ny,grjf.je
testdb-# from t_dwxx dw,lateral (select gr.grbh,gr.xm,jf.ny,jf.je
testdb(# from t_grxx gr inner join t_jfxx jf
testdb(# on gr.dwbh = dw.dwbh
testdb(# and gr.grbh = jf.grbh) grjf
testdb-# where dw.dwbh in ('1001','1002')
testdb-# order by dw.dwbh;
QUERY PLAN
--------------------------------------------------------------------------------------------------
Sort (cost=2010.12..2010.17 rows=20 width=47)
Sort Key: dw.dwbh
-> Nested Loop (cost=14.24..2009.69 rows=20 width=47)
-> Hash Join (cost=13.95..2002.56 rows=20 width=32)
Hash Cond: ((gr.dwbh)::text = (dw.dwbh)::text)
-> Seq Scan on t_grxx gr (cost=0.00..1726.00 rows=100000 width=16)
-> Hash (cost=13.92..13.92 rows=2 width=20)
-> Index Scan using t_dwxx_pkey on t_dwxx dw (cost=0.29..13.92 rows=2 width=20)
Index Cond: ((dwbh)::text = ANY ('{1001,1002}'::text[]))
-> Index Scan using idx_t_jfxx_grbh on t_jfxx jf (cost=0.29..0.35 rows=1 width=20)
Index Cond: ((grbh)::text = (gr.grbh)::text)启动gdb,设置断点,进入create_join_plan函数
(gdb) b create_join_plan
Breakpoint 1 at 0x7b8426: file createplan.c, line 973.
(gdb) c
Continuing.
Breakpoint 1, create_join_plan (root=0x2ef8a00, best_path=0x2f5ad40) at createplan.c:973
973 switch (best_path->path.pathtype)查看输入参数,pathtype为T_NestLoop
(gdb) p *best_path
$3 = {path = {type = T_NestPath, pathtype = T_NestLoop, parent = 0x2f5a570, pathtarget = 0x2f5a788, param_info = 0x0,
parallel_aware = false, parallel_safe = true, parallel_workers = 0, rows = 20, startup_cost = 14.241722117799656,
total_cost = 2009.6908721177995, pathkeys = 0x0}, jointype = JOIN_INNER, inner_unique = false,
outerjoinpath = 0x2f58bb0, innerjoinpath = 0x2f56080, joinrestrictinfo = 0x0}进入create_nestloop_plan
973 switch (best_path->path.pathtype)
(gdb) n
984 plan = (Plan *) create_nestloop_plan(root,
(gdb) step
create_nestloop_plan (root=0x2f49180, best_path=0x2f5ad40) at createplan.c:3678
3678 List *tlist = build_path_tlist(root, &best_path->path);nestloop join->创建tlist,获取连接条件等
3678 List *tlist = build_path_tlist(root, &best_path->path);
(gdb) n
3679 List *joinrestrictclauses = best_path->joinrestrictinfo;
(gdb)
3684 Relids saveOuterRels = root->curOuterRels;
(gdb) p root->curOuterRels
$1 = (Relids) 0x0nestloop join->调用create_plan_recurse创建outer_plan
(gdb) n
3690 outer_plan = create_plan_recurse(root, best_path->outerjoinpath, 0);
(gdb)
Breakpoint 1, create_join_plan (root=0x2f49180, best_path=0x2f58bb0) at createplan.c:973
973 switch (best_path->path.pathtype)nestloop join->外表对应的outer_plan为T_HashJoin
(gdb) p *best_path
$2 = {path = {type = T_HashPath, pathtype = T_HashJoin, parent = 0x2f572d0, pathtarget = 0x2f57508, param_info = 0x0,
parallel_aware = false, parallel_safe = true, parallel_workers = 0, rows = 20, startup_cost = 13.949222117799655,
total_cost = 2002.5604721177997, pathkeys = 0x0}, jointype = JOIN_INNER, inner_unique = true,
outerjoinpath = 0x2f512f0, innerjoinpath = 0x2f51e98, joinrestrictinfo = 0x2f577a8}
(gdb)nestloop join->进入create_hashjoin_plan
(gdb) n
980 plan = (Plan *) create_hashjoin_plan(root,
(gdb) step
create_hashjoin_plan (root=0x2f49180, best_path=0x2f58bb0) at createplan.c:4093
4093 List *tlist = build_path_tlist(root, &best_path->jpath.path);hash join->创建outer plan
(gdb)
4108 outer_plan = create_plan_recurse(root, best_path->jpath.outerjoinpath,
(gdb) p *best_path->jpath.outerjoinpath
$4 = {type = T_Path, pathtype = T_SeqScan, parent = 0x2f06090, pathtarget = 0x2f062c8, param_info = 0x0,
parallel_aware = false, parallel_safe = true, parallel_workers = 0, rows = 100000, startup_cost = 0, total_cost = 1726,
pathkeys = 0x0}hash join->创建inner plan
(gdb) p *best_path->jpath.innerjoinpath
$5 = {type = T_IndexPath, pathtype = T_IndexScan, parent = 0x2f04b60, pathtarget = 0x2f04d98, param_info = 0x0,
parallel_aware = false, parallel_safe = true, parallel_workers = 0, rows = 2, startup_cost = 0.28500000000000003,
total_cost = 13.924222117799655, pathkeys = 0x2f51e20}hash join->获取连接条件
(gdb) n
4115 joinclauses = order_qual_clauses(root, best_path->jpath.joinrestrictinfo);
(gdb)
4120 if (IS_OUTER_JOIN(best_path->jpath.jointype))
(gdb) p *joinclauses
$6 = {type = T_List, length = 1, head = 0x2f57780, tail = 0x2f57780}hash join->处理连接条件&hash条件
(gdb) n
4137 hashclauses = get_actual_clauses(best_path->path_hashclauses);
(gdb)
4138 joinclauses = list_difference(joinclauses, hashclauses);
(gdb)
4144 if (best_path->jpath.path.param_info)
(gdb) p *hashclauses
$8 = {type = T_List, length = 1, head = 0x2f5d690, tail = 0x2f5d690}
(gdb) p *joinclauses
Cannot access memory at address 0x0hash join->变换位置,把外表的Var放在左侧
(gdb) n
4156 hashclauses = get_switched_clauses(best_path->path_hashclauses,
(gdb)hash join->Hash连接条件只有一个,进行数据倾斜优化
(gdb)
4167 if (list_length(hashclauses) == 1)
(gdb) n
4169 OpExpr *clause = (OpExpr *) linitial(hashclauses);
(gdb) n
4172 Assert(is_opclause(clause));
(gdb)
4173 node = (Node *) linitial(clause->args);
(gdb)
4174 if (IsA(node, RelabelType))
(gdb)
4175 node = (Node *) ((RelabelType *) node)->arg;
(gdb)
4176 if (IsA(node, Var))
(gdb)
4178 Var *var = (Var *) node;
(gdb)
4181 rte = root->simple_rte_array[var->varno];
(gdb) p *node
$9 = {type = T_Var}
(gdb) p *(Var *)node
$10 = {xpr = {type = T_Var}, varno = 3, varattno = 1, vartype = 1043, vartypmod = 14, varcollid = 100, varlevelsup = 0,
varnoold = 3, varoattno = 1, location = 208}
(gdb) n
4182 if (rte->rtekind == RTE_RELATION)
(gdb)
4184 skewTable = rte->relid;
(gdb)
4185 skewColumn = var->varattno;
(gdb)
4186 skewInherit = rte->inh;
(gdb)hash join->开始创建创建hash节点和hash join节点
创建hash节点(构建Hash表)
4194 hash_plan = make_hash(inner_plan,
(gdb) n
4203 copy_plan_costsize(&hash_plan->plan, inner_plan);
(gdb)
4204 hash_plan->plan.startup_cost = hash_plan->plan.total_cost;
(gdb) p *hash_plan
$11 = {plan = {type = T_Hash, startup_cost = 0.28500000000000003, total_cost = 13.924222117799655, plan_rows = 2,
plan_width = 20, parallel_aware = false, parallel_safe = true, plan_node_id = 0, targetlist = 0x2f5d250, qual = 0x0,
lefttree = 0x2f58428, righttree = 0x0, initPlan = 0x0, extParam = 0x0, allParam = 0x0}, skewTable = 16742,
skewColumn = 1, skewInherit = false, rows_total = 0}hash join->创建hash join节点
(gdb) n
4217 join_plan = make_hashjoin(tlist,
(gdb)
4226 copy_generic_path_info(&join_plan->join.plan, &best_path->jpath.path);
(gdb)
4228 return join_plan;
(gdb) p *join_plan
$13 = {join = {plan = {type = T_HashJoin, startup_cost = 13.949222117799655, total_cost = 2002.5604721177997,
plan_rows = 20, plan_width = 32, parallel_aware = false, parallel_safe = true, plan_node_id = 0,
targetlist = 0x2f5cb28, qual = 0x0, lefttree = 0x2f5ae98, righttree = 0x2f5d830, initPlan = 0x0, extParam = 0x0,
allParam = 0x0}, jointype = JOIN_INNER, inner_unique = true, joinqual = 0x0}, hashclauses = 0x2f5d7f8}hash join->回到create_nestloop_plan
(gdb) n
create_nestloop_plan (root=0x2f49180, best_path=0x2f5ad40) at createplan.c:3694
3694 best_path->outerjoinpath->parent->relids);
(gdb) n
3693 root->curOuterRels = bms_union(root->curOuterRels,nestloop join->创建内表Plan
(gdb) n
3696 inner_plan = create_plan_recurse(root, best_path->innerjoinpath, 0);
(gdb) p *best_path->innerjoinpath
$16 = {type = T_IndexPath, pathtype = T_IndexScan, parent = 0x2f06858, pathtarget = 0x2f06a70, param_info = 0x2f56910,
parallel_aware = false, parallel_safe = true, parallel_workers = 0, rows = 1, startup_cost = 0.29249999999999998,
total_cost = 0.34651999999999999, pathkeys = 0x2f56608}nestloop join->获取连接条件子句
(gdb) n
3699 bms_free(root->curOuterRels);
(gdb)
3700 root->curOuterRels = saveOuterRels;
(gdb)
3703 joinrestrictclauses = order_qual_clauses(root, joinrestrictclauses);
(gdb)
3707 if (IS_OUTER_JOIN(best_path->jointype))
(gdb) p *joinrestrictclauses
Cannot access memory at address 0x0nestloop join->获取连接条件&参数化处理(相关值为NULL)
(gdb) n
3716 joinclauses = extract_actual_clauses(joinrestrictclauses, false);
(gdb)
3717 otherclauses = NIL;
(gdb)
3721 if (best_path->path.param_info)
(gdb) p *joinclauses
Cannot access memory at address 0x0
(gdb) p *best_path->path.param_info
Cannot access memory at address 0x0nestloop join->获取外表的relids(外表为1和3号RTE的连接)
(gdb) n
3733 outerrelids = best_path->outerjoinpath->parent->relids;
(gdb)
3734 nestParams = NIL;
(gdb) p *outerrelids
$17 = {nWords = 1, words = 0x2f574ec}
(gdb) p *outerrelids->words
$18 = 10nestloop join->遍历当前的外表参数链表
(gdb) n
3735 prev = NULL;
(gdb)
3736 for (cell = list_head(root->curOuterParams); cell; cell = next)
(gdb) p *root->curOuterParams
$19 = {type = T_List, length = 1, head = 0x2f5df98, tail = 0x2f5df98}nestloop join->查看该参数信息,3号RTE编号为2的字段(即grbh)
(gdb) n
3738 NestLoopParam *nlp = (NestLoopParam *) lfirst(cell);
(gdb)
3740 next = lnext(cell);
(gdb) p *(NestLoopParam *)nlp
$21 = {type = T_NestLoopParam, paramno = 0, paramval = 0x2f54e50}
(gdb) p *nlp->paramval
$22 = {xpr = {type = T_Var}, varno = 3, varattno = 2, vartype = 1043, vartypmod = 14, varcollid = 100, varlevelsup = 0,
varnoold = 3, varoattno = 2, location = 273}nestloop join->把条件从root->curOuterParams移动到nestParams链表中
(gdb) n
3741 if (IsA(nlp->paramval, Var) &&
(gdb) n
3742 bms_is_member(nlp->paramval->varno, outerrelids))
(gdb)
3741 if (IsA(nlp->paramval, Var) &&
(gdb)
3744 root->curOuterParams = list_delete_cell(root->curOuterParams,
(gdb)
3746 nestParams = lappend(nestParams, nlp);
(gdb)
3736 for (cell = list_head(root->curOuterParams); cell; cell = next)
(gdb) p *nestParams
$23 = {type = T_List, length = 1, head = 0x2f5df98, tail = 0x2f5df98}
(gdb) p *(Node *)nestParams->head->data.ptr_value
$24 = {type = T_NestLoopParam}
(gdb) p *(NestLoopParam *)nestParams->head->data.ptr_value
$25 = {type = T_NestLoopParam, paramno = 0, paramval = 0x2f54e50}
(gdb) set $nlp=(NestLoopParam *)nestParams->head->data.ptr_value
(gdb) p $nlp->paramval
$26 = (Var *) 0x2f54e50
(gdb) p *$nlp->paramval
$27 = {xpr = {type = T_Var}, varno = 3, varattno = 2, vartype = 1043, vartypmod = 14, varcollid = 100, varlevelsup = 0,
varnoold = 3, varoattno = 2, location = 273}
(gdb)nestloop join->创建nestloop join节点
(gdb) n
3771 best_path->inner_unique);
(gdb)
3764 join_plan = make_nestloop(tlist,
(gdb)
3773 copy_generic_path_info(&join_plan->join.plan, &best_path->path);
(gdb)
3775 return join_plan;
(gdb) p *join_plan
$28 = {join = {plan = {type = T_NestLoop, startup_cost = 14.241722117799656, total_cost = 2009.6908721177995,
plan_rows = 20, plan_width = 47, parallel_aware = false, parallel_safe = true, plan_node_id = 0,
targetlist = 0x2f5c770, qual = 0x0, lefttree = 0x2f5d8c8, righttree = 0x2f59ed0, initPlan = 0x0, extParam = 0x0,
allParam = 0x0}, jointype = JOIN_INNER, inner_unique = false, joinqual = 0x0}, nestParams = 0x2f5dfc0}
(gdb)“Postgresql中create_plan函数连接计划的实现过程是什么”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注编程网网站，小编将为大家输出更多高质量的实用文章！
--结束END--
本文标题: PostgreSQL中create_plan函数连接计划的实现过程是什么
本文链接: https://lsjlt.com/news/64791.html(转载时请注明来源链接)
有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
2024-10-23
2024-10-22
2024-10-22
2024-10-22
2024-10-22
2024-10-22
2024-10-22
2024-10-22
2024-10-22
2024-10-22
回答
回答
回答
回答
回答
回答
回答
回答
回答
回答
官方手机版
微信公众号
商务合作
0