2. 程式人生 > >PotgreSQL 11 新特性之智慧分割槽連線/聚合

PotgreSQL 11 新特性之智慧分割槽連線/聚合

阿新 • • 發佈：2019-01-11

文章目錄

PostgreSQL 11 提供了兩個分割槽級別的新功能：

  • 智慧分割槽連線（partition-wise join），對於兩個分割槽方式相同的分割槽表，如果使用分割槽鍵進行等值連線，允許使用匹配的分割槽直接進行連線操作。
  • 智慧分割槽聚合（partition-wise aggregation），對於分割槽表的聚合操作，如果 GROUP BY 中包含了分割槽鍵，允許針對各個分割槽進行並行的聚合操作，然後再合併結果。

智慧分割槽連線

PostgreSQL 11 增加了一個新的選項：enable_partitionwise_join，用於控制查詢計劃器是否使用分割槽級別的連線。預設值為 off。

首先，建立兩個分割槽表，它們使用相同的分割槽方式：

CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
INSERT
 
 INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
ANALYZE prt1;

CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
CREATE TABLE
 
 prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
ANALYZE prt2;

檢視預設情況下，兩個表的連線操作：

show enable_partitionwise_join;
 enable_partitionwise_join 
---------------------------
 off
(1 row)

EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
                    QUERY PLAN                    
--------------------------------------------------
 Sort
   Sort Key: t1.a
   ->  Hash Join
         Hash Cond: (t2.b = t1.a)
         ->  Append
               ->  Seq Scan on prt2_p1 t2
               ->  Seq Scan on prt2_p2 t2_1
               ->  Seq Scan on prt2_p3 t2_2
         ->  Hash
               ->  Append
                     ->  Seq Scan on prt1_p1 t1
                           Filter: (b = 0)
                     ->  Seq Scan on prt1_p2 t1_1
                           Filter: (b = 0)
                     ->  Seq Scan on prt1_p3 t1_2
                           Filter: (b = 0)
(16 rows)

預設情況下，需要先分別掃描兩個表的所有分割槽，將分割槽結果分別整合在一起（Append），然後執行兩個表的雜湊連線（Hash Join），最後進行排序（Sort）。

接下來，啟用智慧分割槽連線功能，即將引數 enable_partitionwise_join 設定為 on。再次檢視相同的連線操作：

set enable_partitionwise_join to true;
SET
rgsdb=# show enable_partitionwise_join;
 enable_partitionwise_join 
---------------------------
 on
(1 row)

EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
                    QUERY PLAN                    
--------------------------------------------------
 Sort
   Sort Key: t1.a
   ->  Append
         ->  Hash Join
               Hash Cond: (t2.b = t1.a)
               ->  Seq Scan on prt2_p1 t2
               ->  Hash
                     ->  Seq Scan on prt1_p1 t1
                           Filter: (b = 0)
         ->  Hash Join
               Hash Cond: (t2_1.b = t1_1.a)
               ->  Seq Scan on prt2_p2 t2_1
               ->  Hash
                     ->  Seq Scan on prt1_p2 t1_1
                           Filter: (b = 0)
         ->  Hash Join
               Hash Cond: (t2_2.b = t1_2.a)
               ->  Seq Scan on prt2_p3 t2_2
               ->  Hash
                     ->  Seq Scan on prt1_p3 t1_2
                           Filter: (b = 0)
(21 rows)

可以看到，啟用該功能之後，先針對兩個表中的相應分割槽執行雜湊連線（Hash Join），然後將結果整合在一起（Append），最後進行排序（Sort）。其中，分割槽級別的雜湊連線可以並行執行，而且分割槽中的資料量比整個表少，效能會更好。

目前，智慧分割槽連線要求連線條件中必須包含所有的分割槽欄位，它們的資料型別必須相同，並且分割槽方式一致。由於智慧分割槽連線的計劃階段需要佔用更多的 CPU 時間和記憶體，預設沒有啟用該功能。

智慧分割槽聚合

智慧分割槽聚合（分組）使用選項 enable_partitionwise_aggregate 進行控制。預設值為 off。

首先，建立一個分割槽表：

CREATE TABLE pagg_tab (a int, b int, c text, d int) PARTITION BY LIST(c);
CREATE TABLE pagg_tab_p1 PARTITION OF pagg_tab FOR VALUES IN ('0000', '0001', '0002', '0003');
CREATE TABLE pagg_tab_p2 PARTITION OF pagg_tab FOR VALUES IN ('0004', '0005', '0006', '0007');
CREATE TABLE pagg_tab_p3 PARTITION OF pagg_tab FOR VALUES IN ('0008', '0009', '0010', '0011');
INSERT INTO pagg_tab SELECT i % 20, i % 30, to_char(i % 12, 'FM0000'), i % 30 FROM generate_series(0, 2999) i;
ANALYZE pagg_tab;

預設情況下的聚合操作：

show enable_partitionwise_aggregate;
 enable_partitionwise_aggregate 
--------------------------------
 off
(1 row)

EXPLAIN (COSTS OFF)
SELECT c, sum(a), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY c HAVING avg(d) < 15 ORDER BY 1, 2, 3;
                              QUERY PLAN                               
-----------------------------------------------------------------------
 Sort
   Sort Key: pagg_tab_p1.c, (sum(pagg_tab_p1.a)), (avg(pagg_tab_p1.b))
   ->  HashAggregate
         Group Key: pagg_tab_p1.c
         Filter: (avg(pagg_tab_p1.d) < '15'::numeric)
         ->  Append
               ->  Seq Scan on pagg_tab_p1
               ->  Seq Scan on pagg_tab_p2
               ->  Seq Scan on pagg_tab_p3
(9 rows)

預設情況下，需要先分別掃描表的所有分割槽，將分割槽結果整合在一起（Append），然後執行雜湊聚合（HashAggregate），最後進行排序（Sort）。

啟用智慧分割槽聚合功能，檢視相同的聚合操作：

SET enable_partitionwise_aggregate TO true;
SET

EXPLAIN (COSTS OFF)
SELECT c, sum(a), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY c HAVING avg(d) < 15 ORDER BY 1, 2, 3;
                              QUERY PLAN                               
-----------------------------------------------------------------------
 Sort
   Sort Key: pagg_tab_p1.c, (sum(pagg_tab_p1.a)), (avg(pagg_tab_p1.b))
   ->  Append
         ->  HashAggregate
               Group Key: pagg_tab_p1.c
               Filter: (avg(pagg_tab_p1.d) < '15'::numeric)
               ->  Seq Scan on pagg_tab_p1
         ->  HashAggregate
               Group Key: pagg_tab_p2.c
               Filter: (avg(pagg_tab_p2.d) < '15'::numeric)
               ->  Seq Scan on pagg_tab_p2
         ->  HashAggregate
               Group Key: pagg_tab_p3.c
               Filter: (avg(pagg_tab_p3.d) < '15'::numeric)
               ->  Seq Scan on pagg_tab_p3
(15 rows)

可以看到，啟用該功能之後，先針對表中的所有分割槽執行雜湊聚合（HashAggregate），然後將結果整合在一起（Append），最後進行排序（Sort）。其中，分割槽級別的聚合可以並行執行，效能會更好。

如果 GROUP BY 子句中沒有包含分割槽欄位，只會基於分割槽執行部分聚合操作，然後再對結果進行一次最終的聚合。

以下查詢使用欄位 a 進行分組聚合：

EXPLAIN (COSTS OFF)
SELECT a, sum(b), avg(b), count(*), min(a), max(b) FROM pagg_tab GROUP BY a HAVING avg(d) < 15 ORDER BY 1, 2, 3;
                              QUERY PLAN                               
-----------------------------------------------------------------------
 Sort
   Sort Key: pagg_tab_p1.a, (sum(pagg_tab_p1.b)), (avg(pagg_tab_p1.b))
   ->  Finalize HashAggregate
         Group Key: pagg_tab_p1.a
         Filter: (avg(pagg_tab_p1.d) < '15'::numeric)
         ->  Append
               ->  Partial HashAggregate
                     Group Key: pagg_tab_p1.a
                     ->  Seq Scan on pagg_tab_p1
               ->  Partial HashAggregate
                     Group Key: pagg_tab_p2.a
                     ->  Seq Scan on pagg_tab_p2
               ->  Partial HashAggregate
                     Group Key: pagg_tab_p3.a
                     ->  Seq Scan on pagg_tab_p3
(15 rows)

由於欄位 a 不是分割槽鍵，所以先執行分割槽級別的部分雜湊聚合（Partial HashAggregate），聚合的結果中可能存在相同的分組（不同分割槽中的欄位 a 存在相同的值），需要執行最終的雜湊聚合（Finalize HashAggregate）操作。

由於智慧分割槽聚合（分組）的計劃階段需要佔用更多的 CPU 時間和記憶體，預設沒有啟用該功能。

可以同時啟用智慧分割槽連線與智慧分割槽聚合功能。首先，建立兩個分割槽表：

CREATE TABLE pagg_tab1(x int, y int) PARTITION BY RANGE(x);
CREATE TABLE pagg_tab1_p1 PARTITION OF pagg_tab1 FOR VALUES FROM (0) TO (10);
CREATE TABLE pagg_tab1_p2 PARTITION OF pagg_tab1 FOR VALUES FROM (10) TO (20);
CREATE TABLE pagg_tab1_p3 PARTITION OF pagg_tab1 FOR VALUES FROM (20) TO (30);

CREATE TABLE pagg_tab2(x int, y int) PARTITION BY RANGE(y);
CREATE TABLE pagg_tab2_p1 PARTITION OF pagg_tab2 FOR VALUES FROM (0) TO (10);
CREATE TABLE pagg_tab2_p2 PARTITION OF pagg_tab2 FOR VALUES FROM (10) TO (20);
CREATE TABLE pagg_tab2_p3 PARTITION OF pagg_tab2 FOR VALUES FROM (20) TO (30);

INSERT INTO pagg_tab1 SELECT i % 30, i % 20 FROM generate_series(0, 299, 2) i;
INSERT INTO pagg_tab2 SELECT i % 20, i % 30 FROM generate_series(0, 299, 3) i;

ANALYZE pagg_tab1;
ANALYZE pagg_tab2;

使用分割槽欄位作為連線條件，同時使用分割槽欄位進行分組聚合：

SET enable_partitionwise_join TO true;
SET enable_partitionwise_aggregate TO true;

EXPLAIN (COSTS OFF)
rgsdb-# SELECT t1.x, sum(t1.y), count(*) FROM pagg_tab1 t1, pagg_tab2 t2 WHERE t1.x = t2.y GROUP BY t1.x ORDER BY 1, 2, 3;
                         QUERY PLAN                          
-------------------------------------------------------------
 Sort
   Sort Key: t1.x, (sum(t1.y)), (count(*))
   ->  Append
         ->  HashAggregate
               Group Key: t1.x
               ->  Hash Join
                     Hash Cond: (t1.x = t2.y)
                     ->  Seq Scan on pagg_tab1_p1 t1
                     ->  Hash
                           ->  Seq Scan on pagg_tab2_p1 t2
         ->  HashAggregate
               Group Key: t1_1.x
               ->  Hash Join
                     Hash Cond: (t1_1.x = t2_1.y)
                     ->  Seq Scan on pagg_tab1_p2 t1_1
                     ->  Hash
                           ->  Seq Scan on pagg_tab2_p2 t2_1
         ->  HashAggregate
               Group Key: t1_2.x
               ->  Hash Join
                     Hash Cond: (t2_2.y = t1_2.x)
                     ->  Seq Scan on pagg_tab2_p3 t2_2
                     ->  Hash
                           ->  Seq Scan on pagg_tab1_p3 t1_2
(24 rows)

執行計劃先針對兩個表中的相應分割槽執行雜湊連線（Hash Join），然後基於連線結果執行分割槽級別的雜湊聚合（HashAggregate），將結果整合在一起（Append），最後進行排序（Sort）。分割槽級別的雜湊連線以及分割槽級別的聚合可以並行執行。

另外，PostgreSQL 11 還支援 postgres_fdw 外部分割槽的聚合操作下推，即將聚合操作下推至外部表執行。同時還支援 postgres_fdw 外部分割槽上的 INSERT、UPDATE、COPY 操作。

參考：
Basic partition-wise join functionality.
Implement partition-wise grouping/aggregation.

人生本來短暫，你又何必匆匆！點個贊再走吧！

相關推薦

PotgreSQL 11 新特性之智慧分割槽連線/聚合

文章目錄 智慧分割槽連線 智慧分割槽聚合 PostgreSQL 11 提供了兩個分割槽級別的新功能： 智慧分割槽連線（partition-wise join），對於兩個分割槽方式相同的分割槽表，如果使用分割槽鍵

PostgreSQL 11 新特性之預設分割槽

文章目錄 PosgtreSQL 11 支援為分割槽表建立一個預設（DEFAULT）的分割槽，用於儲存無法匹配其他任何分割槽的資料。顯然，只有 RANGE 分割槽表和 LIST 分割槽表需要預設分割槽。 CREATE TABLE measurement (

PostgreSQL 11 新特性之跨分割槽移動資料

文章目錄 在 PostgreSQL 10 中，如果 UPDATE 語句修改了分割槽欄位的值，導致資料需要移動到其他分割槽時，語句將會失敗。 -- PostgreSQL 10 CREATE TABLE rtable(c1 INT, c2 VARCHAR(10))

C++11新特性之智慧指標

　　這一節將從用法上、記憶體儲存上以及生存週期上，對unique_ptr， shared_ptr和weak_ptr做一個深入剖析。 unique_ptr 　　不共享它的指標。它無法複製到其他 unique_ptr，無法通過值傳遞到函式，也無法用於需要副本的

PostgreSQL 11 新特性之分割槽表外來鍵

文章目錄 對於 PostgreSQL 10 中的分割槽表，無法建立引用其他表的外來鍵約束。 -- PostgreSQL 10 CREATE TABLE cities ( city_id int not null PRIMARY KEY,

PostgreSQL 11 新特性之分割槽索引

文章目錄 分割槽自動索引 分割槽表唯一約束 在 PostgreSQL 10 中，分割槽上的索引需要基於各個分割槽手動建立，而不能基於分割槽的父表建立索引。PostgreSQL 11 可以基於分割槽表建立索引。分割槽表上的索

PostgreSQL 11 新特性之雜湊分割槽

文章目錄 PostgreSQL 10 引入了宣告式分割槽（declarative partitioning）特性，但是實現的功能有限。PostgreSQL 11 為此帶來了許多關於分割槽的增強功能。首先就是增加了 HASH 分割槽。雜湊分割槽基於分割槽鍵的雜湊值計算

PostgreSQL 11 新特性之分割槽裁剪增強

文章目錄 在之前的版本中，只在查詢的計劃階段執行分割槽排除操作（通過 constraint_exclusion 變數控制），意味著許多連線查詢和預編譯查詢無法使用分割槽排除。另外，這種方法佔用的時間會隨著分割槽的數量線性增長。 PostgreSQL 11 通過兩

C++11新特性之 std::forward(完美轉發)（轉）

tails array sin .com std utili res details calling 我們也要時刻清醒，有時候右值會轉為左值，左值會轉為右值。 （也許“轉換”二字用的不是很準確） 如果我們要避免這種轉換呢？ 我們需要一種方法能按照參數原來的類型轉發到另一個函

C++11新特性之右值引用

什麼是左值，什麼是右值？ An l-value expression refers to an object's identity, whereas a r-value expression refers to an object's value. 左值標識物件的身份，右值標識物件的值（我把它理解為被物

C++11新特性之十：enable_shared_from_this

 enable_shared_from_this是一個模板類，定義於標頭檔案<memory>，其原型為： template< class T > class enable_shared_from_this;        std::enable_s

C++11新特性之final override識別符號

final: 　　final修飾符可用於修飾類，放在類名後面，被final修飾符修飾的類不能被繼承。示例程式碼： // 正確的示範 #include <iostream> class A { public: void show_a_info() { st

C++11新特性之final override標識符

並不會 ptr 輸出 erro 子類 main count color 特性 final: 　　final修飾符可用於修飾類，放在類名後面，被final修飾符修飾的類不能被繼承。示例代碼： // 正確的示範 #include <iostream> class

C++11 新特性之operator "" xxx

從C++11開始，我們可以使用以下形式通過常量字串構造自定義型別， 比如： class Person { public: Person(const std::string& name): _name(name){} std::string name() const {

C++11 新特性之右值引用和轉移建構函式

問題背景 #include <iostream> usingnamespace std;   vector<int> doubleValues (const vector<int>& v)   {  

C++ 面試 C++ 11 新特性之右值引用與移動

右值引用 什麼是左值，什麼是右值，簡單說左值可以賦值，右值不可以賦值。以下面程式碼為例，“ A a = getA();”該語句中a是左值，getA()的返回值是右值。 #include <iostream> class A { public

PostgreSQL 11 新特性之快速增加包含非空預設值的列

文章目錄 在 PostgreSQL 11 之前，為表增加一個包含非空預設值的欄位，將會導致表資料的重新寫入，為每一行新增該欄位，並且填充預設值。如果針對大表執行這種操作，將會非常耗時。 以下是一個 PostgreSQL 10 中新增欄位（包含非空預設值）的示例：

PostgreSQL 11 新特性之覆蓋索引（Covering Index）

文章目錄 通常來說，索引可以用於提高查詢的速度。通過索引，可以快速訪問表中的指定資料，避免了表上的掃描。 有時候，索引不僅僅能夠用於定位表中的資料。某些查詢可能只需要訪問索引的資料，就能夠獲取所需要的結果，而不需要再次訪問表中的資料。這種訪問資料的方法叫做 In

C++11新特性之Lambda函式

我是搞C++的 一直都在提醒自己，我是搞C++的；但是當C++11出來這麼長時間了，我卻沒有跟著隊伍走，發現很對不起自己的身份，也還好，發現自己也有段時間沒有寫C++程式碼了。今天看到了C++中的Lambda表示式，雖然用過C#的，但是C++的，一直沒有用，也不知道怎麼

C++11新特性之列表初始化

在我們實際程式設計中，我們經常會碰到變數初始化的問題，對於不同的變數初始化的手段多種多樣，比如說對於一個數組我們可以使用 int arr[] = {1,2,3}的方式初始化，又比如對於一個簡單的結構體： struct A { int x; int y; }a={1,2