子查询优化

上拉子连接

上拉子连接主要是把ANY和EXIST子句转换为半连接

  1. void
  2. pull_up_sublinks(PlannerInfo *root)
  3. {
  4.     Node	   *jtnode; //子连接上拉生成的结果
  5.     Relids		relids;
  7.     /* Begin recursion through the jointree ，jointree代表From和join子句*/
  8.     jtnode = pull_up_sublinks_jointree_recurse(root,
  9.                                            (Node *) root->parse->jointree,
  10.                                            &relids);
  12.     //把生成的结果jtnode，放入jointree表达式中
  13.     if (IsA(jtnode, FromExpr))
  14.     	root->parse->jointree = (FromExpr *) jtnode;
  15.     else
  16.     	root->parse->jointree = makeFromExpr(list_make1(jtnode), NULL);
  17. }

pull_up_sublinks_jointree_recurse递归上拉子连接函数

  1. static Node *
  2. pull_up_sublinks_jointree_recurse(PlannerInfo *root, Node *jtnode,
  3. 								  Relids *relids)
  4. {
  5.     if (jtnode == NULL)
  6.     else if (IsA(jtnode, RangeTblRef))//如果是范围表，直接合并到表示关系的relid中
  7.     //处理FromExpr
  8.     else if (IsA(jtnode, FromExpr))
  9.     {
  10.     	/* 递归上拉From中所有子连接 */
  11.     	foreach(l, f->fromlist)
  12.     	{
  13.             newchild = pull_up_sublinks_jointree_recurse(root,
  14.                             lfirst(l),
  15.                             &childrelids);
  16.             //合并上拉的子连接到本层
  17.             newfromlist = lappend(newfromlist, newchild);
  18.             frelids = bms_join(frelids, childrelids);
  19.     	}
  20.     	//递归上拉子连接中的条件
  21.         newf->quals = pull_up_sublinks_qual_recurse(root, f->quals,
  22.     					&jtlink, frelids,
  23.     					NULL, NULL);
  24.     }
  25.     else if (IsA(jtnode, JoinExpr))
  26.     {
  27.     	/* 上拉左右连接中的子连接 */
  28.     	j->larg = pull_up_sublinks_jointree_recurse(root, j->larg,
  29.     						&leftrelids);
  30.     	j->rarg = pull_up_sublinks_jointree_recurse(root, j->rarg,
  31.     						&rightrelids);
  32.     	//递归上拉子连接中的条件
  33.     	switch (j->jointype)
  34.     	{
  35.     		case JOIN_INNER:
  36.     			j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
  37.                 					 &jtlink,
  38.                 					 bms_union(leftrelids,
  39.                 							rightrelids),
  40.                 					 NULL, NULL);
  41.     			break;
  42.     		case JOIN_LEFT:
  43.     			j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
  44. 							 &j->rarg,
  45. 							 rightrelids,
  46. 							 NULL, NULL);
  47.     			break;
  48.     		case JOIN_FULL:
  49.     			/* can't do anything with full-join quals */
  50.     			break;
  51.     		case JOIN_RIGHT:
  52.     			j->quals = pull_up_sublinks_qual_recurse(root, j->quals,
  53. 							 &j->larg,
  54. 							 leftrelids,
  55. 							 NULL, NULL);
  56.     			break;
  57.     		default:
  58.     			elog(ERROR, "unrecognized join type: %d",
  59.     				 (int) j->jointype);
  60.     			break;
  61.     	}
  63.     }
  64.     else
  65.     	elog(ERROR, "unrecognized node type: %d",
  66.     		 (int) nodeTag(jtnode));
  67.     return jtnode;
  68. }

pull_up_sublinks_qual_recurse上拉限制条件中的子连接

用于递归上拉限制条件中存在的子连接(ANY，EXISTS),经过convert_ANY_sublink_to_join转按ANY子连接，经过convert_EXISTS_sublink_to_join消除EXISTS递归消除

  1. static Node *
  2. //node为子连接节点，jtlink1和available_rels1都是上拉后的返回结果
  3. pull_up_sublinks_qual_recurse(PlannerInfo *root, Node *node,
  4.     		  Node **jtlink1, Relids available_rels1,
  5.     		  Node **jtlink2, Relids available_rels2)
  6. {
  7.     if (node == NULL)
  8.     	return NULL;
  9.     if (IsA(node, SubLink))
  10.     {
  11.     	/* 上拉ANY_SUBLINK类型子连接*/
  12.     	if (sublink->subLinkType == ANY_SUBLINK)
  13.     	{
  14.         	if ((j = convert_ANY_sublink_to_join(root, sublink,
  15.         				available_rels1)) != NULL)//上拉ANY子连接成功
  16.         	{
  17.                 //处理刚上拉的右关系
  18.                 j->rarg = pull_up_sublinks_jointree_recurse(root,
  19.                         			j->rarg,
  20.                         			&child_rels);
  22.                 //处理刚刚上拉的子连接
  23.             	j->quals = pull_up_sublinks_qual_recurse(root,
  24.     							 j->quals,
  25.     							 &j->larg,
  26.     							 available_rels1,
  27.     							 &j->rarg,
  28.     							 child_rels);
  29.         		/* Return NULL representing constant TRUE */
  30.         		return NULL;
  31.         	}
  32.         	//处理available_rels2对应项
  33.         	if (available_rels2 != NULL &&
  34.         		(j = convert_ANY_sublink_to_join(root, sublink,
  35. 						 available_rels2)) != NULL)
  37.     	}
  38.     	//上拉EXIST_SUBLINKS对应项
  39.     	else if (sublink->subLinkType == EXISTS_SUBLINK)
  40.     	{
  41.     		if ((j = convert_EXISTS_sublink_to_join(root, sublink, false,
  42. 						available_rels1)) != NULL)
  43.     		{
  44.     		    //基本逻辑和ANY块相同
  45.     		}
  46.     		if (available_rels2 != NULL &&
  47.     			(j = convert_EXISTS_sublink_to_join(root, sublink, false,
  48. 							available_rels2)) != NULL)
  49.     		{
  50.                 //基本逻辑和ANY块相同
  51.     		}
  52.     	}
  53.     	/* Else return it unmodified */
  54.     	return node;
  55.     }
  56.     //处理NOT_EXISTS
  57.     if (not_clause(node))
  58.     {
  59.     }
  60.     if (and_clause(node)) //处理AND每一个子项
  61.     {
  62.     	/* Recurse into AND clause */
  63.     	List	   *newclauses = NIL;
  64.     	ListCell   *l;
  66.     	foreach(l, ((BoolExpr *) node)->args)
  67.     	{
  68.     		Node	   *oldclause = (Node *) lfirst(l);
  69.     		Node	   *newclause;
  71.     		newclause = pull_up_sublinks_qual_recurse(root,
  72. 							  oldclause,
  73. 							  jtlink1,
  74. 							  available_rels1,
  75. 							  jtlink2,
  76. 							  available_rels2);
  77.     		if (newclause)
  78.     			newclauses = lappend(newclauses, newclause);
  79.     	}
  80.     	/* We might have got back fewer clauses than we started with */
  81.     	if (newclauses == NIL)
  82.     		return NULL;
  83.     	else if (list_length(newclauses) == 1)
  84.     		return (Node *) linitial(newclauses);
  85.     	else
  86.     		return (Node *) make_andclause(newclauses);
  87.     }
  88.     /* Stop if not an AND */
  89.     return node;
  90. }

pull_up_sublinks_qual_recurse和pull_up_sublinks_qual_recurse交替调用，穷尽所有ANY/EXISTS类型子连接

convert_ANY_sublink_to_join

ANY(类型包括ANY,NOT ANY,SOME, NOT SOME, IN, NOT IN)

  1. JoinExpr *
  2. convert_ANY_sublink_to_join(PlannerInfo *root, SubLink *sublink,
  3. 							Relids available_rels)
  4. {
  5.     JoinExpr   *result;//子链接转换为连接关系
  7.     Assert(sublink->subLinkType == ANY_SUBLINK);
  9.     //子连接右操作数：不能出现包含上层任何Var对象
  10.     if (contain_vars_of_level((Node *) subselect, 1))
  11.     	return NULL;
  13.     /*子连接左操作数
  14.      *a. 一定与上层出现的Var结构体表示的对象有相同，如果没有，可以直接求解，不用和上层关联
  15.      *b. 不能引用上层出现的关系
  16.      *c. 不能出现易失函数
  17.      */
  18.     upper_varnos = pull_varnos(sublink->testexpr);//情况a
  19.     if (bms_is_empty(upper_varnos))
  20.     	return NULL;
  22.     /*
  23.      * However, it can't refer to anything outside available_rels.
  24.      */
  25.     if (!bms_is_subset(upper_varnos, available_rels))//情况b
  26.     	return NULL;
  28.     /*
  29.      * The combining operators and left-hand expressions mustn't be volatile.
  30.      */
  31.     if (contain_volatile_functions(sublink->testexpr))情况c
  32.     	return NULL;
  34.     /* Create a dummy ParseState for addRangeTableEntryForSubquery */
  35.     pstate = make_parsestate(NULL);
  37.     /*上拉子链接到上层范围表中，作为未来连接的对象 */
  38.     rte = addRangeTableEntryForSubquery(pstate,
  39.     			subselect,
  40.     			makeAlias("ANY_subquery", NIL),
  41.     			false,
  42.     			false);
  43.     parse->rtable = lappend(parse->rtable, rte);
  44.     rtindex = list_length(parse->rtable);
  46.     /*
  47.      * Form a RangeTblRef for the pulled-up sub-select.
  48.      */
  49.     rtr = makeNode(RangeTblRef);
  50.     rtr->rtindex = rtindex;
  52.     /*
  53.      * Build a list of Vars representing the subselect outputs.
  54.      */
  55.     subquery_vars = generate_subquery_vars(root,
  56.     		   subselect->targetList,
  57.     		   rtindex);
  59.     /* 连接条件*/
  60.     quals = convert_testexpr(root, sublink->testexpr, subquery_vars);
  62.     /*
  63.      * And finally, build the JoinExpr node.
  64.      */
  65.     result = makeNode(JoinExpr);
  66.     result->jointype = JOIN_SEMI;//半连接
  68.     return result;
  69. }

有几种情况会上拉失败：

  1. 右操作数不能包含上层操作对象(包含就是关联子查询了)
  2. 左边操作符
    1. 与上层对象无关
    2. 不能引用上层的关系？
    3. 含有易失函数

convert_EXISTS_sublink_to_join

将EXISTS，NOT EXISTS上拉

  1. JoinExpr *
  2. convert_EXISTS_sublink_to_join(PlannerInfo *root, SubLink *sublink,
  3. 	   bool under_not, Relids available_rels)
  4. {
  5.     JoinExpr   *result;
  6.     Query	   *parse = root->parse;
  8.     Assert(sublink->subLinkType == EXISTS_SUBLINK);
  10.     /*对于右操作数
  11.      * a. 不支持带有WITH子句的格式
  12.      * b. 不支持集合操作或者带有CTE,聚合函数， HAVING，LIMIT等格式
  13.      * c. 不支持FROM或者WHERE子句为空
  14.      */
  15.     if (subselect->cteList)//情况a
  16.     	return NULL;
  18.     if (!simplify_EXISTS_query(root, subselect))//情况b
  19.     	return NULL;
  21.     if (subselect->jointree->fromlist == NIL)//情况c
  22.     	return NULL;
  24.     whereClause = subselect->jointree->quals;//子查询条件保存
  25.     subselect->jointree->quals = NULL;
  27.     //右操作树的子查询不能包含上层中出现的任何Var对象
  28.     if (contain_vars_of_level((Node *) subselect, 1))
  29.     	return NULL;
  30.     //右操作数的where需要有山层的Var，这样才能够成功连接
  31.     if (!contain_vars_of_level(whereClause, 1))
  32.     	return NULL;
  33.     //易失函数不能优化
  34.     if (contain_volatile_functions(whereClause))
  35.     	return NULL;
  37.     //上拉成功，到顶层范围表
  38.     rtoffset = list_length(parse->rtable);
  39.     OffsetVarNodes((Node *) subselect, rtoffset, 0);
  40.     OffsetVarNodes(whereClause, rtoffset, 0);
  42.     /* 从技术上看来，上拉子查询就是把子查询中范围表拉到From子句，并把Where条件合并 */
  43.     parse->rtable = list_concat(parse->rtable, subselect->rtable);
  45.     /*
  46.      * And finally, build the JoinExpr node.
  47.      */
  48.     result = makeNode(JoinExpr);
  49.     result->jointype = under_not ? JOIN_ANTI : JOIN_SEMI;
  50.     return result;
  51. }

不能上拉的条件：

  1. 右操作数：

    1. 不支持带有WITH子句的格式
    2. 不支持集合操作或者带有CTE(定义临时表的存在只是一个查询/withi子句),聚合函数， HAVING，LIMIT等格式
    3. 不支持FROM或者WHERE子句为空
    4. 不支持关联子查询，但是Where必须有上层Var
    5. 易失函数不能优化

上拉子查询

搜索From子句中的范围表，上拉其中子查询

  1. void
  2. pull_up_subqueries(PlannerInfo *root)
  3. {
  4.     /* Recursion starts with no containing join nor appendrel */
  5.     root->parse->jointree = (FromExpr *)
  6.     	pull_up_subqueries_recurse(root, (Node *) root->parse->jointree,
  7.     						NULL, NULL, NULL, false);
  8. }

真正执行上拉

  1. static Node *
  2. pull_up_subqueries_recurse(PlannerInfo *root, Node *jtnode,
  3. 						   JoinExpr *lowest_outer_join,
  4. 						   JoinExpr *lowest_nulling_outer_join,
  5. 						   AppendRelInfo *containing_appendrel,
  6. 						   bool deletion_ok)
  7. {
  8.     Assert(jtnode != NULL);
  9.     if (IsA(jtnode, RangeTblRef))//一个范围表
  10.     {
  11.     	if (rte->rtekind == RTE_SUBQUERY &&
  12.     		is_simple_subquery(rte->subquery, rte,
  13. 			   lowest_outer_join, deletion_ok) &&//如果是简单子查询，上拉
  14.     		(containing_appendrel == NULL ||
  15.     		 is_safe_append_member(rte->subquery)))
  16.     		return pull_up_simple_subquery(root, jtnode, rte,
  17. 				   lowest_outer_join,
  18. 				   lowest_nulling_outer_join,
  19. 				   containing_appendrel,
  20. 				   deletion_ok);
  22.     	if (rte->rtekind == RTE_SUBQUERY &&
  23.     		is_simple_union_all(rte->subquery))//如果是简单UNION操作，上拉
  24.     		return pull_up_simple_union_all(root, jtnode, rte);
  26.     	//普通Value，上拉
  27.     	if (rte->rtekind == RTE_VALUES &&
  28.     		lowest_outer_join == NULL &&
  29.     		containing_appendrel == NULL &&
  30.     		is_simple_values(root, rte, deletion_ok))
  31.     		return pull_up_simple_values(root, jtnode, rte);
  33.     	/* Otherwise, do nothing at this node. */
  34.     }
  35.     else if (IsA(jtnode, FromExpr))
  36.     {
  37.     	FromExpr   *f = (FromExpr *) jtnode;
  39.     	foreach(l, f->fromlist)
  40.     	{
  41.     		lfirst(l) = pull_up_subqueries_recurse(root, lfirst(l),
  42. 						   lowest_outer_join,
  43. 						   lowest_nulling_outer_join,
  44. 						   NULL,
  45. 						   sub_deletion_ok);
  46.     	}
  47.     }
  48.     else if (IsA(jtnode, JoinExpr))
  49.     {
  50.     	JoinExpr   *j = (JoinExpr *) jtnode;
  52.     	/* Recurse, being careful to tell myself when inside outer join */
  53.     	switch (j->jointype)
  54.     	{
  55.     	    //对各种JOIN子句进行上拉
  56.     	}
  57.     }
  58.     else
  59.     	elog(ERROR, "unrecognized node type: %d",
  60.     		 (int) nodeTag(jtnode));
  61.     return jtnode;
  62. }

可以上拉的：

  1. 简单子查询，Union ALL，普通Value
  2. 可以递归多个From子句，也可以递归上拉join左右操作数

优化顶层Union all

  1. void
  2. flatten_simple_union_all(PlannerInfo *root)
  3. {
  4. 	Query	   *parse = root->parse;
  6. 	/* 存在Union嵌套，就是WITH子句 */
  7. 	if (root->hasRecursion)
  8. 		return;
  10. 	/* UNION ALL的列不同*/
  11. 	if (!is_simple_union_all_recurse((Node *) topop, parse, topop->colTypes))
  12. 		return;
  13.     //构造AppendRefInfo节点优化UNION ALL
  14. 	pull_up_union_leaf_queries((Node *) topop, root, leftmostRTI, parse, 0);
  15. }

UNION和UNION ALL和OR

  1. UNION和UNION ALL都是使用AppendRefInfo替代，但是UNION会排序和去重
  2. OR里面会有OrFilter

PostgreSQL查询优化之子查询优化的更多相关文章

  1. postgresql子查询优化(提升子查询)

    问题背景 在开发项目过程中,客户要求使用gbase8s数据库(基于informix),简单的分页页面响应很慢.排查发现分页sql是先查询出数据在外面套一层后再取多少条,如果去掉嵌套的一层,直接获取则很 ...

  2. PostgreSQL代码分析，查询优化部分，canonicalize_qual

    这里把规范谓词表达式的部分就整理完了.阅读的顺序例如以下: 一.PostgreSQL代码分析,查询优化部分,canonicalize_qual 二.PostgreSQL代码分析,查询优化部分,pull ...

  3. 【MySQL】MySQL中针对大数据量常用技术_创建索引+缓存配置+分库分表+子查询优化（转载）

    原文地址:http://blog.csdn.net/zwan0518/article/details/11972853 目录(?)[-] 一查询优化 1创建索引 2缓存的配置 3slow_query_ ...

  4. 标量子查询优化（用group by 代替distinct）

    标量子查询优化 当使用另外一个SELECT 语句来产生结果中的一列的值的时候,这个查询必须只能返回一行一列的值.这种类型的子查询被称为标量子查询 在某些情况下可以进行优化以减少标量子查询的重复执行,但 ...

  5. PostgreSQL代码分析，查询优化部分，pull_ands()和pull_ors()

    PostgreSQL代码分析,查询优化部分. 这里把规范谓词表达式的部分就整理完了,阅读的顺序例如以下: 一.PostgreSQL代码分析,查询优化部分,canonicalize_qual 二.Pos ...

  6. MySQL实验 子查询优化双参数limit

    MySQL实验 子查询优化双参数limit 没想到双参数limit还有优化的余地,为了亲眼见到,今天来亲自实验一下.   实验准备 使用MySQL官方的大数据库employees进行实验,导入该示例库 ...

  7. Mysql单表访问方法，索引合并，多表连接原理，基于规则的优化，子查询优化

    参考书籍<mysql是怎样运行的> 非常推荐这本书,通俗易懂,但是没有讲mysql主从等内容 书中还讲解了本文没有提到的子查询优化内容, 本文只总结了常见的子查询是如何优化的 系列文章目录 ...

  8. mysql查询优化之三：查询优化器提示（hint）

    目录: <MySQL中的两种临时表>--强制使用临时表 SQL_BUFFER_RESULT <MySQL 多表关联更新及删除> <mysql查询优化之三:查询优化器提示( ...

  9. 由一条sql语句想到的子查询优化

    摘要:相信大家都使用过子查询,因为使用子查询可以一次性的完成很多逻辑上需要多个步骤才能完成的SQL操作,比较灵活,我也喜欢用,可最近因为一条包含子查询的select count(*)语句导致点开管理系 ...

随机推荐

  1. Ubuntu Linux訪问小米手机存储卡

    操作系统: 麒麟14.04 安装工具 sudo apt-get install mtpfs libfuse-dev libmad0-dev sudo mkdir /media/mtp 重新启动与使用 ...

  2. 基于FPGA的图像显示

    基于FPGA的图像显示 作者:lee神 这几天一直在调试FPGA的图像显示系统,今天终于成功,图像不在闪烁,也不再边框缺失. 基于FPGA的图像处理的第一课应该是基于FPGA的图像显示,只有图像正常显 ...

  3. 页面的新开页，window.open的hacker

    一.window.open如何进行hack 网上看的办法很多,归根接地还是不能解决掉,只有通过a标签的target属性 $obj.click(function(){  var newTab=windo ...

  4. IDEA下Spring Boot的快速搭建

    下边使用的是IDEA快速搭建一个Spring Boot项目 (1)File--New-New Project (2)点击Next填写相应的信息 (3)点击Next,选择Dependencies,这里创 ...

  5. Elasticsearch常用基础操作

    1.获得集群中的节点列表: curl 'localhost:9200/_cat/nodes?v' 2.获得所有索引: curl 'localhost:9200/_cat/indices?v' 3.创建 ...

  6. spring cloud eureka高可用

    记录下自己踩的坑 spring cloud eureka的高可用网上的教程大致分为两种,一种是两两互相注册,一种是三个互相注册. 1.两两互相注册 普通服务的注册写法都是http://peer1/eu ...

  7. http中的get和post（二）

    博客园精华区有篇文章< GET 和 POST 有什么区别?及为什么网上的多数答案都是错的 >,文中和回复多是对以下两个问题进行了深究: 长度限制 Url 是否隐藏数据 在我看来这两者都不是 ...

  8. python 动态加载类对象

    第一步 加载模块 module  =__import__("modulename",fromlist=['']) 第二部 加载类对象 cls = getattr(module, & ...

  9. 【WebGL】《WebGL编程指南》读书笔记——第4章

    一.前言        今天继续第四章的学习内容,开始学习复合变换的知识. 二.正文        Example1: 复合变换 在书中,作者为我们封装了一套用于变换的矩阵对象:Matrix4对象.它 ...

  10. ES6 let和const命令（3）

    const 用来声明常量.一旦声明,就不能改变. const在声明必须初始化,只声明不赋值会出错 const的作用域与let一样,只在声明的块级作用域有效. const命令声明的常量也不提升,同样存在 ...