Greenplum聚合函数的两种实现：HashAggregate与GroupAggregate

分类：设计模式作者：佚名

在Postgresql/Greenplum数据库中，聚合函数有两种实现方式：HashAggregate与GroupAggregate。

我们现在通过一个最简单的sql来分析这两种聚合的区别以及其应用场景。

select count(1) from pg_class group by oid;

一、两种实现算法的比较：

  • HashAggregate

对于hash聚合来说，数据库会根据group by字段后面的值算出hash值，并根据前面使用的聚合函数在内存中维护对应的列表。如果select后面有两个聚合函数，那么在内存中就会维护两个对应的数据。同样的，有n个聚合函数就会维护n个同样的数组。对于hash算法来说，数组的长度肯定是大于group by的字段的distinct值的个数的，且跟这个值应该呈线性关系，group by后面的值越唯一，使用的内存也就越大。

执行计划如下：

aligputf8=# explain select count(1) from pg_class group by oid;
                              QUERY PLAN                              
----------------------------------------------------------------------
 HashAggregate  (cost=1721.40..2020.28 rows=23910 width=4)
   Group By: oid
   ->  Seq Scan on pg_class  (cost=0.00..1004.10 rows=143460 width=4)
 Settings:  enable_seqscan=on
(4 rows)

  • GroupAggregate

对于普通聚合函数，使用group聚合，其原理是先将表中的数据按照group by的字段排序，这样子同一个group by的值就在一起，这样就只需要对排好序的数据进行一次全扫描，就可以得到聚合的结果了。

执行计划如下：

aligputf8=# set enable_hashagg = off;
SET
aligputf8=#  explain select count(1) from pg_class group by oid;
                                 QUERY PLAN                                 
----------------------------------------------------------------------------
 GroupAggregate  (cost=13291.66..14666.48 rows=23910 width=4)
   Group By: oid
   ->  Sort  (cost=13291.66..13650.31 rows=143460 width=4)
         Sort Key: oid
         ->  Seq Scan on pg_class  (cost=0.00..1004.10 rows=143460 width=4)
 Settings:  enable_hashagg=off; enable_seqscan=on
(6 rows)

从上面的两个执行计划的cost来说，GroupAggregate 由于需要排序，效率很差，消耗是HashAggregate的7倍。所以在GP里面，对于这种聚合函数的使用，采用的都是HashAggregate。

二、两种实现的内存消耗：

先建立一张测试表，并且往里面insert数据，通过每个字段的数据唯一性不一致，还有聚合函数的个数来观察HashAggregate与GroupAggregate在内存的消耗情况以及实际的计算时间的比较。

1.表结构如下：

create table test_group(
 id   integer,col1 numeric,col2 numeric,col3 numeric,col4 numeric,col5 numeric,col6 numeric,col7 numeric,col8 numeric,col9 numeric,col11 varchar(100),col12 varchar(100),col13 varchar(100),col14 varchar(100)
)distributed by(id);

2.插入数据，通过random函数，实现每个字段数据的唯一性不一样

aligputf8=# insert into test_group 
aligputf8-# select generate_series(1,100000),aligputf8-#        (random()*200)::int,aligputf8-#        (random()*800)::int,aligputf8-#        (random()*1600)::int,aligputf8-#        (random()*3200)::int,aligputf8-#        (random()*6400)::int,aligputf8-#        (random()*12800)::int,aligputf8-#        (random()*40000)::int,aligputf8-#        (random()*100000)::int,aligputf8-#        (random()*1000000)::int,aligputf8-#        'hello',aligputf8-#        'welcome',aligputf8-#        'haha',aligputf8-#        'chen';
INSERT 0 100000

表大小为：

aligputf8=# select pg_size_pretty(pg_relation_size('test_group'));
 pg_size_pretty 
----------------
 12 MB
(1 row)


3.使用explain analyze来观察实际数据库消耗的内存差异：

以下是底层单个节点来计算的，避免了广播的时间跟内存消耗

HashAggregate

aligputf8=#  explain analyze select sum(col1),sum(col2),sum(col3),sum(col4),sum(col5),sum(col6),sum(col7),sum(col8),sum(col9) from test_group group by col5;
                                             QUERY PLAN                                            
----------------------------------------------------------------------------------------------------
 HashAggregate  (cost=4186.96..5432.88 rows=38336 width=62)
   Group By: col5
   Rows out:  6401 rows with 289 ms to first row,295 ms to end,start offset by 0.143 ms.
   Executor memory:  2818K bytes.
   ->  Seq Scan on test_group  (cost=0.00..1480.56 rows=108256 width=62)
         Rows out:  100000 rows with 0.023 ms to first row,48 ms to end,start offset by 0.218 ms.
 Slice statistics:
   (slice0)    Executor memory: 2996K bytes.
 Settings:  enable_seqscan=off
 Total runtime: 296.283 ms
(10 rows)

GroupAggregate

aligputf8=#  explain analyze select sum(col1),sum(col9) from test_group group by col5;
                                                QUERY PLAN                                               
----------------------------------------------------------------------------------------------------------
 GroupAggregate  (cost=10532.97..14755.93 rows=38336 width=62)
   Group By: col5
   Rows out:  6401 rows with 306 ms to first row,585 ms to end,start offset by 0.092 ms.
   Executor memory:  8K bytes.
   ->  Sort  (cost=10532.97..10803.61 rows=108256 width=62)
         Sort Key: col5
         Rows out:  100000 rows with 306 ms to first row,342 ms to end,start offset by 0.093 ms.
         Executor memory:  19449K bytes.
         Work_mem used:  19449K bytes.
         ->  Seq Scan on test_group  (cost=0.00..1480.56 rows=108256 width=62)
               Rows out:  100000 rows with 0.021 ms to first row,46 ms to end,start offset by 0.116 ms.
 Slice statistics:
   (slice0)    Executor memory: 19623K bytes.  Work_mem: 19449K bytes max.
 Settings:  enable_hashagg=off; enable_seqscan=off
 Total runtime: 586.114 ms
(15 rows)

通过这种方法，可以看出，消耗的内存跟实际执行时间的比例：

sql:

explain analyze select sum(col1),sum(col9) from test_group group by id;

9个聚合函数

group by字段

col1

col2

col3

col4

col5

col6

col7

col8

col9

id

HashAggregate

Executor memory

554K

786K

1074K

1715K

2996K

5469K

13691K

21312K

29428K

29476K

时间（ms）

266

272

275

281

296

323

357

359

352

340

GroupAggregate

Executor memory

19623K

19623K

19623K

19623K

19623K

19623K

19623K

19623K

19623K

19615K

时间（ms）

500

533

547

568

589

609

636

652

649

387

sql:

27个聚合函数

group by字段

col1

col2

col3

col4

col5

col6

col7

col8

col9

id

HashAggregate

Executor memory

514K

1299K

2340K

4405K

8504K

19687K

69947K

93859K

106419K

106876K

时间（ms）

504.91

511.03

523.36

559.85

616.94

937.73

1179.05

1395.56

1391.27

1391.14

GroupAggregate

Executor memory

19687K

19687K

19687K

19687K

19687K

19687K

19687K

19687K

19687K

19687K

时间（ms）

759.58

782.56

802.4

838.07

880.38

939.52

1104.75

1256.92

1365.61

1142

explain analyze select sum(col1),sum(col9),
max(col1),max(col2),max(col3),max(col4),max(col5),max(col6),max(col7),max(col8),max(col9),
avg(col1),avg(col2),avg(col3),avg(col4),avg(col5),avg(col6),avg(col7),avg(col8),avg(col9) from test_group group by id;

可以看出，对于GroupAggregate来说，消耗的内存基本上是恒定的，无论group by哪个字段。当聚合函数较少的时候，速度也相对较慢，但是相对稳定。

HashAggregate在少数聚合函数是表现优异，但是很多聚合函数，性能跟消耗的内存差异很明显。尤其是受group by字段的唯一性很明显，字段count（district）值越大，hash聚合消耗的内存越多，性能下降剧烈。

所以在sql中有大量聚合函数，group by 的字段由相对比较唯一的时候，应该用GroupAggregate，而不能用HashAggregate。

三、在GP4.1出现的sql报错：

在GP4.1中，之前出现过 有大量聚合函数，并且group by 的字段由相对比较唯一的sql报错如下：

ERROR:Unexpectedinternalerror:SegmentprocessreceivedsignalSIGSEGV

这个sql其实应该就是占用内存太多，进程被操作系统发出信号干掉导致的报错。

查看执行计划，发现是HashAggregate搞得鬼。一般来说，数据库会根据统计信息来选择HashAggregate或者是GroupAggregate，但是有可能统计信息不够详细或者sql太复杂而选错执行计划。

一般遇到这种问题，有两张办法：

1.拆分成多个sql来跑，减少HashAggregate使用的内存.

2.在跑sql之前，先执行enable_hashagg = off;将hash聚合参数关掉。强制不走HashAggregate，建议用这种。

下次如果再遇到这种sql报错，建议采用这种方法改一下脚本试一下。

注：当work_mem不够内存使用时：

aligputf8=# explain analyze select sum(col1),max(col1),avg(col1),avg(col9) from test_group group by id;
                                             QUERY PLAN                                             
----------------------------------------------------------------------------------------------------
 HashAggregate  (cost=15225.85..29783.06 rows=108256 width=66)
   Group By: id
   Rows out:  100000 rows with 722 ms to first row,1367 ms to end,start offset by 0.125 ms.
   Executor memory:  32536K bytes.
   Work_mem used:  32001K bytes.
   Work_mem wanted: 106876K bytes to lessen workfile I/O.
   100000 groups total in 32 batches; 1 overflows; 100000 spill groups.
   Hash chain length 1.8 avg,20 max,using 74100 of 135168 buckets.
   ->  Seq Scan on test_group  (cost=0.00..1480.56 rows=108256 width=66)
         Rows out:  100000 rows with 0.016 ms to first row,51 ms to end,start offset by 0.142 ms.
 Slice statistics:
   (slice0)  * Executor memory: 32697K bytes.  Work_mem: 32001K bytes max,106876K bytes wanted.
 Settings:  enable_groupagg=off; enable_hashagg=on; enable_seqscan=off; work_mem=32000kB
 Total runtime: 1391.138 ms
(14 rows)

当work_mem足够时：

                                             QUERY PLAN                                             
----------------------------------------------------------------------------------------------------
 HashAggregate  (cost=9058.48..17448.32 rows=108256 width=66)
   Group By: id
   Rows out:  100000 rows with 460 ms to first row,1014 ms to end,start offset by 0.120 ms.
   Executor memory:  110093K bytes.
   ->  Seq Scan on test_group  (cost=0.00..1480.56 rows=108256 width=66)
         Rows out:  100000 rows with 0.019 ms to first row,52 ms to end,start offset by 0.554 ms.
 Slice statistics:
   (slice0)    Executor memory: 110271K bytes.
 Settings:  enable_groupagg=off; enable_hashagg=on; enable_seqscan=off; work_mem=320000kB
 Total runtime: 1038.209 ms

(10 rows)

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

迭代器模式（Iterator）
迭代器模式（Iterator）迭代器模式（Iterator）[Cursor]意图：提供一种方法顺序访问一个聚合对象中的每个元素，而又不想暴露该对象的内部表示。应用：STL标准库迭代器实现、Java集合类型迭代器等模式结构：心得：迭代器模式的目的是在不获知集合对象内部细节的同时能对集合元素进行遍历操作
高性能IO模型浅析
高性能IO模型浅析服务器端编程经常需要构造高性能的IO模型，常见的IO模型有四种：（1）同步阻塞IO（BlockingIO）：即传统的IO模型。（2）同步非阻塞IO（Non-blockingIO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的N
策略模式（Strategy）
策略模式（Strategy）策略模式（Strategy）[Policy]意图：定义一系列算法，把他们封装起来，并且使他们可以相互替换，使算法可以独立于使用它的客户而变化。应用：排序的比较方法、封装针对类的不同的算法、消除条件判断、寄存器分配算法等。模式结构：心得：对对象（Context）的处理操作可
访问者模式（Visitor）
访问者模式（Visitor）访问者模式（Visitor）意图：表示一个作用于某对象结构中的各元素的操作，它使你在不改变各元素的类的前提下定义作用于这些元素的新操作。应用：作用于编译器语法树的语义分析算法。模式结构：心得：访问者模式是要解决对对象添加新的操作和功能时候，如何尽可能不修改对象的类的一种方
命令模式（Command）
命令模式（Command）命令模式（Command）[Action/Transaction]意图：将一个请求封装为一个对象，从而可用不同的请求对客户参数化。对请求排队或记录请求日志，以及支持可撤消的操作。应用：用户操作日志、撤销恢复操作。模式结构：心得：命令对象的抽象接口（Command）提供的两个
生成器模式（Builder）
生成器模式（Builder）生成器模式（Builder）意图：将一个对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。 应用：编译器词法分析器指导生成抽象语法树、构造迷宫等。模式结构：心得：和工厂模式不同的是，Builder模式需要详细的指导产品的生产。指导者（Director）使用C
设计模式学习心得
设计模式学习心得《设计模式：可复用面向对象软件的基础》一书以更贴近读者思维的角度描述了GOF的23个设计模式。按照书中介绍的每个设计模式的内容，结合网上搜集的资料，我将对设计模式的学习心得总结出来。网络上关于设计模式的资料和文章汗牛充栋，有些文章对设计模式介绍生动形象。但是我相信“一千个读者，一千个
工厂方法模式（Factory Method）
工厂方法模式（Factory Method）工厂方法模式（Factory Method）[Virtual Constructor]意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实力化延迟到子类。应用：多文档应用管理不同类型的文档。模式结构：心得：面对同一继承体系（Produc
单例模式（Singleton）
单例模式（Singleton）单例模式（Singleton）意图：保证一个类只有一个实例，并提供一个访问它的全局访问点。应用：Session或者控件的唯一示例等。模式结构：心得：单例模式应该是设计模式中最简单的结构了，它的目的很简单，就是保证自身的实例只有一份。实现这种目的的方式有很多，在Java中
装饰者模式（Decorator）
装饰者模式（Decorator）装饰者模式（Decorator）[Wrapper]意图：动态的给一个对象添加一些额外的职责，就增加功能来说，比生成子类更为灵活。应用：给GUI组件添加功能等。模式结构：心得：装饰器（Decorator）和被装饰的对象（ConcreteComponent）拥有统一的接口
抽象工厂模式（Abstract Factory）
抽象工厂模式（Abstract Factory）抽象工厂模式（Abstract Factory）[Kit]意图：提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。应用：用户界面工具包。模式结构：心得：工厂方法把生产产品的方式封装起来了，但是一个工厂只能生产一类对象，当一个工厂需要生
桥接模式（Bridge）
桥接模式（Bridge）桥接模式（Bridge）[Handle/Body]意图：将抽象部分与它的实现部分分离，使他们都可以独立的变化。应用：不同系统平台的Windows界面。模式结构：心得：用户所见类体系结构（Window派生）提供了一系列用户的高层操作的接口，但是这些接口的实现是基于具体的底层实现
适配器模式（Adapter）
适配器模式（Adapter）适配器模式（Adapter）[Wrapper]意图：将类的一个接口转换成用户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。应用：将图形类接口适配到用户界面组件类中。模式结构：心得：适配器模式一般应用在具有相似接口可复用的条件下。目标接口（Targ
组合模式（Composition）
组合模式（Composition）组合模式（Composition）意图：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。应用：组合图形、文件目录、GUI容器等。模式结构：心得： 用户（Client）通过抽象类（Component）提供的公用接口统一
原型模式（Prototype）
原型模式（Prototype）原型模式（Prototype）意图：用原型实例制定创建对象的种类，并且通过拷贝这些原型创建新的对象。应用：Java/C#中的Clonable和IClonable接口等。模式结构：心得：原型模式本质上就是对象的拷贝，使用对象拷贝代替对象创建的原因有很多。比如对象的初始化构
什么是设计模式？Design pattern--和生活结合更好理解
什么是设计模式一套被反复使用、多数人知晓的、经过分类编目的、代码 设计经验 的总结；使用设计模式是为了 可重用 代码、让代码 更容易 被他人理解、保证代码 可靠性；设计模式使代码编制  真正工程化；设计模式使软件工程的 基石脉络， 如同大厦的结构一样；并不直接用来完成代码的编写，而是 描述 在各种不同情况下，要怎么解决问题的一种方案；能使不稳定依赖于相对稳定、具体依赖于相对抽象，避免引
面向对象设计原则一——单一职责原则
单一职责原则定义（Single Responsibility Principle，SRP）一个对象应该只包含 单一的职责，并且该职责被完整地封装在一个类中。Every  Object should have  a single responsibility, and that responsibility should be entirely encapsulated by t
十分钟理解Java中的动态代理----强烈推荐
动态代理和CGLib代理分不清吗，看看这篇文章，写的非常好，强烈推荐。原文截图*************************************************************************************************************************原文文本************
适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合作。
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot