Greenplum行存与列存性能对比

最新推荐文章于 2023-01-09 15:00:42 发布
最新推荐文章于 2023-01-09 15:00:42 发布
阅读量1.5k 收藏
点赞数 1
文章标签： 数据库 大数据 测试
原文链接：https://my.oschina.net/javacy/blog/2998969
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

今天给大家分享一个Greenplum中行存与列存的性能对比，在分析型业务中，如果对数据查询的列数不是很多，还是建议优先选用列存。本文涉及的测试用例就能看出列存恰当使用时，性能能提升3倍！！

测试结果对比：

SQL行存响应(ms)列存响应(ms)
SELECT cab_type, count(*) FROM trips GROUP BY cab_type;
9539.6073060.362
SELECT passenger_count,avg(total_amount) FROM trips GROUP BY passenger_count;
7186.3762512.066
SELECT passenger_count, extract(year from pickup_datetime) AS pickup_year,  count(*) FROM trips GROUP BY passenger_count, pickup_year;
9430.0535301.265
SELECT passenger_count,extract(year from pickup_datetime) AS pickup_year,  cast(trip_distance as int) AS distance,count(*) AS the_count FROM trips GROUP BY passenger_count, pickup_year, distance ORDER BY pickup_year, the_count desc;
10616.3586627.922

测试执行过程：

--行存--

postgres=# \timing on
Timing is on.
postgres=# SELECT cab_type,
       count(*)
FROM trips
GROUP BY cab_type;
cab_type |   count   
----------+-----------
yellow   | 400000000
(1 row)

Time: 9539.607 ms
postgres=# SELECT passenger_count,
postgres-#        avg(total_amount)
postgres-# FROM trips
postgres-# GROUP BY passenger_count;
passenger_count |       avg        
-----------------+------------------
             247 |            19.44
             255 |            15.25
               7 | 27.3425925925926
              47 |                9
              36 |            61.55
               4 | 13.9527243251649
              65 |             50.3
             249 |              9.5
             177 |               17
              33 |                9
             129 | 9.43333333333333
               1 | 13.6593432049349
               9 | 21.2552830188679
             254 |              6.5
               6 | 14.0393473844229
               3 | 13.8312939694461
               8 |         25.42975
               0 | 10.6683842285075
             208 | 7.24198473282443
               5 | 13.7613386506018
              58 |            20.74
              10 | 38.0166666666667
              66 |             19.3
               2 | 14.3546975991445
(24 rows)

Time: 7186.376 ms
postgres=# SELECT passenger_count,
postgres-#        extract(year from pickup_datetime) AS pickup_year,
postgres-#        count(*)
postgres-# FROM trips
postgres-# GROUP BY passenger_count,
postgres-#          pickup_year;
passenger_count | pickup_year |   count   
-----------------+-------------+-----------
               7 |        2011 |         2
             255 |        2013 |         2
               3 |        2012 |   7716364
               7 |        2013 |        35
              47 |        2011 |         1
               3 |        2014 |    117300
             254 |        2012 |         1
              10 |        2011 |         2
              58 |        2011 |         1
               2 |        2011 |   6864045
               6 |        2012 |   4880708
               2 |        2013 |  23517494
               6 |        2014 |    111403
              65 |        2012 |         1
             249 |        2012 |         1
             177 |        2012 |         1
               9 |        2014 |         2
               1 |        2012 | 123955714
               5 |        2013 |  10034696
               5 |        2011 |   3471211
               9 |        2012 |        25
               1 |        2014 |   2008131
               8 |        2011 |         1
               8 |        2013 |        25
               0 |        2011 |    805380
               4 |        2012 |   3752549
               0 |        2013 |      5035
             208 |        2013 |        13
             208 |        2011 |         7
               4 |        2014 |     55319
             247 |        2012 |         1
               3 |        2013 |   7315829
Time: 9430.053 ms
postgres=# SELECT passenger_count,
postgres-#        extract(year from pickup_datetime) AS pickup_year,
postgres-#        cast(trip_distance as int) AS distance,
postgres-#        count(*) AS the_count
postgres-# FROM trips
postgres-# GROUP BY passenger_count,
postgres-#          pickup_year,
postgres-#          distance
postgres-# ORDER BY pickup_year,
postgres-#          the_count desc;
passenger_count | pickup_year | distance | the_count
-----------------+-------------+----------+-----------
               1 |        2011 |        1 |  10607963
               1 |        2011 |        2 |   7729133
               1 |        2011 |        3 |   3412674
               2 |        2011 |        1 |   2309318
               1 |        2011 |        4 |   2081972
               1 |        2011 |        0 |   2016713
               2 |        2011 |        2 |   1746024
               5 |        2011 |        1 |   1245490
               1 |        2011 |        5 |   1098301
               5 |        2011 |        2 |    859082
               2 |        2011 |        3 |    816196
               1 |        2011 |        6 |    787657
               3 |        2011 |        1 |    722827
               3 |        2011 |        2 |    542156
               2 |        2011 |        4 |    503827
               1 |        2011 |        7 |    446286
               5 |        2011 |        3 |    429471
               1 |        2011 |        8 |    389943
               1 |        2011 |       10 |    345441
               4 |        2011 |        1 |    345021
               1 |        2011 |        9 |    341023
               2 |        2011 |        0 |    334394
               0 |        2011 |        1 |    303759
               6 |        2011 |        1 |    274382
               2 |        2011 |        5 |    269895
               4 |        2011 |        2 |    265926
               3 |        2011 |        3 |    253013
               5 |        2011 |        4 |    235683
               1 |        2011 |       11 |    228015
               0 |        2011 |        2 |    212231
               6 |        2011 |        2 |    189166
               2 |        2011 |        6 |    189150
Time: 10616.358 ms
postgres=#

--列存--

postgres=# SELECT cab_type,
postgres-#        count(*)
postgres-# FROM trips
postgres-# GROUP BY cab_type;
cab_type |   count   
----------+-----------
yellow   | 400000000
(1 row)

Time: 3060.362 ms
postgres=# SELECT passenger_count,
postgres-#        avg(total_amount)
postgres-# FROM trips
postgres-# GROUP BY passenger_count;
passenger_count |       avg        
-----------------+------------------
              36 |            61.55
               4 |  13.952724325165
              65 |             50.3
             249 |              9.5
             177 |               17
              33 |                9
             129 | 9.43333333333333
               1 | 13.6593432049358
               9 | 21.2552830188679
             254 |              6.5
               6 |  14.039347384423
               3 | 13.8312939694462
               0 | 10.6683842285075
             208 | 7.24198473282443
               8 |         25.42975
               5 | 13.7613386506019
              66 |             19.3
              58 |            20.74
               2 | 14.3546975991445
              10 | 38.0166666666667
              47 |                9
             255 |            15.25
               7 | 27.3425925925926
             247 |            19.44
(24 rows)

Time: 2512.066 ms
postgres=# SELECT passenger_count,
postgres-#        extract(year from pickup_datetime) AS pickup_year,
postgres-#        count(*)
postgres-# FROM trips
postgres-# GROUP BY passenger_count,
postgres-#          pickup_year;
passenger_count | pickup_year |   count   
-----------------+-------------+-----------
               8 |        2011 |         1
               4 |        2012 |   3752549
               0 |        2011 |    805380
               0 |        2013 |      5035
               8 |        2013 |        25
             208 |        2013 |        13
             208 |        2011 |         7
               4 |        2014 |     55319
             247 |        2012 |         1
               3 |        2011 |   2090860
               3 |        2013 |   7315829
               7 |        2012 |        17
              66 |        2012 |         1
              10 |        2012 |         1
               6 |        2011 |    764407
               2 |        2012 |  24900623
               6 |        2013 |   6764789
               2 |        2014 |    389248
             129 |        2013 |         1
               1 |        2011 |  30417318
               5 |        2012 |  12063339
               1 |        2013 | 121959711
              33 |        2011 |         1
               9 |        2013 |        26
             129 |        2011 |         2
               5 |        2014 |    162696
              36 |        2011 |         1
               4 |        2011 |   1018515
               0 |        2012 |   1274858
               4 |        2013 |   3582103
             208 |        2012 |       107
               8 |        2012 |        13
Time: 5301.265 ms
postgres=# SELECT passenger_count,
postgres-#        extract(year from pickup_datetime) AS pickup_year,
postgres-#        cast(trip_distance as int) AS distance,
postgres-#        count(*) AS the_count
postgres-# FROM trips
postgres-# GROUP BY passenger_count,
postgres-#          pickup_year,
postgres-#          distance
postgres-# ORDER BY pickup_year,
postgres-#          the_count desc;
passenger_count | pickup_year | distance | the_count
-----------------+-------------+----------+-----------
               1 |        2011 |        1 |  10607963
               1 |        2011 |        2 |   7729133
               1 |        2011 |        3 |   3412674
               2 |        2011 |        1 |   2309318
               1 |        2011 |        4 |   2081972
               1 |        2011 |        0 |   2016713
               2 |        2011 |        2 |   1746024
               5 |        2011 |        1 |   1245490
               1 |        2011 |        5 |   1098301
               5 |        2011 |        2 |    859082
               2 |        2011 |        3 |    816196
               1 |        2011 |        6 |    787657
               3 |        2011 |        1 |    722827
               3 |        2011 |        2 |    542156
               2 |        2011 |        4 |    503827
               1 |        2011 |        7 |    446286
               5 |        2011 |        3 |    429471
               1 |        2011 |        8 |    389943
               1 |        2011 |       10 |    345441
               4 |        2011 |        1 |    345021
               1 |        2011 |        9 |    341023
               2 |        2011 |        0 |    334394
               0 |        2011 |        1 |    303759
               6 |        2011 |        1 |    274382
               2 |        2011 |        5 |    269895
               4 |        2011 |        2 |    265926
               3 |        2011 |        3 |    253013
               5 |        2011 |        4 |    235683
               1 |        2011 |       11 |    228015
               0 |        2011 |        2 |    212231
               6 |        2011 |        2 |    189166
               2 |        2011 |        6 |    189150
Time: 6627.922 ms
postgres=#

 

转载于:https://my.oschina.net/javacy/blog/2998969

weixin_33859231
关注
greenplum比mysql慢_GreenPlum简单性能测试与分析
weixin_28834169的博客
01-18 1307
如今，多样的交易模式以及大众消费观念的改变使得数据库应用领域不断扩大，现代的大型分布式应用系统的数据膨胀也对数据库的海量数据处理能力和并行处理能力提出了更高的要求，如何在数据呈现海量扩张的同时提高处理速度和应用系统的可用性，使客户能同时得到更高的处理速度、更高的数据可用性和更大的数据集，是数据库系统面临的一个挑战。通过TPC-H基准测试，可获得数据库单位时间内的性能处理能力，为评估数据库系统的现有...
Greenplum问题定位及性能调优
Greenplum中文社区
07-16 1130
...
greenplum 简介及数据库对比
08-21
greenplum 简介及数据库对比 。 greenplum hive infobright 对比。
greenplum数据入库方式总结及性能对比
u011563666的博客
08-22 6323
1.greenplum入库方式总结 greenplum目前主要使用到的入库方式有如下4种： 使用insert into方式入库 使用gpss方式入库 使用gpkafka方式入库 使用gpcopy方式入库 2.以上入库方式优缺点及性能对比 详细优缺点及性能对比如下： 入库方式 优点 缺点 入库性能 ...
阿里云HybridDB for PG实践 - 行存、列存，堆表、AO表的原理和选择
weixin_34232744的博客
08-20 384
标签 PostgreSQL , Greenplum , 向量计算 , 行存储 , 列存 , AO表 背景 Greenplum支持行存和列存，支持堆表和AO表，那么他们有什么不同，如何选择呢？ 行存和列存的原理 1、行存，以行为形式组织存储，一行是一个tuple，存在一起。当需要读取某列时，需要将这列前面的所有列都进行deform，所以访问第一列和访...
列存储和行存储 java_Greenplum行存与列存性能对比
weixin_42377742的博客
03-02 420
今天给大家分享一个Greenplum中行存与列存的性能对比，在分析型业务中，如果对数据查询的列数不是很多，还是建议优先选用列存。本文涉及的测试用例就能看出列存恰当使用时，性能能提升3倍！！测试结果对比：SQL行存响应(ms)列存响应(ms)SELECT cab_type, count(*) FROM trips GROUP BY cab_type;9539.6073060.362SELECT pa...
《GreenPlum/Postgres系列》PostgreSQL和GreenPlum比较
https://blog.datasource.space
03-16 3658
PostgreSQL是以加州大学伯克利分校计算机系开发的POSTFGRES，现在已经更名为POSTGRES，版本4.2为基础的对象关系型数据库管理系统(ORDBMS)。PostgreSQL支持大部分的SQL标准并且提供了许多其他现代特性：复杂查询、外键、触发器、视图、事务完整性、MVCC。同样，PostgreSQL可以用许多方法扩展，比如：通过增加新的数据类型、函数、操作符、聚集函数、索引方法、过程语言。
greenplum product document
02-03
- **GPORCA作为默认优化器**：Greenplum 5.0.0中将GPORCA作为查询优化器的默认选项，GPORCA（ORCA是列存优化器）是为了提升大数据处理能力而设计的。 - **遗留优化器变更**：对旧版优化器也进行了变更，这可能影响到...
Greenplum MVCC并发控制：严格的一致性与极致的性能
Greenplum中文社区
09-03 915
了解更多Greenplum技术干货，欢迎访问Greenplum中文社区网站 2020的夏天已经接近尾声，《深入浅出Greenplum内核》系列直播也已经成功举办了五场活动，内容覆盖了Greenplum架构、执行引擎、查询优化、B树索引（均插入之前的总结文章链接），相关视频可前往B站的Greenplum中文社区频道进行回顾观看。 8月28日，Greenplum原厂内核研发陈金豹从优缺点、实现细节、和空间重用三个角度深度揭秘了Greenplum的MVCC并发控制。本文将带领我们回顾精华内容。 MVCC，全称.
SQL Server向Greenplum_移植参考手册
09-18
3. **建表语句**：Greenplum支持的建表语句与SQL Server有所不同，比如分区表的定义、列存与行存的选择等，需要对这些特性有深入理解。 4. **数据导出**：使用SQL Server的导出工具，如bcp或SSIS，将数据导出为可读...
Greenplum性能测试报告.docx
07-28
Greenplum数据查询性能测试报告，包括架构介绍，数据查询分析测试报告，单表和多表join的测试性能分析
OLAP(总)：Impala/Druid/Presto/Kylin/Clickhouse/Greenplum等对比
热门推荐
.
10-13 2万+
OLAP（On-LineAnalytical Processing）联机分析处理，也称为面向交易的处理过程，其基本特征是前台接收的用户数据可以立即传送到计算中心进行处理，并在很短的时间内给出处理结果，是对用户操作快速响应的方式之一。应用在数据仓库，使用对象是决策者。OLAP系统强调的是数据分析，响应速度要求没那么高。目前市面上主流的开源OLAP引擎包含不限于：Hive、Presto、Kylin、Impala、Sparksql、Druid、Greenplum等 OLTP（On-Line Transact..
数据库行式存储和列式存储的区别
u013986335的博客
04-27 1908
行式存储，列式存储
GreenPlum系列-6-表设计之存储类型、分布、分区的介绍
最新发布
IfNotExists的博客
01-09 3136
在实际的生产中创建表之前需要对业务需求分析，包括使用堆存储还是追加优化存储、选择行存还是列存是否需要压缩、分布键的选择、分区的使用。
PostgreSQL DBA(60) - 列式存储zedstore
07-22 1942
本节简单介绍了Greenplum开源的列式存储zedstore的安装和使用. 安装 从Github上下载源码,与普通P...
greenplum,teradata,presto,clickhouse四种分布式数据库的对比
MyySophia的博客
06-05 2675
1. 四种数据库的比较 数据库 描述 Greenplum 开源大规模并行数据分析引擎。借助MPP架构，在大型数据集上执行复杂SQL分析的速度比很多解决方案都要快。应用广泛。 Teradata 大型数据仓库系统，产品成熟，价格昂贵。用于证券系统。 Presto 分布式SQL查询引擎， 专门进行高速、实时的数据分析。本身不存储数据，但是可以接入多种数据源。擅长对海量数据进行复杂的分析。用于大数据...
Greenplum性能优化之路 --（二）存储格式
jc_benben的专栏
07-10 1672
存储格式介绍 Greenplum（以下简称GP）有2种存储格式，Heap表和AO表（AORO表，AOCO表）。 Heap表：这种存储格式是从PostgreSQL继承而来的，目前是GP默认的表存储格式，只支持行存储。 AO表： AO表最初设计是只支持append的（就是只能insert），因此全称是Append-Only，在4.3之后进行了优化，目前已经可以update和delete了，全称也改为Append-Optimized。AO支持行存储（AORO）和列存储（AOCO）。 Heap表 Heap表
Greenplum行存与列存的选择以及转换方法
weixin_33860528的博客
08-15 2007
背景 数据在数据库中的存储形式多种多样，比较常见的如 1. PostgreSQL的堆表，以行的形式存储，（当变成字段压缩后的长度超过数据块的四分之一时，会以TOAST的形式存储到TOAST表）。 2. MySQL innodb则是以b+tree形式存储的。 在数据仓库产品中，如Greenplum，支持行存，也支持列存。 还有很多存储格式，本文将讨论行存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值