openGauss真的比PostgreSQL差了10年?

news2024/10/6 8:31:04

前不久写了MogDB针对PostgreSQL的兼容性文章,我在文中提到针对PostgreSQL而言,MogDB兼容性还是不错的,其中也给出了其中一个能源客户之前POC的迁移报告数据。

But很快我发现总有人回留言喷我,而且我发现每次喷的这帮人是根本不看文章内容的,完全就是看了标题就开喷,真是一喷为快!

针对如此多的后台留言,这里为提炼一下,同时我也来尝试“诡辩”一下!

MogDB是基于openGauss,而openGauss是基于PG9.2,现在PG都16了,最差了这么多代,你们还好意思说?

首先我要说下,针对是这个想法的这些有网友,你们真的看了文章内容吗?原生pg是多进程架构,而魔改之后的openGauss是线程架构,架构都不一样了呢,毫不夸张的说,基本上是完全不同的两款数据库产品了。

因此,就谈不上什么版本差了很多代的说法了呢。

那么如果说基于openGauss迭代的MogDB具具备了PG新版本所具有的一些功能,你们又该如何评价呢?

这里我就特意挑选几个小的点!

MogDB支持全局索引而PG不支持

记得前几天PG界的第一红网德哥就吐槽说,PG不支持全局索引。当时我看了之后,我心里一阵纳闷!

不支持全局索引的数据库,这tm的能用吗?这不搞笑的吗?

首先我给大家看下MogDB对于分区表的全局索引支持情况,废话不多说,直接上测试结果:

[omm2@mogdb1 ~]$ gsql -r -d test -U roger
Password for user roger: 
gsql ((MogDB 5.0.7 build c4707384) compiled at 2024-05-24 10:51:53 commit 0 last mr 1804 )
Non-SSL connection (SSL connection is recommended when requiring high-security)
Type "help" for help.

test=> CREATE TABLE list_list
test-> (
test(>     month_code VARCHAR2 ( 30 ) NOT NULL ,
test(>     dept_code  VARCHAR2 ( 30 ) NOT NULL ,
test(>     user_no    VARCHAR2 ( 30 ) NOT NULL ,
test(>     sales_amt  int
test(> )
test-> PARTITION BY LIST (month_code) SUBPARTITION BY LIST (dept_code)
test-> (
test(>   PARTITION p_201901 VALUES ( '201902' )
test(>   (
test(>     SUBPARTITION p_201901_a VALUES ( '1' ),
test(>     SUBPARTITION p_201901_b VALUES ( '2' )
test(>   ),
test(>   PARTITION p_201902 VALUES ( '201903' )
test(>   (
test(>     SUBPARTITION p_201902_a VALUES ( '1' ),
test(>     SUBPARTITION p_201902_b VALUES ( '2' )
test(>   )
test(> );
CREATE TABLE
test=> insert into list_list values('201902''1''1', 1);
INSERT 0 1
test=> insert into list_list values('201902''2''1', 1);
INSERT 0 1
test=> insert into list_list values('201902''1''1', 1);
INSERT 0 1
test=> insert into list_list values('201903''2''1', 1);
INSERT 0 1
test=> insert into list_list values('201903''1''1', 1);
INSERT 0 1
test=> insert into list_list values('201903''2''1', 1);
INSERT 0 1
test=> create index idx_list_list on list_list(user_no) global;
CREATE INDEX
test=> explain select * from list_list where user_no=1;
                                  QUERY PLAN                                  
------------------------------------------------------------------------------
 Partition Iterator  (cost=0.00..14.57 rows=2 width=238)
   Iterations: 2, Sub Iterations: 4
   Selected Partitions:  1..2
   Selected Subpartitions:  1:ALL, 2:ALL
   ->  Partitioned Seq Scan on list_list  (cost=0.00..14.57 rows=2 width=238)
         Filter: ((user_no)::bigint = 1)
(6 rows)

test=> \di+
                                                     List of relations
 Schema |          Name           |          Type          | Owner |      Table       |    Size    | Storage | Description 
--------+-------------------------+------------------------+-------+------------------+------------+---------+-------------
 public | index_prune_tt01        | index                  | omm2  | prune_tt01       | 64 kB      |         | 
 public | table_1188398_2_pk      | index                  | omm2  | table_1188398_2  | 16 kB      |         | 
 roger  | idx_list_list           | global partition index | roger | list_list        | 16 kB      |         | 
 roger  | idx_test01_objectid     | index                  | roger | test01           | 245 MB     |         | 
 roger  | idx_test01_owner        | index                  | roger | test01           | 248 MB     |         | 
 roger  | t2_pkey                 | index                  | roger | t2               | 8192 bytes |         | 
 roger  | test_incresort_1_id_idx | index                  | roger | test_incresort_1 | 301 MB     |         | 
(7 rows)

大家可以看到这个分区的创建与法基本上跟Oracle一致,哪怕是二级分区,也支持创建global index的。

接下来我们看看PostgreSQL 13是否支持在分区表上创建Global Index。

postgres_5432@mogdb3 bin]$ ./psql
psql (13.2)
Type "help" for help.

postgres=# select version();
                                                version                                                 
---------------------------------------------------------------------------------------------------------
PostgreSQL 13.2 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-44), 64-bit
(1 row)

postgres=#   CREATE TABLE list_list
postgres-#  (
postgres(#      month_code VARCHAR2 ( 30 ) NOT NULL ,
postgres(#      dept_code  VARCHAR2 ( 30 ) NOT NULL ,
postgres(#      user_no    VARCHAR2 ( 30 ) NOT NULL ,
postgres(#      sales_amt  int
postgres(#  )
postgres-#  PARTITION BY LIST (month_code) SUBPARTITION BY LIST (dept_code)
postgres-#  (
postgres(#    PARTITION p_201901 VALUES ( '201902' )
postgres(#    (
postgres(#      SUBPARTITION p_201901_a VALUES ( '1' ),
postgres(#      SUBPARTITION p_201901_b VALUES ( '2' )
postgres(#    ),
postgres(#    PARTITION p_201902 VALUES ( '201903' )
postgres(#    (
postgres(#      SUBPARTITION p_201902_a VALUES ( '1' ),
postgres(#      SUBPARTITION p_201902_b VALUES ( '2' )
postgres(#    )
postgres(#  );
ERROR:  syntax error at or near "SUBPARTITION"
LINE 8:  PARTITION BY LIST (month_code) SUBPARTITION BY LIST (dept_c...
                                       ^
postgres=#   
postgres=# CREATE TABLE measurement (
postgres(#     city_id         int not null,
postgres(#     logdate         date not null,
postgres(#     peaktemp        int,
postgres(#     unitsales       int
postgres(# ) PARTITION BY RANGE (logdate);
CREATE TABLE
postgres=
postgres=
postgres=# create table measurement_2022_1 partition of measurement
postgres-# for values from ('2022-01-01') to ('2022-02-01');
CREATE TABLE
postgres=
postgres=#  create table measurement_2022_2 partition of measurement
postgres-# for values from ('2022-02-01') to ('2022-03-01');
CREATE TABLE
postgres=
postgres=#  create table measurement_2022_3 partition of measurement
postgres-#  for values from ('2022-03-01') to ('2022-04-01');
CREATE TABLE
postgres=
postgres=# create index idx_measurement_date on measurement(logdate) global;
ERROR:  syntax error at or near "global"
LINE 1: ...e index idx_measurement_date on measurement(logdate) global;
                                                               ^
postgres=# create index idx_measurement_date on measurement(logdate);
CREATE INDEX

postgres=# insert into measurement(city_id,logdate,peaktemp,unitsales)  values(1,'2022-01-01',1,1);
INSERT 0 1
postgres=# insert into measurement(city_id,logdate,peaktemp,unitsales)  values(2,'2022-02-01',2,2);
INSERT 0 1
postgres=# insert into measurement(city_id,logdate,peaktemp,unitsales)  values(3,'2022-03-01',3,3);
INSERT 0 1
postgres=# \di+
                                                        List of relations
Schema |              Name              |       Type        |  Owner   |       Table        | Persistence |  Size   | Description 
--------+--------------------------------+-------------------+----------+--------------------+-------------+---------+-------------
public | idx_measurement_date           | partitioned index | postgres | measurement        | permanent   | 0 bytes | 
public | measurement_2022_1_logdate_idx | index             | postgres | measurement_2022_1 | permanent   | 16 kB   | 
public | measurement_2022_2_logdate_idx | index             | postgres | measurement_2022_2 | permanent   | 16 kB   | 
public | measurement_2022_3_logdate_idx | index             | postgres | measurement_2022_3 | permanent   | 16 kB   | 
(4 rows)

postgres=
ostgres=# explain select * from measurement where logdate > '2022-02-01';
                                            QUERY PLAN                                              
-----------------------------------------------------------------------------------------------------
Append  (cost=8.93..59.46 rows=1234 width=16)
  ->  Bitmap Heap Scan on measurement_2022_2 measurement_1  (cost=8.93..26.65 rows=617 width=16)
        Recheck Cond: (logdate > '2022-02-01'::date)
        ->  Bitmap Index Scan on measurement_2022_2_logdate_idx  (cost=0.00..8.78 rows=617 width=0)
              Index Cond: (logdate > '2022-02-01'::date)
  ->  Bitmap Heap Scan on measurement_2022_3 measurement_2  (cost=8.93..26.65 rows=617 width=16)
        Recheck Cond: (logdate > '2022-02-01'::date)
        ->  Bitmap Index Scan on measurement_2022_3_logdate_idx  (cost=0.00..8.78 rows=617 width=0)
              Index Cond: (logdate > '2022-02-01'::date)
(9 rows)

Time: 0.792 ms
postgres=# select * from measurement where logdate > '2022-02-01';
city_id |  logdate   | peaktemp | unitsales 
---------+------------+----------+-----------
      3 | 2022-03-01 |        3 |         3
(1 row)

Time: 0.491 ms

这是什么鬼?实际上我们可以看到PG的分区创建方式是有所区别的,简单的讲,其子分区已经是一个独立的表了,独立的文件。

不过从原理上来讲,我认为没有全局索引,还是一定程度上会影响查询性能,虽然local index其实也足够用了。

这个给大家举个例子,记得2014年去给某头部快递公司做数据库优化时(用的是Oracle exdata),发现一个访问非常高频的大表上的索引创建就不合理。

可能之前DBA是为了维护方便,索引几乎都是清一色的local分区,然而后面发现SQL的逻辑读非常高,在双11来临之前改成global index之后,逻辑读降低了数倍。当然最后系统CPU也降低了很多。

PG16新增的几个json函数,MogDB已经支持了

第二小的点是Postsql16新增的几个json处理函数,实际上MogDB 早就支持了。

大家可以参考pg的官方文档:https://www.postgresql.org/docs/16/release-16.html

[omm2@mogdb1 bin]$ gsql -r
gsql ((MogDB 5.0.7 build c4707384) compiled at 2024-05-24 10:51:53 commit 0 last mr 1804 )
Non-SSL connection (SSL connection is recommended when requiring high-security)
Type "help" for help.

MogDB=# \c dbm
Non-SSL connection (SSL connection is recommended when requiring high-security)
You are now connected to database "dbm" as user "omm2".
dbm=
dbm=# select json_array(1,'a','b',true,null);
        json_array         
---------------------------
 [1, "a""b"true, null]
(1 row)

dbm=#  CREATE TEMP TABLE foo1 (serial_num int, name text, type text);
CREATE TABLE
dbm=# INSERT INTO foo1 VALUES (847001,'t15','GE1043');
INSERT 0 1
dbm=# INSERT INTO foo1 VALUES (847002,'t16','GE1043');
INSERT 0 1
dbm=# INSERT INTO foo1 VALUES (847003,'sub-alpha','GESS90');
INSERT 0 1
dbm=# SELECT json_arrayagg(type) from foo1;
         json_arrayagg          
--------------------------------
 ["GE1043""GE1043""GESS90"]
(1 row)


dbm=# select json_object('{a,b,"a b c"}', '{a,1,1}');
              json_object              
---------------------------------------
 {"a" : "a""b" : "1""a b c" : "1"}
(1 row)

dbm=# select serial_num,JSON_OBJECTAGG(name,type) from foo1 group by serial_num;
 serial_num |     json_objectagg      
------------+-------------------------
     847003 | {"sub-alpha""GESS90"}
     847001 | {"t15""GE1043"}
     847002 | {"t16""GE1043"}
(3 rows)

dbm=

上述提到的几个函数,实际上我在PG13.2上测试发现是不支持的。

[postgres_5432@mogdb3 bin]$ ./psql
psql (13.2)
Type "help" for help.

postgres=# select json_array(1,'a','b',true,null);
ERROR:  function json_array(integer, unknown, unknown, boolean, unknown) does not exist
LINE 1: select json_array(1,'a','b',true,null);
               ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
postgres=#     
postgres=
postgres=# CREATE TEMP TABLE foo1 (serial_num int, name text, type text);
CREATE TABLE
postgres=# INSERT INTO foo1 VALUES (847001,'t15','GE1043');
INSERT 0 1
postgres=# INSERT INTO foo1 VALUES (847002,'t16','GE1043');
INSERT 0 1
postgres=# INSERT INTO foo1 VALUES (847003,'sub-alpha','GESS90');
INSERT 0 1
postgres=# SELECT json_arrayagg(type) from foo1;
ERROR:  function json_arrayagg(text) does not exist
LINE 1: SELECT json_arrayagg(type) from foo1;
               ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
postgres=

postgres=# select serial_num,JSON_OBJECTAGG(name,type) from foo1 group by serial_num;
ERROR:  function json_objectagg(text, text) does not exist
LINE 1: select serial_num,JSON_OBJECTAGG(name,type) from foo1 group ...
                          ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
postgres=

MogDB 排序算法并不比PG主流版本差

另外我在看PG16的new feature时发现提到在优化器方面又有一些改进,其中一点就是对于增量排序(Allow incremental sorts in more cases, including DISTINCT (David Rowley)。

这里我想说的是,MogDB在这方面实际上也做了一些努力,在MogDB 3.1版本之前其实还是比较慢的。不相信? 好吧,给你看看同为openGauss系的友商数据库性能。

orcl=# \copy mogdb_incresort_1 from '/tmp/MogDB_incresort_1.dat';
Time: 45158.913 ms
orcl=# select count(1) from mogdb_incresort_1;
  count   
----------
 10000000
(1 row)

Time: 3986.539 ms
orcl=#  select players.pname,
orcl-#      random() as lottery_number
orcl-#  from (
orcl(#          select distinct pname
orcl(#          from MogDB_incresort_1
orcl(#          group by pname
orcl(#          order by pname
orcl(#      ) as players
orcl-#  order by players.pname,
orcl-#      lottery_number
orcl-#  limit 20;
      pname       |  lottery_number   
------------------+-------------------
 player# 1        |  .693211137317121
 player# 10       |  .373950335662812
 player# 100      |  .748802043031901
 player# 1000     |  .868999985512346
 player# 10000    |  .708094645757228
 player# 100000   |  .146068200934678
 player# 1000000  |  .400482173077762
 player# 10000000 | .0748530034907162
 player# 1000001  |  .951222819741815
 player# 1000002  | .0985643910244107
 player# 1000003  |  .673836125060916
 player# 1000004  |  .493436659686267
 player# 1000005  |  .744129443541169
 player# 1000006  |   .45777113456279
 player# 1000007  |   .90621894877404
 player# 1000008  |  .818961981683969
 player# 1000009  |   .91224535740912
 player# 100001   |  .955949443858117
 player# 1000010  |  .175989827606827
 player# 1000011  | .0911367381922901
(20 rows)

Time: 33222.676 ms
orcl=# explain analyze
orcl-#  select players.pname,
orcl-#      random() as lottery_number
orcl-#  from (
orcl(#          select distinct pname
orcl(#          from MogDB_incresort_1
orcl(#          group by pname
orcl(#          order by pname
orcl(#      ) as players
orcl-#  order by players.pname,
orcl-#      lottery_number
orcl-#  limit 20;
                                                                              QUERY PLAN                                                                               
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=5984227.96..5984228.01 rows=20 width=128) (actual time=37477.723..37477.728 rows=20 loops=1)
   ->  Sort  (cost=5984227.96..6009228.03 rows=10000029 width=128) (actual time=37477.718..37477.719 rows=20 loops=1)
         Sort Key: players.pname, (random())
         Sort Method: top-N heapsort  Memory: 30kB
         ->  Subquery Scan on players  (cost=5518130.20..5718130.78 rows=10000029 width=128) (actual time=17705.988..34580.240 rows=10000000 loops=1)
               ->  Unique  (cost=5518130.20..5593130.42 rows=10000029 width=128) (actual time=17705.951..26398.773 rows=10000000 loops=1)
                     ->  Group  (cost=5518130.20..5568130.35 rows=10000029 width=128) (actual time=17705.947..23714.165 rows=10000000 loops=1)
                           Group By Key: mogdb_incresort_1.pname
                           ->  Sort  (cost=5518130.20..5543130.28 rows=10000029 width=128) (actual time=17705.940..20369.481 rows=10000000 loops=1)
                                 Sort Key: mogdb_incresort_1.pname
                                 Sort Method: external merge  Disk: 1350368kB
                                 ->  Seq Scan on mogdb_incresort_1  (cost=0.00..356411.29 rows=10000029 width=128) (actual time=0.020..2464.995 rows=10000000 loops=1)
 Total runtime: 37478.118 ms
(13 rows)

Time: 37480.533 ms

是的,你没有看错,这个简单的测试SQL 居然跑了30多秒。

那么我们来看在MogDB5.0.7版本中跑一下需要多久呢?

test=# \copy mogdb_incresort_1 from '/tmp/MogDB_incresort_1.dat';
test=# \timing on
test=# explain analyze
test-#  select players.pname,
test-#      random() as lottery_number
test-#  from (
test(#          select distinct pname
test(#          from MogDB_incresort_1
test(#          group by pname
test(#          order by pname
test(#      ) as players
test-#  order by players.pname,
test-#      lottery_number
test-#  limit 20;
                                                                             QUERY PLAN                                                                              
---------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=2174587.26..2174588.44 rows=20 width=64) (actual time=5315.519..5315.524 rows=20 loops=1)
   ->  Incremental Sort  (cost=2174587.26..2763354.30 rows=9999951 width=64) (actual time=5315.517..5315.518 rows=20 loops=1)
         Sort Key: players.pname, (random())
         Presorted Key: players.pname
         Full-sort Groups: 1  Sort Method: quicksort  Average Memory: 28kB Peak Memory: 28kB
         ->  Subquery Scan on players  (cost=2172256.79..2372255.81 rows=9999951 width=64) (actual time=5315.453..5315.487 rows=21 loops=1)
               ->  Unique  (cost=2172256.79..2247256.43 rows=9999951 width=64) (actual time=5315.433..5315.452 rows=21 loops=1)
                     ->  Group  (cost=2172256.79..2222256.55 rows=9999951 width=64) (actual time=5315.425..5315.442 rows=21 loops=1)
                           Group By Key: mogdb_incresort_1.pname
                           ->  Sort  (cost=2172256.79..2197256.67 rows=9999951 width=64) (actual time=5315.420..5315.425 rows=21 loops=1)
                                 Sort Key: mogdb_incresort_1.pname
                                 Sort Method: external merge  Disk: 665520kB
                                 ->  Seq Scan on mogdb_incresort_1  (cost=0.00..223456.51 rows=9999951 width=64) (actual time=0.012..1828.749 rows=10000000 loops=1)
 Total runtime: 5449.456 ms
(14 rows)

Time: 5457.669 ms
test=#  select players.pname,
test-#      random() as lottery_number
test-#  from (
test(#          select distinct pname
test(#          from MogDB_incresort_1
test(#          group by pname
test(#          order by pname
test(#      ) as players
test-#  order by players.pname,
test-#      lottery_number
test-#  limit 20;
      pname       |   lottery_number   
------------------+--------------------
 player# 1        |  0.579584513325244
 player# 10       |  0.836566388607025
 player# 100      |  0.843441488686949
 player# 1000     |  0.718995271716267
 player# 10000    |  0.892783336341381
 player# 100000   |   0.10398242296651
 player# 1000000  |  0.308310507796705
 player# 10000000 | 0.0168832587078214
 player# 1000001  |  0.446922336239368
 player# 1000002  | 0.0639159493148327
 player# 1000003  |  0.313714498188347
 player# 1000004  |  0.516515084076673
 player# 1000005  |  0.702487968374044
 player# 1000006  |  0.277854182291776
 player# 1000007  |  0.934525999706239
 player# 1000008  |   0.72923140367493
 player# 1000009  |  0.321010332554579
 player# 100001   |  0.651651729829609
 player# 1000010  |  0.506305878516287
 player# 1000011  |   0.46931520383805
(20 rows)

Time: 4521.001 ms
test=#   

大家可以看到,其实也就不到5s的样子的。还是比较快的。

最后我们看下相同的SQL在PG13中运行效率如何。

postgres=#  create table MogDB_incresort_1 (id int, pname name, match text);
CREATE TABLE
postgres=#  create index on MogDB_incresort_1(id);
CREATE INDEX
postgres=# insert into MogDB_incresort_1
postgres-#  values (
postgres(#          generate_series(1, 10000000),
postgres(#          'player# ' || generate_series(1, 10000000),
postgres(#          'match# ' || generate_series(1, 11)
postgres(#      );
 INSERT 0 10000000
postgres=#  
postgres=
postgres=#  select count(1) from MogDB_incresort_1;
  count   
----------
 10000000
(1 row)

postgres=#  vacuum analyze MogDB_incresort_1;
VACUUM
postgres=# \timing on
Timing is on.
postgres=#   set max_parallel_workers_per_gather = 0;
SET
Time: 0.250 ms
postgres=#  select players.pname,
postgres-#      random() as lottery_number
postgres-#  from (
postgres(#          select distinct pname
postgres(#          from MogDB_incresort_1
postgres(#          group by pname
postgres(#          order by pname
postgres(#      ) as players
postgres-#  order by players.pname,
postgres-#      lottery_number
postgres-#  limit 20;
      pname       |   lottery_number    
------------------+---------------------
 player# 1        |  0.0447521551191592
 player# 10       |   0.408278868270898
 player# 100      |  0.7921926875019913
 player# 1000     | 0.11271848207791635
 player# 10000    |  0.2647472418342467
 player# 100000   |  0.1412932234901234
 player# 1000000  |  0.4266691727193681
 player# 10000000 | 0.46474439957439273
 player# 1000001  | 0.23216838816411567
 player# 1000002  |  0.1229366164369452
 player# 1000003  |  0.3386561272461357
 player# 1000004  |  0.4146373941657302
 player# 1000005  | 0.28414336215408653
 player# 1000006  |  0.3686260468699629
 player# 1000007  |  0.1296536218416513
 player# 1000008  | 0.22829014039084683
 player# 1000009  | 0.15364363544027881
 player# 100001   | 0.08520628747068315
 player# 1000010  |   0.697556601432435
 player# 1000011  |  0.7879138632733813
(20 rows)

Time: 3637.823 ms (00:03.638)
postgres=# explain analyze
postgres-#  select players.pname,
postgres-#      random() as lottery_number
postgres-#  from (
postgres(#          select distinct pname
postgres(#          from MogDB_incresort_1
postgres(#          group by pname
postgres(#          order by pname
postgres(#      ) as players
postgres-#  order by players.pname,
postgres-#      lottery_number
postgres-#  limit 20;
                                                                              QUERY PLAN                                                                              
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=1765110.33..1765111.80 rows=20 width=72) (actual time=3759.205..3759.210 rows=20 loops=1)
   ->  Incremental Sort  (cost=1765110.33..2498764.46 rows=10000017 width=72) (actual time=3759.203..3759.206 rows=20 loops=1)
         Sort Key: players.pname, (random())
         Presorted Key: players.pname
         Full-sort Groups: 1  Sort Method: quicksort  Average Memory: 27kB  Peak Memory: 27kB
         ->  Subquery Scan on players  (cost=1762114.60..1962114.94 rows=10000017 width=72) (actual time=3759.173..3759.192 rows=21 loops=1)
               ->  Unique  (cost=1762114.60..1837114.73 rows=10000017 width=64) (actual time=3759.168..3759.184 rows=21 loops=1)
                     ->  Group  (cost=1762114.60..1812114.69 rows=10000017 width=64) (actual time=3759.167..3759.178 rows=21 loops=1)
                           Group Key: mogdb_incresort_1.pname
                           ->  Sort  (cost=1762114.60..1787114.64 rows=10000017 width=64) (actual time=3759.164..3759.169 rows=21 loops=1)
                                 Sort Key: mogdb_incresort_1.pname
                                 Sort Method: external merge  Disk: 724152kB
                                 ->  Seq Scan on mogdb_incresort_1  (cost=0.00..223457.17 rows=10000017 width=64) (actual time=0.010..1315.358 rows=10000000 loops=1)
 Planning Time: 0.095 ms
 Execution Time: 3897.663 ms
(15 rows)

Time: 3898.239 ms (00:03.898)
postgres=

我们可以看到实际上PG13版本也差不多需要4s左右。

而且细心一点的朋友还可以发现,其中的sort method部分,MogDB似乎看起来比pg13还要好一些。

后面我发现去年研发团队有同事分享过MogDB排序方面的知识,看pdf材料内容,其实应该是借鉴了PostgreSQL15的相关算法。

alt

好了,言归正传!

基于如上三点!所以你们还会觉得MogDB比PG差几代么?

本文由 mdnice 多平台发布

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1887432.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

Python基础003

Python流程控制基础 1.条件语句 内置函数input a input("请输入一段内容:") print(a) print(type(a))代码执行的时候遇到input函数,就会等键盘输入结果,已回车为结束标志,也就时说输入回车后代码才会执行 2.顺序执行…

【问题记录】如何在xftp上查看隐藏文件。

显示隐藏的文件夹 用xftp连接到服务器后,发现有些隐藏的文件夹并未显示出来,通过以下配置,即可使隐藏的文件夹给显示出来。 1.点击菜单栏的"小齿轮"按钮: 2.勾选显示隐藏的文件夹: 3.点击确定即可。

古韵流光:探秘五代耀州窑青瓷提梁倒灌壶的奇妙设计

在陕西历史博物馆的静谧展厅中,一件千年前的瓷器静静陈列,它不仅承载着历史的沉淀,更凝聚了古代匠人的非凡智慧。这便是五代时期的耀州窑青瓷提梁倒灌壶,一件巧夺天工的艺术品,其独特的设计至今仍让人叹为观止。 一、倒…

算法mq 交互通用校验模块设计

背景 当前与算法交互均通过rocketMQ异步交互,绝大部分场景一条请求mq消息应对应一条返回mq,但由于各种原因(消息积压、程序bug),可能会导致返回mq超时未返回或者消息丢失。工程侧针对一些重要场景 case by case的通过…

【web3】分享一个web入门学习平台-HackQuest

前言 一直想进入web3行业,但是没有什么途径,偶然在电鸭平台看到HackQuest的共学营,发现真的不错,并且还接触到了黑客松这种形式。 链接地址:HackQuest 平台功能 学习路径:平台有完整的学习路径&#xff…

VS2022+Qt+OpenCV Debug模式下,循环中格式转换引起的内存异常问题 debug_heap.cpp

文章目录 前言一、问题二、报错1.提示图片2.提示堆栈3.反汇编位置 三、解决办法总结 前言 最近在使用VS2022,C,OpenCV,Qt开发时,遇到了一个疑难杂症-在循环中执行字符串格式转换会触发内存异常,经过痛苦的排查过程&am…

Ubuntu下反弹shell的思考

目录 Ubuntu的命令执行环境 bash (Bourne Again SHell): sh (Bourne SHell): dash (Debian Almquist SHell): 它们之间的关系: 可能遇到的问题 一、脚本权限问题 二、命令执行环境(shell解释器)问题 如何解决? 1.修改/bin/sh软连接的指向为bas…

C++字体库开发

建议根据字体需求,多个组合使用。高度定制可基于freeTypeharfbuzz基础库完成。 GitHub - GNOME/pango: Read-only mirror of https://gitlab.gnome.org/GNOME/pango GitHub - googlefonts/fontview: Demo app that displays fonts with a free/libre/open-source …

Java_多线程:线程和死锁

一、线程 1、线程的状态流转 新建状态(New):当线程对象对创建后,即进入了新建状态,如:Thread t new MyThread();就绪状态(Runnable):当调用线程对象的start()方法&…

JAVA极简图书管理系统,初识springboot后端项目

前提条件: 具备基础的springboot 知识 Java基础 废话不多说! 创建项目 配置所需环境 将application.properties>application.yml 配置以下环境 数据库连接MySQL 自己创建的数据库名称为book_test server:port: 8080 spring:datasource:url:…

搜索型数据库的技术发展历程与趋势前瞻

概述 随着数字科技的飞速发展和信息量的爆炸性增长,搜索引擎已成为我们获取信息的首选途径之一,典型的代表厂商如 Google。然而,随着用户需求的不断演变,传统的搜索技术已经无法满足人们对信息的实时性、个性化和多样性的需求。 …

C++基础知识-编译相关

记录C语言相关的基础知识 1 C源码到可执行文件的四个阶段 预处理(.i)、编译(.s)、汇编(.obj)、链接。 1.1 预处理 预处理阶段,主要完成宏替换、文件展开、注释删除、条件编译展开、添加行号和文件名标识,输出.i/.ii预处理文件。 宏替换,…

AI的价值——不再那么“废”人,保险行业用AI人员流失减少20%

最近有个热点挺让人唏嘘的,某咖啡店员工对顾客泼咖啡粉,我们对于这个事件不予评价。但是对员工这种情绪崩溃,我们所接触的行业中也有不少例子,比如保险行业,相信大家经常会被打保险电话,这类电话很容易就被…

K8s 的最后一片拼图:dbPaaS

K8s 的发展使得私有云跟公共云之间的技术差不断的缩小,不管是在私有云还是公共云,大家今天都在基于 K8s 去开发 PaaS 系统。而 K8s 作为构建 PaaS 的基础,其全景图里还缺最后一块“拼图”——dbPaaS。作为一个云数据库行业干了十几年的资深从…

Swin Transformer:最佳论文,准确率和性能双佳的视觉Transformer | ICCV 2021

论文提出了经典的Vision Transormer模型Swin Transformer,能够构建层级特征提高任务准确率,而且其计算复杂度经过各种加速设计,能够与输入图片大小成线性关系。从实验结果来看,Swin Transormer在各视觉任务上都有很不错的准确率&a…

哈尔滨如何选择合适的等保测评机构?

选择合适的等保测评机构确实需要细致考虑,您提到的八个方面已经非常全面,涵盖了资质、专业能力、服务质量和合规性等多个关键点。为了进一步确保所选机构的可靠性,还可以考虑以下几点: 1.技术创新与工具:了解测评机构是…

UE5的安装与基本操作(一)

文章目录 前言安装UE5新建第一个游戏项目基本游览方式对目标进行变换各种变换对齐 快速定位目标 总结 前言 Unreal Engine 5 (UE5) 是一款由 Epic Games 开发的实时 3D 创作平台,用于制作游戏、电影、动画、建筑可视化和其他类型的交互式体验。UE5 提供了一系列强大…

解锁IDEA中Git/SVN Issue Navigation功能:80%程序员都不懂的秘密武器~

文章目录 前言什么是 Git Issue Navigation?配置 Git Issue Navigation1. 打开设置2. 导航到 Issue Navigation 设置3. 添加新的 Issue Navigation 规则具体示例配置 使用 Git Issue Navigation在提交信息中使用 Issue ID实际导航到连接 优点1. 快速定位问题2. 提高…

可重入锁思想,设计MQ迁移方案

如果你的MQ消息要从Kafka切换到RocketMQ且不停机,怎么做?在让这个MQ消息调用第三方发奖接口,但无幂等字段又怎么处理?今天小傅哥就给大家分享一个关于MQ消息在这样的场景中的处理手段。 这是一种比较特例的场景,需要保…

6月28日华为云数据库斯享会上海站,NineData技术总监薛晓乐受邀并带来主题分享

6月28日(周五),华为云数据库斯享会即将在上海举办,将与的开发者朋友们一起进行数据库技术交流!NineData 技术总监薛晓乐受邀参会,并将带来《企业级数据库 DevOps 最佳实践》的主题分享。 本次活动议程&…