ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 数据库> 文章详细

KingbaseES 数据库逻辑优化规则

2022-09-16 19:00:08  阅读：251  来源： 互联网

标签：逻辑 rows actual .. 数据库 width cost KingbaseES id


SQL 优化的过程可以分为逻辑优化和物理优化两个部分。逻辑优化主要是基于规则的优化，简称 RBO（Rule-Based Optimization）。物理优化会为逻辑查询计划中的算子选择某个具体的实现，需要用到一些统计信息，决定哪一种方式代价最低，所以是基于代价的优化 CBO（Cost-Based Optimization）。
本文将主要介绍Kingbase数据库的逻辑优化规则。

准备数据：

create table big(id int , bname varchar(20)); 

create table middle(id int , bname varchar(20)); 

create table small(id int , sname varchar(20)); 

insert into big  select  generate_series(1 , 1000), dbms_random.string('l',5) ; 

insert into middle  select  generate_series(501 , 1000), dbms_random.string('l',5) ; 

insert into small  select  generate_series(951 , 1050), dbms_random.string('l',5) ;

逻辑优化分类

[逻辑优化分类]
                             |选择下推
                             |谓词下推
            |逻辑分解优化 ⇒  |连接顺序交换
            |                |等价类推理
逻辑优化  ⇒
            |               |子查询提升
            |逻辑重写优化 ⇒ |子连接提升
                            |表达式预处理
                            |外连接消除

逻辑分解优化

选择下推

连接条件直接下推到自己所涉及的基表上。

demo=# explain analyze select * from big b left join small s on b.id = s.id and s.id = 1000;
                                                  QUERY PLAN                                                  
--------------------------------------------------------------------------------------------------------------
 Hash Left Join  (cost=2.26..22.02 rows=1000 width=20) (actual time=0.027..0.228 rows=1000 loops=1)
   Hash Cond: (b.id = s.id)
   ->  Seq Scan on big b  (cost=0.00..16.00 rows=1000 width=10) (actual time=0.010..0.079 rows=1000 loops=1)
   ->  Hash  (cost=2.25..2.25 rows=1 width=10) (actual time=0.012..0.013 rows=1 loops=1)
         Buckets: 1024  Batches: 1  Memory Usage: 9kB
         ->  Seq Scan on small s  (cost=0.00..2.25 rows=1 width=10) (actual time=0.008..0.010 rows=1 loops=1)
               Filter: (id = 1000)
               Rows Removed by Filter: 99
 Planning Time: 0.077 ms
 Execution Time: 0.276 ms
(10 行记录)

谓词下推

谓词下推 Predicate Pushdown(PPD):简而言之,就是在不影响结果的情况下,尽量将过滤条件提前执行。

demo=# explain analyze select * from big b left join small s on b.id = s.id and b.id = 1000; 
                                                    QUERY PLAN                                                    
------------------------------------------------------------------------------------------------------------------
 Hash Left Join  (cost=3.25..24.25 rows=1000 width=20) (actual time=0.035..0.304 rows=1000 loops=1)
   Hash Cond: (b.id = s.id)
   Join Filter: (b.id = 1000)
   Rows Removed by Join Filter: 49
   ->  Seq Scan on big b  (cost=0.00..16.00 rows=1000 width=10) (actual time=0.010..0.091 rows=1000 loops=1)
   ->  Hash  (cost=2.00..2.00 rows=100 width=10) (actual time=0.020..0.020 rows=100 loops=1)
         Buckets: 1024  Batches: 1  Memory Usage: 13kB
         ->  Seq Scan on small s  (cost=0.00..2.00 rows=100 width=10) (actual time=0.004..0.009 rows=100 loops=1)
 Planning Time: 0.078 ms
 Execution Time: 0.365 ms
(10 行记录)

规则：

1：连接条件下推之后会变成过滤条件，过滤条件下推之后仍然是过滤条件。

2：如果连接条件引用了 Nonnullable-side 的表，那么连接条件不能下推；如果连接条件只引用了 Nullable-side 的表，那么连接条件可以下推。

3：如果过滤条件只引用了 Nonnullable-side 的表，那么这个过滤条件能够下推到表上；如果过滤条件引用了 Nullable-side
的表且过滤条件是严格的，那么会导致外连接消除，外连接消除之后变成内连接，过滤条件也是能下推的。

连接顺序交换

优化器对表的连接顺序进行重新排列。


demo=# explain analyze select * from big b left join middle m on true left join small s on m.id = s.id ;
                                                          QUERY PLAN                                                          
------------------------------------------------------------------------------------------------------------------------------
 Nested Loop Left Join  (cost=3.25..6281.38 rows=500000 width=30) (actual time=0.043..84.884 rows=500000 loops=1)
   ->  Seq Scan on big b  (cost=0.00..16.00 rows=1000 width=10) (actual time=0.009..0.200 rows=1000 loops=1)
   ->  Materialize  (cost=3.25..16.62 rows=500 width=20) (actual time=0.000..0.020 rows=500 loops=1000)
         ->  Hash Left Join  (cost=3.25..14.12 rows=500 width=20) (actual time=0.029..0.135 rows=500 loops=1)
               Hash Cond: (m.id = s.id)
               ->  Seq Scan on middle m  (cost=0.00..8.00 rows=500 width=10) (actual time=0.004..0.036 rows=500 loops=1)
               ->  Hash  (cost=2.00..2.00 rows=100 width=10) (actual time=0.020..0.020 rows=100 loops=1)
                     Buckets: 1024  Batches: 1  Memory Usage: 13kB
                     ->  Seq Scan on small s  (cost=0.00..2.00 rows=100 width=10) (actual time=0.003..0.008 rows=100 loops=1)
 Planning Time: 0.149 ms
 Execution Time: 99.958 ms
(11 行记录)

规则：

假设 A、B、C 为参与连接的基表，Pab 代表引用了 A 表和 B 表上的列的谓词（连接条件）。

  1. LEFT JOIN 相关的连接顺序交换等式：

1.1 等式 1： ( A left join B on (Pab)) inner join C on (Pac) = ( A inner join C on (Pac)) left join b on (Pab)

1.2 等式 2： ( A left join B on (Pab)) left join C on (Pac) = ( A left join C on (Pac)) left join b on (Pab)

1.3 等式 3： ( A left join B on (Pab)) left join C on (Pbc) = A left join ( B left join C on (Pbc)) on (Pab)
&Pbc 必须是严格的筛选条件

  1. Semi Join 有关的连接顺序交换等式：

( A semi Join B on (Pab)) innerjoin/leftjoin/semijoin/antijoin C on (Pac) =
( A innerjoin/leftjoin/semijoin/antijoin C on (Pac)) semi Join B on (Pab)

  1. Anti Join 有关的连接顺序交换等式：

( A anti Join B on (Pab)) innerjoin/leftjoin/semijoin/antijoin C on (Pac) =
( A innerjoin/leftjoin/semijoin/antijoin C on (Pac)) anti Join B on (Pab)

等价类推理

等值查询时，检索条件a.id = b.id and a.id = 1 ,会将检索条进行推理为a.id = 1 and b.id = 1

demo=# explain analyze select * from big b ,small s where b.id = s.id and b.id = 100; 
                                               QUERY PLAN                                               
--------------------------------------------------------------------------------------------------------
 Nested Loop  (cost=0.00..20.76 rows=1 width=20) (actual time=0.271..0.272 rows=0 loops=1)
   ->  Seq Scan on big b  (cost=0.00..18.50 rows=1 width=10) (actual time=0.046..0.261 rows=1 loops=1)
         Filter: (id = 100)
         Rows Removed by Filter: 999
   ->  Seq Scan on small s  (cost=0.00..2.25 rows=1 width=10) (actual time=0.008..0.008 rows=0 loops=1)
         Filter: (id = 100)
         Rows Removed by Filter: 100
 Planning Time: 0.123 ms
 Execution Time: 0.330 ms
(9 行记录)

逻辑重写优化

Kingbase数据库基于子查询所在的位置和作用的不同，将子查询细分成了两类，一类称为子连接（SubLink），另一类称为子查询（SubQuery）。通常而言，
如果它是以“表”的方式存在的，那么就称为子查询，如果它以表达式的方式存在，那么就称为子连接。

子连接和子查询的区别：出现在 FROM 关键字后的子句是子查询语句，出现在 WHERE/ON 等约束条件中或投影中的子句是子连接语句。

相关子连接和非相关子连接：

相关子连接：指在子查询语句中引用了外层表的列属性，这就导致外层表每获得一个元组，子查询就需要重新执行一次。

非相关子连接：指子查询语句是独立的，和外层的表没有直接的关联，子查询可以单独执行一次，外层表可以重复利用子查询的执行结果。

子查询提升

demo=# explain analyze select * from big b ,(select * from small s where s.id > 100) s where b.id = s.id ; 
                                                    QUERY PLAN                                                    
------------------------------------------------------------------------------------------------------------------
 Hash Join  (cost=3.50..24.25 rows=100 width=20) (actual time=0.203..0.220 rows=50 loops=1)
   Hash Cond: (b.id = s.id)
   ->  Seq Scan on big b  (cost=0.00..16.00 rows=1000 width=10) (actual time=0.011..0.089 rows=1000 loops=1)
   ->  Hash  (cost=2.25..2.25 rows=100 width=10) (actual time=0.029..0.029 rows=100 loops=1)
         Buckets: 1024  Batches: 1  Memory Usage: 13kB
         ->  Seq Scan on small s  (cost=0.00..2.25 rows=100 width=10) (actual time=0.006..0.016 rows=100 loops=1)
               Filter: (id > 100)
 Planning Time: 0.091 ms
 Execution Time: 0.245 ms
(9 行记录)

子连接提升

将子连接提升为子查询。

demo=# explain analyze select * from big b where exists (select * from small s where b.id = s.id) ;
                                                   QUERY PLAN                                                    
-----------------------------------------------------------------------------------------------------------------
 Hash Semi Join  (cost=3.25..22.99 rows=100 width=10) (actual time=0.168..0.180 rows=50 loops=1)
   Hash Cond: (b.id = s.id)
   ->  Seq Scan on big b  (cost=0.00..16.00 rows=1000 width=10) (actual time=0.010..0.073 rows=1000 loops=1)
   ->  Hash  (cost=2.00..2.00 rows=100 width=4) (actual time=0.025..0.025 rows=100 loops=1)
         Buckets: 1024  Batches: 1  Memory Usage: 12kB
         ->  Seq Scan on small s  (cost=0.00..2.00 rows=100 width=4) (actual time=0.005..0.012 rows=100 loops=1)
 Planning Time: 0.078 ms
 Execution Time: 0.200 ms
(8 行记录)

规则：

  1. EXISTS 类型的相关子连接会被提升(需要是“简单”的子连接 )
  2. EXISTS 非相关子连接会形成子执行计划单独求解
  3. ANY 类型的非相关子连接可以提升(需要是“简单”的子连接)，且可以通过物化的方式进行优化
  4. ANY 类型的相关子连接目前还不能提升
  5. 相关子连接提升上来之后可以避免那种 O(N^2) 式的子计划的执行方式（参照上面的借助参数执行的情况），例如提升上来之后借助哈希表实现优化
  6. 不能提升的一种情况是非相关子连接，因为只需要执行一次就能反复利用它的执行结果
  7. 另一种不能提升的情况是对于外连接，它需要满足的是和 Nullable 端相关，而非和 Nonnullable 端相关

“简单”子连接：不包含通用表达式（CTE）, 集合操作、聚集操作、HAVING 子句等的子连接叫作“简单”子连接。

注意：

子句中如果包含通用表达式（CTE），子连接不能提升。如果子句中包含集合操作、聚集操作、HAVING子句等，子连接不能提升，否则子连接中的子句进行简化。

表达式预处理

对表达式进行处理，简化约束条件

demo=# explain analyze select * from big b where b.id > 100 and 1 = 2;
                                     QUERY PLAN                                     
------------------------------------------------------------------------------------
 Result  (cost=0.00..0.00 rows=0 width=0) (actual time=0.001..0.001 rows=0 loops=1)
   One-Time Filter: false
 Planning Time: 0.040 ms
 Execution Time: 0.011 ms
(4 行记录)

外连接消除

通过对连接条件限制，消除外连接，转换为内连接处理

demo=# explain analyze select * from big b left join small s on b.id = s.id where s.id is not null ;
                                                    QUERY PLAN                                                    
------------------------------------------------------------------------------------------------------------------
 Hash Join  (cost=3.25..24.00 rows=100 width=20) (actual time=0.278..0.292 rows=50 loops=1)
   Hash Cond: (b.id = s.id)
   ->  Seq Scan on big b  (cost=0.00..16.00 rows=1000 width=10) (actual time=0.010..0.134 rows=1000 loops=1)
   ->  Hash  (cost=2.00..2.00 rows=100 width=10) (actual time=0.037..0.037 rows=100 loops=1)
         Buckets: 1024  Batches: 1  Memory Usage: 13kB
         ->  Seq Scan on small s  (cost=0.00..2.00 rows=100 width=10) (actual time=0.020..0.028 rows=100 loops=1)
               Filter: (id IS NOT NULL)
 Planning Time: 0.148 ms
 Execution Time: 0.339 ms
(9 行记录)

总结：

Kingbase数据库逻辑优化方式，通过找出SQL等价的变换形式让 SQL 执行效率更高效。这些规则背后的原理就是关系代数的等价变换，其中典型的规则包括：列剪裁，谓词下推等,对查询进行重写。SQL 的查询重写包括了子查询优化、等价谓词重写、视图重写、条件简化、连接消除和嵌套连接消除等。各种逻辑优化技术依据关系代数和启发式规则进行。

标签：逻辑,rows,actual,..,数据库,width,cost,KingbaseES,id
来源： https://www.cnblogs.com/kingbase/p/16700984.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有