免费体验PolarDB PostgreSQL向量化引擎_云原生数据库 PolarDB(PolarDB)-阿里云帮助中心

本文介绍如何免费体验PolarDB PostgreSQL版向量化引擎功能。

背景

PolarDB向量化引擎是针对HTAP场景、OLTP中的慢SQL场景而研发的查询加速方案。典型使用场景包括：实时的统计与分析、灵活查询条件（复合索引不灵活）、基于地理网格的时空统计、与OSS结合的冷数据加速统计等。具体优势包括：

高性能：与PostgreSQL原生行存执行引擎相比，性能可提升15-30倍，最高可提升百倍。比如在TPC-H场景下，可提升近30倍。
低成本：只需为查询用到的列创建列存索引，无需将整表转成列存。列存格式索引占用的空间小。此外PolarDB PostgreSQL版支持OSS冷数据查询与分析，可以有效降低数据存储成本。
易用性：兼容PostgreSQL语法，支持基于PostgreSQL的索引机制。支持精细化控制OLTP与OLAP查询。
实时性：自动维护行存与列存索引之间的实时数据一致性，无需额外构建行列数据转换链路。
功能全面：
- 支持Prepared Statement语法。
- 支持分区表与pg_pathman。
- 支持事务块内SELECT语句的加速。
- 支持CREATE TABLE AS等ETL功能。

阿里云提供了数据库解决方案功能体验馆，提供真实免费的PolarDB集群环境和开箱即用的测试方法，您可以在线快捷体验向量化引擎带来的提升效果。

影响

本功能体验不涉及生产环境的部署，因此不会影响业务。

费用

本次体验中，由于体验涉及到的资源不归属于您，因此不会产生任何费用，您可以放心体验。

体验内容

体验环境

在本免费体验中，阿里云提供了预置环境供您操作体验，预置环境的详情如下：

集群：提供了一个PolarDB PostgreSQL版集群。具体如下：
- 内核版本： 14.13.27.0
- 产品版本：企业版
- 系列：集群版独享规格
- 集群规格：集群包含1个主节点和1个只读节点，规格都为2核8 GB
- 存储类型： PSL5
测试数据集：集群中预置了标准测试集TPCH 10G的数据集。

观测指标

CPU占用率：集群中主节点、只读节点和只读列存节点的平均CPU使用率。单位：%。
查询耗时：执行特定SQL所耗费的时间。单位：秒。

操作步骤

进入瑶池解决方案体验馆。
单击核心功能体验，然后单击列存索引-加速TP复杂SQL查询的免费体验按钮。
在产品选项中选择PolarDB PostgreSQL。
单击页面下方的创建免费体验任务按钮。
在确认创建查询加速体验任务对话框中，单击确定。
稍等片刻后，可以看到您创建的体验任务。
单击查看详情，进入实时查询体验页面。

使用行存引擎和向量化引擎分别进行单表统计和多表JOIN两个场景的SQL语句查询。

说明

请根据页面按钮提示，手动单击按钮执行每一步操作。若在倒计时结束时没有手动单击按钮，则会自动执行对应操作。
整个体验过程中，您可以在下方的趋势图中观测CPU占用率。

单击开始任务。
单击选择数据库，自动执行如下命令，切换至目标数据库。
```
\c mydb
```

首先进行单表统计场景查询。

首先进行单表统计的普通查询，单击关闭向量化引擎，自动执行如下命令。
```
set polar_csi.enable_query to off;
```

单击查看SQL执行计划，自动执行如下命令，查看如下SQL的执行计划。

explain select
   l_returnflag,
   l_linestatus,
   sum(l_quantity) as sum_qty,
   sum(l_extendedprice) as sum_base_price,
   sum(l_extendedprice * (1 - l_discount)) as sum_disc_price,
   sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge,
   avg(l_quantity) as avg_qty,
   avg(l_extendedprice) as avg_price,
   avg(l_discount) as avg_disc,
   count(*) as count_order
from
   lineitem
where l_shipdate <= date '1998-12-01' - '60 day'::interval
 group by
   l_returnflag,
   l_linestatus
order by
   l_returnflag,
   l_linestatus;

此时查询计划中并未使用向量化引擎/列存索引，返回结果如下：

                                              QUERY PLAN                                               
-------------------------------------------------------------------------------------------------------
 Finalize GroupAggregate  (cost=2307510.18..2307512.14 rows=6 width=236)
   Group Key: l_returnflag, l_linestatus
   ->  Gather Merge  (cost=2307510.18..2307511.58 rows=12 width=236)
         Workers Planned: 2
         ->  Sort  (cost=2306510.16..2306510.17 rows=6 width=236)
               Sort Key: l_returnflag, l_linestatus
               ->  Partial HashAggregate  (cost=2306509.95..2306510.08 rows=6 width=236)
                     Group Key: l_returnflag, l_linestatus
                     ->  Parallel Seq Scan on lineitem  (cost=0.00..1437900.14 rows=24817423 width=25)
                           Filter: (l_shipdate <= '1998-10-02 00:00:00'::timestamp without time zone)
(10 rows)

单击执行SQL，自动执行以下SQL语句：

select
   l_returnflag,
   l_linestatus,
   sum(l_quantity) as sum_qty,
   sum(l_extendedprice) as sum_base_price,
   sum(l_extendedprice * (1 - l_discount)) as sum_disc_price,
   sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge,
   avg(l_quantity) as avg_qty,
   avg(l_extendedprice) as avg_price,
   avg(l_discount) as avg_disc,
   count(*) as count_order
from
   lineitem
where l_shipdate <= date '1998-12-01' - '60 day'::interval
 group by
   l_returnflag,
   l_linestatus
order by
   l_returnflag,
   l_linestatus;

返回结果如下，执行时间为29.998秒。

 l_returnflag | l_linestatus |   sum_qty    |  sum_base_price  |   sum_disc_price   |      sum_charge      |       avg_qty       |     avg_price      |        avg_disc        | count_order 
--------------+--------------+--------------+------------------+--------------------+----------------------+---------------------+--------------------+------------------------+-------------
 A            | F            | 377518399.00 |  566065727797.25 |  537759104278.0656 |  559276670892.116819 | 25.5009751030070973 | 38237.151008958546 | 0.05000657454024320463 |    14804077
 N            | F            |   9851614.00 |   14767438399.17 |   14028805792.2114 |   14590490998.366737 | 25.5224483028409474 | 38257.810660081140 | 0.04997336773765667180 |      385998
 N            | O            | 755019122.00 | 1132129731453.74 | 1075518177478.8293 | 1118551353535.822147 | 25.4984266349481027 | 38234.166602626373 | 0.05000018236823388523 |    29610420
 R            | F            | 377732830.00 |  566431054976.00 |  538110922664.7677 |  559634780885.086257 | 25.5083847896801383 | 38251.219273559761 | 0.04999679231408742045 |    14808183
(4 rows)

Time: 29998.041 ms (00:29.998)

然后进行单表统计的加速查询。单击开启向量化引擎，自动执行如下命令。
```
set polar_csi.enable_query to on;
```

单击查看SQL执行计划，自动执行如下命令，查看如下SQL的执行计划。

explain select
   l_returnflag,
   l_linestatus,
   sum(l_quantity) as sum_qty,
   sum(l_extendedprice) as sum_base_price,
   sum(l_extendedprice * (1 - l_discount)) as sum_disc_price,
   sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge,
   avg(l_quantity) as avg_qty,
   avg(l_extendedprice) as avg_price,
   avg(l_discount) as avg_disc,
   count(*) as count_order
from
   lineitem
where l_shipdate <= date '1998-12-01' - '60 day'::interval
 group by
   l_returnflag,
   l_linestatus
order by
   l_returnflag,
   l_linestatus;

此时查询计划使用向量化引擎/列存索引，返回结果如下：

  QUERY PLAN  
--------------
 CSI Executor
(1 row)

单击执行SQL，自动执行以下SQL语句：

select
   l_returnflag,
   l_linestatus,
   sum(l_quantity) as sum_qty,
   sum(l_extendedprice) as sum_base_price,
   sum(l_extendedprice * (1 - l_discount)) as sum_disc_price,
   sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge,
   avg(l_quantity) as avg_qty,
   avg(l_extendedprice) as avg_price,
   avg(l_discount) as avg_disc,
   count(*) as count_order
from
   lineitem
where l_shipdate <= date '1998-12-01' - '60 day'::interval
 group by
   l_returnflag,
   l_linestatus
order by
   l_returnflag,
   l_linestatus;

返回结果如下，执行时间为0.496秒。

 l_returnflag | l_linestatus |   sum_qty    |  sum_base_price  |   sum_disc_price   |      sum_charge      |     avg_qty      |    avg_price     |      avg_disc      | count_order 
--------------+--------------+--------------+------------------+--------------------+----------------------+------------------+------------------+--------------------+-------------
 A            | F            | 377518399.00 |  566065727797.25 |  537759104278.0656 |  559276670892.116819 | 25.5009751030071 | 38237.1510089585 | 0.0500065745402432 |    14804077
 N            | F            |   9851614.00 |   14767438399.17 |   14028805792.2114 |   14590490998.366737 | 25.5224483028409 | 38257.8106600811 | 0.0499733677376567 |      385998
 N            | O            | 755019122.00 | 1132129731453.74 | 1075518177478.8293 | 1118551353535.822147 | 25.4984266349481 | 38234.1666026264 | 0.0500001823682339 |    29610420
 R            | F            | 377732830.00 |  566431054976.00 |  538110922664.7677 |  559634780885.086257 | 25.5083847896801 | 38251.2192735598 | 0.0499967923140874 |    14808183
(4 rows)

Time: 496.226 ms

开始进行多表JOIN场景查询。

首先进行多表JOIN的普通查询，单击关闭向量化引擎，自动执行如下命令。
```
set polar_csi.enable_query to off;
```

单击查看SQL执行计划，自动执行如下命令，查看如下SQL的执行计划。

explain select
   l_orderkey,
   sum(l_extendedprice * (1 - l_discount)) as revenue,
   o_orderdate,
   o_shippriority
from
   customer,orders,
   lineitem
where
   c_mktsegment = 'FURNITURE'
   and c_custkey = o_custkey
   and l_orderkey = o_orderkey
   and o_orderdate < date '1995-03-05'
   and l_shipdate > date '1995-03-05'
group by
   l_orderkey,
   o_orderdate,
   o_shippriority
order by revenue desc, o_orderdate limit 10;

此时查询计划中并未使用向量化引擎/列存索引，返回结果如下：

                                                              QUERY PLAN                                                              
--------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=2714604.62..2714604.64 rows=10 width=44)
   ->  Sort  (cost=2714604.62..2722505.04 rows=3160168 width=44)
         Sort Key: (sum((lineitem.l_extendedprice * ('1'::numeric - lineitem.l_discount)))) DESC, orders.o_orderdate
         ->  Finalize GroupAggregate  (cost=2230423.64..2646314.52 rows=3160168 width=44)
               Group Key: lineitem.l_orderkey, orders.o_orderdate, orders.o_shippriority
               ->  Gather Merge  (cost=2230423.64..2573894.00 rows=2633474 width=44)
                     Workers Planned: 2
                     ->  Partial GroupAggregate  (cost=2229423.62..2268925.73 rows=1316737 width=44)
                           Group Key: lineitem.l_orderkey, orders.o_orderdate, orders.o_shippriority
                           ->  Sort  (cost=2229423.62..2232715.46 rows=1316737 width=24)
                                 Sort Key: lineitem.l_orderkey, orders.o_orderdate, orders.o_shippriority
                                 ->  Parallel Hash Join  (cost=434379.92..2063951.34 rows=1316737 width=24)
                                       Hash Cond: (lineitem.l_orderkey = orders.o_orderkey)
                                       ->  Parallel Seq Scan on lineitem  (cost=0.00..1437900.14 rows=13555969 width=16)
                                             Filter: (l_shipdate > '1995-03-05'::date)
                                       ->  Parallel Hash  (cost=423823.16..423823.16 rows=607261 width=12)
                                             ->  Parallel Hash Join  (cost=46232.51..423823.16 rows=607261 width=12)
                                                   Hash Cond: (orders.o_custkey = customer.c_custkey)
                                                   ->  Parallel Seq Scan on orders  (cost=0.00..339779.89 rows=3011708 width=16)
                                                         Filter: (o_orderdate < '1995-03-05'::date)
                                                   ->  Parallel Hash  (cost=44164.29..44164.29 rows=126018 width=4)
                                                         ->  Parallel Seq Scan on customer  (cost=0.00..44164.29 rows=126018 width=4)
                                                               Filter: (c_mktsegment = 'FURNITURE'::bpchar)
(23 rows)

单击执行SQL，自动执行以下SQL语句：

select
   l_orderkey,
   sum(l_extendedprice * (1 - l_discount)) as revenue,
   o_orderdate,
   o_shippriority
from
   customer,orders,
   lineitem
where
   c_mktsegment = 'FURNITURE'
   and c_custkey = o_custkey
   and l_orderkey = o_orderkey
   and o_orderdate < date '1995-03-05'
   and l_shipdate > date '1995-03-05'
group by
   l_orderkey,
   o_orderdate,
   o_shippriority
order by revenue desc, o_orderdate limit 10;

返回结果如下，执行时间为15.105秒。

 l_orderkey |   revenue   | o_orderdate | o_shippriority 
------------+-------------+-------------+----------------
   16716836 | 457530.6898 | 1995-01-28  |              0
   49108805 | 437309.8833 | 1995-02-24  |              0
   59180740 | 424083.7684 | 1995-02-04  |              0
    3459808 | 423001.2631 | 1995-03-04  |              0
   26812736 | 422055.4106 | 1995-02-27  |              0
   19938211 | 421534.7725 | 1995-02-16  |              0
   44247173 | 421467.1845 | 1995-02-14  |              0
   10666915 | 415306.2064 | 1995-02-14  |              0
   23005989 | 413233.6425 | 1995-01-22  |              0
   35934054 | 412331.2913 | 1995-02-17  |              0
(10 rows)

Time: 15104.732 ms (00:15.105)

然后进行单表统计的加速查询。单击开启向量化引擎，自动执行如下命令。
```
set polar_csi.enable_query to on;
```

单击查看SQL执行计划，自动执行如下命令，查看如下SQL的执行计划。

explain select
   l_orderkey,
   sum(l_extendedprice * (1 - l_discount)) as revenue,
   o_orderdate,
   o_shippriority
from
   customer,orders,
   lineitem
where
   c_mktsegment = 'FURNITURE'
   and c_custkey = o_custkey
   and l_orderkey = o_orderkey
   and o_orderdate < date '1995-03-05'
   and l_shipdate > date '1995-03-05'
group by
   l_orderkey,
   o_orderdate,
   o_shippriority
order by revenue desc, o_orderdate limit 10;

此时查询计划使用向量化引擎/列存索引，返回结果如下：

  QUERY PLAN  
--------------
 CSI Executor
(1 row)

单击执行SQL，自动执行以下SQL语句：

select
   l_orderkey,
   sum(l_extendedprice * (1 - l_discount)) as revenue,
   o_orderdate,
   o_shippriority
from
   customer,orders,
   lineitem
where
   c_mktsegment = 'FURNITURE'
   and c_custkey = o_custkey
   and l_orderkey = o_orderkey
   and o_orderdate < date '1995-03-05'
   and l_shipdate > date '1995-03-05'
group by
   l_orderkey,
   o_orderdate,
   o_shippriority
order by revenue desc, o_orderdate limit 10;

返回结果如下，执行时间为0.354秒。

 l_orderkey |   revenue   | o_orderdate | o_shippriority 
------------+-------------+-------------+----------------
   16716836 | 457530.6898 | 1995-01-28  |              0
   49108805 | 437309.8833 | 1995-02-24  |              0
   59180740 | 424083.7684 | 1995-02-04  |              0
    3459808 | 423001.2631 | 1995-03-04  |              0
   26812736 | 422055.4106 | 1995-02-27  |              0
   19938211 | 421534.7725 | 1995-02-16  |              0
   44247173 | 421467.1845 | 1995-02-14  |              0
   10666915 | 415306.2064 | 1995-02-14  |              0
   23005989 | 413233.6425 | 1995-01-22  |              0
   35934054 | 412331.2913 | 1995-02-17  |              0
(10 rows)

Time: 354.131 ms

整个执行SQL的过程中，您可以在左侧趋势图中观测集群平均CPU使用率的变化情况。
说明
由于实时监控数据可能存在延迟，为了确保展示完整的CPU变化情况，趋势图中会在SQL执行完后，自动延长一定监控时间（2~3秒）。
（可选）对于已创建的任务，您可以在列存索引-加速TP复杂SQL查询页面，单击体验记录，在任务列表中，单击全部任务或我的任务，查看体验结果及其详情。

结果分析

从本方案中您可以体验到PolarDB PostgreSQL向量化引擎的如下优势：

1. 使用方式简单，无需更改查询SQL即可实现加速效果。

2. 针对单表统计和多表Join场景，向量化引擎均有近30倍以上的性能提升。

向量化引擎对查询有明显加速作用

从执行时间上看，当开启向量化引擎后，复杂查询执行时间大幅缩短，单表统计查询从29.998秒缩短至0.496秒，多表JOIN查询从15.105秒缩短至0.354秒。
从执行计划上看，当开启向量化引擎后，执行计划包含CSI Executor，即表示使用向量化引擎功能。

向量化引擎对查询的处理更高效

说明

由于实时监控数据可能存在延迟，为了确保展示完整的CPU变化情况，趋势图中会在SQL执行完后，自动延长一定监控时间（2~3秒）。

从执行时间和对应的CPU占用率可以看到，向量化引擎通过更低的CPU占用率实现了更快的查询。

单表统计查询

多表JOIN查询

专家面对面

您可以加入官方钉钉群进行咨询，获取更多技术支持。钉钉群号：75850003226。

背景

影响

费用

体验内容

体验环境

观测指标

操作步骤

结果分析

向量化引擎对查询有明显加速作用

向量化引擎对查询的处理更高效

相关内容

专家面对面