0 总结
对于SQL:select * from student, (select * from score where sno > 2) s where student.sno = s.sno;
pullup在pull_up_subqueries函数内递归完成,分几步:
- 将内层rte score追加到上层rtbable中:rte1是student、rte2带subquery是子查询、rte3是score。
- 调整所有var的varno(从1指向3)、varlevelsup(本例不涉及);还有其他调整本例不涉及。
- 将上层代表子查询的rte2的subquery清空,但rte2不删除。
- 将上层jointree中,指向子查询的rte替换为 子查询中的FromExpr(sno > 2)。
1 待分析场景
sql
drop table student;
create table student(sno int, sname varchar(10), ssex int);
insert into student values(1, 'stu1', 0);
insert into student values(2, 'stu2', 1);
insert into student values(3, 'stu3', 1);
insert into student values(4, 'stu4', 0);
drop table course;
create table course(cno int, cname varchar(10), tno int);
insert into course values(10, 'meth', 1);
insert into course values(11, 'english', 2);
drop table teacher;
create table teacher(tno int, tname varchar(10), tsex int);
insert into teacher values(1, 'te1', 1);
insert into teacher values(2, 'te2', 0);
drop table score;
create table score (sno int, cno int, degree int);
insert into score values (1, 10, 100);
insert into score values (1, 11, 89);
insert into score values (2, 10, 99);
insert into score values (2, 11, 90);
insert into score values (3, 10, 87);
insert into score values (3, 11, 20);
insert into score values (4, 10, 60);
insert into score values (4, 11, 70);
带子查询的语句:select * from student, (select * from score where sno > 2) s where student.sno = s.sno;
sql
set enable_hashjoin to off;
set enable_mergejoin to off;
explain select * from student, (select * from score where sno > 2) s where student.sno = s.sno;
QUERY PLAN
---------------------------------------------------------------------
Nested Loop (cost=0.00..11278.20 rows=3740 width=58)
Join Filter: (student.sno = score.sno)
-> Seq Scan on student (cost=0.00..21.00 rows=1100 width=46)
-> Materialize (cost=0.00..38.90 rows=680 width=12)
-> Seq Scan on score (cost=0.00..35.50 rows=680 width=12)
Filter: (sno > 2)
||||||||||
||等价写法||
vvvvvvvvvvv
explain select * from student, score where score.sno > 2 and student.sno = score.sno;
QUERY PLAN
---------------------------------------------------------------------
Nested Loop (cost=0.00..11278.20 rows=3740 width=58)
Join Filter: (student.sno = score.sno)
-> Seq Scan on student (cost=0.00..21.00 rows=1100 width=46)
-> Materialize (cost=0.00..38.90 rows=680 width=12)
-> Seq Scan on score (cost=0.00..35.50 rows=680 width=12)
Filter: (sno > 2)
pull_up_subqueries做的事情就是帮我们把子查询上拉了,下面分析上拉是如何做的。
select * from student, (select * from score where sno > 2) s where student.sno = s.sno;
Plannerinfo完整结构
注意pull_up_subqueries只对jointree做处理。
c
void
pull_up_subqueries(PlannerInfo *root)
{
/* Top level of jointree must always be a FromExpr */
Assert(IsA(root->parse->jointree, FromExpr));
/* Recursion starts with no containing join nor appendrel */
root->parse->jointree = (FromExpr *)
pull_up_subqueries_recurse(root, (Node *) root->parse->jointree,
NULL, NULL);
/* We should still have a FromExpr */
Assert(IsA(root->parse->jointree, FromExpr));
}
2 pull_up_subqueries流程分析
2.1 处理FromExpr下面挂的第一个RANGETBLREF(student表)
FromExpr的第一张表是student表,指向一个rtekind = RTE_RELATION
普通表类型,无需做任何处理。
2.2 处理FromExpr下面挂的第二个RANGETBLREF(子查询)
FromExpr的第二个rte是子查询(select * from score where sno > 2) s
,可以看到引用的rte结构的subquery指向了内层query:
开始进入pull_up_simple_subquery内部处理,进入路径:
在分析pull_up_simple_subquery前有两个准入条件:
-
rte->rtekind == RTE_SUBQUERY
-
is_simple_subquery:不全部列举了,其中重要的是子查询不能带有一些特殊的语法:
is_simple_subquery
...
if (subquery->hasAggs ||
subquery->hasWindowFuncs ||
subquery->hasTargetSRFs ||
subquery->groupClause ||
subquery->groupingSets ||
subquery->havingQual ||
subquery->sortClause ||
subquery->distinctClause ||
subquery->limitOffset ||
subquery->limitCount ||
subquery->hasForUpdate ||
subquery->cteList)
return false;
...
2.3 进入pull_up_simple_subquery开始处理子查上拉
第一步:拿到rte指向的子查询的Query树,构造PlannerInfo开始处理。
static Node *
pull_up_simple_subquery(PlannerInfo *root, Node *jtnode, RangeTblEntry *rte,
JoinExpr *lowest_outer_join,
AppendRelInfo *containing_appendrel)
{
Query *subquery;
Query *parse = root->parse;
PlannerInfo *subroot;
subquery = copyObject(rte->subquery);
subroot = makeNode(PlannerInfo);
subroot->parse = subquery;
...
...
第二步:递归的处理sublink、subquery等。
replace_empty_jointree(subquery);
if (subquery->hasSubLinks)
pull_up_sublinks(subroot);
preprocess_function_rtes(subroot);
pull_up_subqueries(subroot);
第三步:开始pull up
到这里subroot就是rte2的subquery子查询的结构还没有任何调整:
/*
* Adjust level-0 varnos in subquery so that we can append its rangetable
* to upper query's. We have to fix the subquery's append_rel_list as
* well.
*/
rtoffset = list_length(parse->rtable); // 2
OffsetVarNodes((Node *) subquery, rtoffset, 0);
OffsetVarNodes((Node *) subroot->append_rel_list, rtoffset, 0);
parse是上层查询的,上层有两个rtable。因为要把子查询拉平,所以把子查询的varno的指向调整一下,因为是要append到父查询,所以直接加上父查询rte的个数就好了(这里是2)。加完了应该指向父查询rte的3的位置(现在父查询只有两个rte,3位置是空的)。
OffsetVarNodes((Node *) subquery, 2, 0);
-
调整var→varno:1→3。
-
调整rangetblref→rindex:1→3。
/* * Upper-level vars in subquery are now one level closer to their parent * than before. */ IncrementVarSublevelsUp((Node *) subquery, -1, 1); IncrementVarSublevelsUp((Node *) subroot->append_rel_list, -1, 1);
-
这一步调整的目的:因为varlevelsup=1表示引用上一层的列(相当于距离)这里拉平后,varlevelsup就需要-1了,因为距离少了1。
-
在当前SQL中
select * from student, (select * from score where sno > 2) s where student.sno = s.sno;
,开始调整var→varlevelsup字段,注意这个字段表示当前查询中使用了上层的变量,但上面子查询中(select * from score where sno > 2)没有引用上层的任何列,所以子查询中的var→varlevelsup都是0。这一步调整不会有影响。/* * Now append the adjusted rtable entries and their perminfos to upper * query. (We hold off until after fixing the upper rtable entries; no * point in running that code on the subquery ones too.) */ CombineRangeTables(&parse->rtable, &parse->rteperminfos, subquery->rtable, subquery->rteperminfos);
开始把子查询的RTE拷贝到上层,现在子查询里面的varno=3指向就对了。
/*
* We no longer need the RTE's copy of the subquery's query tree. Getting
* rid of it saves nothing in particular so far as this level of query is
* concerned; but if this query level is in turn pulled up into a parent,
* we'd waste cycles copying the now-unused query tree.
*/
rte->subquery = NULL;
删除子查询RTE带的Query,注意现在还缺一个条件。
pull_up_simple_subquery
return (Node *) subquery->jointree;
返回一个jointree带着条件。
返回去后,在这里把fromlist指向的第二个rte(子查询)换成 上面计算好的jointree。
然后就拉平了。
pull_up_subqueries_recurse
...
else if (IsA(jtnode, FromExpr))
{
FromExpr *f = (FromExpr *) jtnode;
ListCell *l;
Assert(containing_appendrel == NULL);
/* Recursively transform all the child nodes */
foreach(l, f->fromlist)
{
lfirst(l) = pull_up_subqueries_recurse(root, lfirst(l),
lowest_outer_join,
NULL);
}
}
最终效果对比
pullup前 vs pullup后