AntDB 重分布性能测试记录二

最新推荐文章于 2023-10-29 10:23:43 发布
最新推荐文章于 2023-10-29 10:23:43 发布
阅读量519 收藏
点赞数
分类专栏： AntDB 文章标签： AntDB PostgreSQL PGXC Reduce
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/constzl/article/details/79230176
版权

AntDB 重分布性能测试记录二

接上篇《AntDB重分布（rebalance）性能对比记录一》，AntDB在重分布方面有优化的空间，本文通过记录一组数据，验证优化方案的可能性。

优化方案描述

重分布对各个数据节点（datanode）来说，主要包含两个操作：

  1. 删除不属于自己的数据，这部分数据其他节点需要。
  2. 插入属于自己的数据，这部分数据可能在其他节点上。

由通过插入一张新表来模拟重分布带来的启发，AntDB是否可以通过以下方法实现重分布。每个节点扫描所有记录，通过重分布表达式计算，属于本节点的数据保留，不属于本节点的数据，通过Reduce转发到其他节点上，并插入由其他节点Reduce的数据，最终完成数据重分布。
Reduce模拟重分布

优化方案验证

验证环境准备
--10万
create table t_one_million_new2(id int8, value int8) distribute by hash(id) to node(dn1, dn2, dn3);
--100万
create table t_ten_million_new2(id int8, value int8) distribute by hash(id) to node(dn1, dn2, dn3);
--1000万
create table t_hundred_million_new2(id int8, value int8) distribute by hash(id) to node(dn1, dn2, dn3);
--1亿
create table t_thousand_million_new2(id int8, value int8) distribute by hash(id) to node(dn1, dn2, dn3);
验证10万条数据
方法
explain (verbose, analyze, plan_id)
with tmp as (
delete from t_one_million
      where ('[0:2]={16388,16386,16387}' ::oid[])[COALESCE(int4abs((hashint8(id) % 3)), 0)] != adb_node_oid()
  returning *)
insert into t_one_million_new2
     select *
       from tmp;

select node_name, count(1)
  from (select xc_node_id,*
          from t_one_million
        union all
        select xc_node_id,*
          from t_one_million_new2) a,
       pgxc_node b
 where a.xc_node_id = b.node_id
 group by 1
 order by 1;
结果
postgres=# explain (verbose, analyze, plan_id)
postgres-# with tmp as (
postgres(# delete from t_one_million
postgres(#       where ('[0:2]={16388,16386,16387}' ::oid[])[COALESCE(int4abs((hashint8(id) % 3)), 0)] != adb_node_oid()
postgres(#   returning *)
postgres-# insert into t_one_million_new2
postgres-#      select *
postgres-#        from tmp;
                                                                   QUERY PLAN                                                                   
------------------------------------------------------------------------------------------------------------------------------------------------
 Cluster Gather  (cost=2699.12..3269.39 rows=1841 width=16) (actual time=206.958..206.958 rows=0 loops=1)
   Plan id: 0
   Remote node: 16385,16386,16387,16388
   ->  Insert on public.t_one_million_new2  (cost=1.00..18.97 rows=614 width=16) (actual time=0.130..0.130 rows=0 loops=1)
         Plan id: 1
         Node 16385: (actual time=162.042..162.042 rows=0 loops=1)
         Node 16388: (actual time=188.439..188.439 rows=0 loops=1)
         Node 16387: (actual time=196.024..196.024 rows=0 loops=1)
         Node 16386: (actual time=205.083..205.083 rows=0 loops=1)
         CTE tmp
           ->  Delete on public.t_one_million  (cost=0.00..12.91 rows=460 width=18) (actual time=0.046..0.047 rows=0 loops=1)
                 Plan id: 4
                 Output: t_one_million.id, t_one_million.value
                 Node 16385: (actual time=0.190..102.856 rows=25282 loops=1)
                 Node 16388: (actual time=7.967..82.578 rows=16701 loops=1)
                 Node 16387: (actual time=8.182..81.934 rows=16699 loops=1)
                 Node 16386: (actual time=7.412..80.025 rows=16587 loops=1)
                 ->  Seq Scan on public.t_one_million  (cost=0.00..12.91 rows=460 width=18) (actual time=0.039..0.039 rows=0 loops=1)
                       Plan id: 5
                       Output: t_one_million.id, t_one_million.ctid, t_one_million.xc_node_id
                       Filter: (('[0:2]={16388,16386,16387}'::oid[])[COALESCE(int4abs((hashint8(t_one_million.id) % 3)), 0)] <> adb_node_oid())
                       Remote node: 16388,16386,16387,16385
                       Node 16385: (actual time=0.108..26.268 rows=25282 loops=1)
                       Node 16388: (actual time=7.866..26.071 rows=16701 loops=1)
                       Node 16387: (actual time=8.109..26.764 rows=16699 loops=1)
                       Node 16386: (actual time=7.309..25.298 rows=16587 loops=1)
         ->  Cluster Reduce  (cost=1.00..18.97 rows=614 width=16) (actual time=0.128..0.128 rows=0 loops=1)
               Plan id: 2
               Reduce: ('[0:2]={16388,16386,16387}'::oid[])[COALESCE(int4abs((hashint8(tmp.id) % 3)), 0)]
               Node 16385: (actual time=162.039..162.039 rows=0 loops=1)
               Node 16388: (actual time=128.717..139.005 rows=25038 loops=1)
               Node 16387: (actual time=125.046..146.805 rows=25174 loops=1)
               Node 16386: (actual time=122.414..155.618 rows=25057 loops=1)
               ->  CTE Scan on tmp  (cost=0.00..12.91 rows=460 width=16) (actual time=0.050..0.050 rows=0 loops=1)
                     Plan id: 3
                     Output: tmp.id, tmp.value
                     Node 16385: (actual time=0.198..113.614 rows=25282 loops=1)
                     Node 16388: (actual time=7.976..89.735 rows=16701 loops=1)
                     Node 16387: (actual time=8.188..89.122 rows=16699 loops=1)
                     Node 16386: (actual time=7.418..87.059 rows=16587 loops=1)
 Planning time: 1.283 ms
 Execution time: 459.616 ms
(42 rows)

Time: 888.970 ms
postgres=# select node_name, count(1)
postgres-#   from (select xc_node_id,*
postgres(#           from t_one_million
postgres(#         union all
postgres(#         select xc_node_id,*
postgres(#           from t_one_million_new2) a,
postgres-#        pgxc_node b
postgres-#  where a.xc_node_id = b.node_id
postgres-#  group by 1
postgres-#  order by 1;
 node_name | count 
-----------+-------
 dn1       | 33343
 dn2       | 33209
 dn3       | 33448
(3 rows)

Time: 268.398 ms
postgres=# select node_name, count(1) from t_one_million_new a, pgxc_node b where a.xc_node_id = b.node_id group by 1 order by 1;
 node_name | count 
-----------+-------
 dn1       | 33343
 dn2       | 33209
 dn3       | 33448
(3 rows)

Time: 212.445 ms
验证100万条数据
方法
explain (verbose, analyze, plan_id)
with tmp as (
delete from t_ten_million
      where ('[0:2]={16388,16386,16387}' ::oid[])[COALESCE(int4abs((hashint8(id) % 3)), 0)] != adb_node_oid()
  returning *)
insert into t_ten_million_new2
     select *
       from tmp;

select node_name, count(1)
  from (select xc_node_id,*
          from t_ten_million
        union all
        select xc_node_id,*
          from t_ten_million_new2) a,
       pgxc_node b
 where a.xc_node_id = b.node_id
 group by 1
 order by 1;
结果
postgres=# explain (verbose, analyze, plan_id)
postgres-# with tmp as (
postgres(# delete from t_ten_million
postgres(#       where ('[0:2]={16388,16386,16387}' ::oid[])[COALESCE(int4abs((hashint8(id) % 3)), 0)] != adb_node_oid()
postgres(#   returning *)
postgres-# insert into t_ten_million_new2
postgres-#      select *
postgres-#        from tmp;
                                                                   QUERY PLAN                                                                   
------------------------------------------------------------------------------------------------------------------------------------------------
 Cluster Gather  (cost=2699.12..3269.39 rows=1841 width=16) (actual time=2580.157..2580.157 rows=0 loops=1)
   Plan id: 0
   Remote node: 16385,16386,16387,16388
   ->  Insert on public.t_ten_million_new2  (cost=1.00..18.97 rows=614 width=16) (actual time=0.127..0.127 rows=0 loops=1)
         Plan id: 1
         Node 16385: (actual time=2060.965..2060.965 rows=0 loops=1)
         Node 16386: (actual time=2111.376..2111.376 rows=0 loops=1)
         Node 16387: (actual time=2436.112..2436.112 rows=0 loops=1)
         Node 16388: (actual time=2574.979..2574.979 rows=0 loops=1)
         CTE tmp
           ->  Delete on public.t_ten_million  (cost=0.00..12.91 rows=460 width=18) (actual time=0.044..0.045 rows=0 loops=1)
                 Plan id: 4
                 Output: t_ten_million.id, t_ten_million.value
                 Node 16385: (actual time=0.187..1179.583 rows=250385 loops=1)
                 Node 16386: (actual time=63.668..831.904 rows=165932 loops=1)
                 Node 16387: (actual time=63.455..934.034 rows=167032 loops=1)
                 Node 16388: (actual time=64.036..929.712 rows=166591 loops=1)
                 ->  Seq Scan on public.t_ten_million  (cost=0.00..12.91 rows=460 width=18) (actual time=0.040..0.040 rows=0 loops=1)
                       Plan id: 5
                       Output: t_ten_million.id, t_ten_million.ctid, t_ten_million.xc_node_id
                       Filter: (('[0:2]={16388,16386,16387}'::oid[])[COALESCE(int4abs((hashint8(t_ten_million.id) % 3)), 0)] <> adb_node_oid())
                       Remote node: 16388,16386,16387,16385
                       Node 16385: (actual time=0.112..225.628 rows=250385 loops=1)
                       Node 16386: (actual time=63.608..218.627 rows=165932 loops=1)
                       Node 16387: (actual time=63.408..234.907 rows=167032 loops=1)
                       Node 16388: (actual time=63.983..234.140 rows=166591 loops=1)
         ->  Cluster Reduce  (cost=1.00..18.97 rows=614 width=16) (actual time=0.125..0.125 rows=0 loops=1)
               Plan id: 2
               Reduce: ('[0:2]={16388,16386,16387}'::oid[])[COALESCE(int4abs((hashint8(tmp.id) % 3)), 0)]
               Node 16385: (actual time=2060.963..2060.963 rows=0 loops=1)
               Node 16386: (actual time=1268.951..1416.964 rows=249790 loops=1)
               Node 16387: (actual time=1484.659..1581.653 rows=249980 loops=1)
               Node 16388: (actual time=1477.651..1593.620 rows=250170 loops=1)
               ->  CTE Scan on tmp  (cost=0.00..12.91 rows=460 width=16) (actual time=0.047..0.047 rows=0 loops=1)
                     Plan id: 3
                     Output: tmp.id, tmp.value
                     Node 16385: (actual time=0.191..1307.779 rows=250385 loops=1)
                     Node 16386: (actual time=63.671..920.255 rows=165932 loops=1)
                     Node 16387: (actual time=63.460..1022.836 rows=167032 loops=1)
                     Node 16388: (actual time=64.041..1022.762 rows=166591 loops=1)
 Planning time: 1.197 ms
 Execution time: 2611.913 ms
(42 rows)

Time: 2840.856 ms
postgres=# select node_name, count(1)
postgres-#   from (select xc_node_id,*
postgres(#           from t_ten_million
postgres(#         union all
postgres(#         select xc_node_id,*
postgres(#           from t_ten_million_new2) a,
postgres-#        pgxc_node b
postgres-#  where a.xc_node_id = b.node_id
postgres-#  group by 1
postgres-#  order by 1;
 node_name | count  
-----------+--------
 dn1       | 333622
 dn2       | 332909
 dn3       | 333469
(3 rows)

Time: 1290.778 ms
postgres=# select node_name, count(1) from t_ten_million_new a, pgxc_node b where a.xc_node_id = b.node_id group by 1 order by 1;
 node_name | count  
-----------+--------
 dn1       | 333622
 dn2       | 332909
 dn3       | 333469
(3 rows)

Time: 1127.809 ms
验证1000万条数据
方法
explain (verbose, analyze, plan_id)
with tmp as (
delete from t_hundred_million
      where ('[0:2]={16388,16386,16387}' ::oid[])[COALESCE(int4abs((hashint8(id) % 3)), 0)] != adb_node_oid()
  returning *)
insert into t_hundred_million_new2
     select *
       from tmp;

select node_name, count(1)
  from (select xc_node_id,*
          from t_hundred_million
        union all
        select xc_node_id,*
          from t_hundred_million_new2) a,
       pgxc_node b
 where a.xc_node_id = b.node_id
 group by 1
 order by 1;
结果
postgres=# explain (verbose, analyze, plan_id)
postgres-# with tmp as (
postgres(# delete from t_hundred_million
postgres(#       where ('[0:2]={16388,16386,16387}' ::oid[])[COALESCE(int4abs((hashint8(id) % 3)), 0)] != adb_node_oid()
postgres(#   returning *)
postgres-# insert into t_hundred_million_new2
postgres-#      select *
postgres-#        from tmp;
                                                                     QUERY PLAN                                                                     
----------------------------------------------------------------------------------------------------------------------------------------------------
 Cluster Gather  (cost=2699.12..3269.39 rows=1841 width=16) (actual time=23802.106..23802.106 rows=0 loops=1)
   Plan id: 0
   Remote node: 16385,16386,16387,16388
   ->  Insert on public.t_hundred_million_new2  (cost=1.00..18.97 rows=614 width=16) (actual time=0.131..0.131 rows=0 loops=1)
         Plan id: 1
         Node 16385: (actual time=20565.963..20565.963 rows=0 loops=1)
         Node 16387: (actual time=22259.154..22259.154 rows=0 loops=1)
         Node 16388: (actual time=22810.022..22810.022 rows=0 loops=1)
         Node 16386: (actual time=23784.276..23784.276 rows=0 loops=1)
         CTE tmp
           ->  Delete on public.t_hundred_million  (cost=0.00..12.91 rows=460 width=18) (actual time=0.044..0.045 rows=0 loops=1)
                 Plan id: 4
                 Output: t_hundred_million.id, t_hundred_million.value
                 Node 16385: (actual time=0.214..11428.316 rows=2497291 loops=1)
                 Node 16387: (actual time=486.838..8149.738 rows=1667058 loops=1)
                 Node 16388: (actual time=473.074..8031.809 rows=1667088 loops=1)
                 Node 16386: (actual time=476.968..9090.809 rows=1666677 loops=1)
                 ->  Seq Scan on public.t_hundred_million  (cost=0.00..12.91 rows=460 width=18) (actual time=0.040..0.040 rows=0 loops=1)
                       Plan id: 5
                       Output: t_hundred_million.id, t_hundred_million.ctid, t_hundred_million.xc_node_id
                       Filter: (('[0:2]={16388,16386,16387}'::oid[])[COALESCE(int4abs((hashint8(t_hundred_million.id) % 3)), 0)] <> adb_node_oid())
                       Remote node: 16388,16386,16387,16385
                       Node 16385: (actual time=0.138..2133.664 rows=2497291 loops=1)
                       Node 16387: (actual time=486.791..1972.714 rows=1667058 loops=1)
                       Node 16388: (actual time=473.019..1693.478 rows=1667088 loops=1)
                       Node 16386: (actual time=476.906..1952.976 rows=1666677 loops=1)
         ->  Cluster Reduce  (cost=1.00..18.97 rows=614 width=16) (actual time=0.129..0.129 rows=0 loops=1)
               Plan id: 2
               Reduce: ('[0:2]={16388,16386,16387}'::oid[])[COALESCE(int4abs((hashint8(tmp.id) % 3)), 0)]
               Node 16385: (actual time=20565.962..20565.962 rows=0 loops=1)
               Node 16387: (actual time=13131.765..14239.031 rows=2498596 loops=1)
               Node 16388: (actual time=13783.951..14884.326 rows=2502704 loops=1)
               Node 16386: (actual time=14427.555..15564.555 rows=2496814 loops=1)
               ->  CTE Scan on tmp  (cost=0.00..12.91 rows=460 width=16) (actual time=0.048..0.048 rows=0 loops=1)
                     Plan id: 3
                     Output: tmp.id, tmp.value
                     Node 16385: (actual time=0.219..12673.297 rows=2497291 loops=1)
                     Node 16387: (actual time=486.841..8941.105 rows=1667058 loops=1)
                     Node 16388: (actual time=473.080..8689.941 rows=1667088 loops=1)
                     Node 16386: (actual time=476.972..9927.592 rows=1666677 loops=1)
 Planning time: 1.261 ms
 Execution time: 23878.725 ms
(42 rows)

Time: 24123.468 ms
postgres=# select node_name, count(1)
postgres-#   from (select xc_node_id,*
postgres(#           from t_hundred_million
postgres(#         union all
postgres(#         select xc_node_id,*
postgres(#           from t_hundred_million_new2) a,
postgres-#        pgxc_node b
postgres-#  where a.xc_node_id = b.node_id
postgres-#  group by 1
postgres-#  order by 1;
 node_name |  count  
-----------+---------
 dn1       | 3337145
 dn2       | 3330709
 dn3       | 3332146
(3 rows)

Time: 10990.656 ms
postgres=# select node_name, count(1) from t_hundred_million_new a, pgxc_node b where a.xc_node_id = b.node_id group by 1 order by 1;
 node_name |  count  
-----------+---------
 dn1       | 3337145
 dn2       | 3330709
 dn3       | 3332146
(3 rows)

Time: 9582.919 ms
验证1亿条数据
方法
explain (verbose, analyze, plan_id)
with tmp as (
delete from t_thousand_million
      where ('[0:2]={16388,16386,16387}' ::oid[])[COALESCE(int4abs((hashint8(id) % 3)), 0)] != adb_node_oid()
  returning *)
insert into t_thousand_million_new2
     select *
       from tmp;

select node_name, count(1)
  from (select xc_node_id,*
          from t_thousand_million
        union all
        select xc_node_id,*
          from t_thousand_million_new2) a,
       pgxc_node b
 where a.xc_node_id = b.node_id
 group by 1
 order by 1;
结果
postgres=# explain (verbose, analyze, plan_id)
postgres-# with tmp as (
postgres(# delete from t_thousand_million
postgres(#       where ('[0:2]={16388,16386,16387}' ::oid[])[COALESCE(int4abs((hashint8(id) % 3)), 0)] != adb_node_oid()
postgres(#   returning *)
postgres-# insert into t_thousand_million_new2
postgres-#      select *
postgres-#        from tmp;
                                                                     QUERY PLAN                                                                      
-----------------------------------------------------------------------------------------------------------------------------------------------------
 Cluster Gather  (cost=2699.12..3269.39 rows=1841 width=16) (actual time=303480.427..303480.427 rows=0 loops=1)
   Plan id: 0
   Remote node: 16385,16386,16387,16388
   ->  Insert on public.t_thousand_million_new2  (cost=1.00..18.97 rows=614 width=16) (actual time=0.122..0.122 rows=0 loops=1)
         Plan id: 1
         Node 16385: (actual time=233747.394..233747.394 rows=0 loops=1)
         Node 16387: (actual time=250731.393..250731.393 rows=0 loops=1)
         Node 16386: (actual time=296341.588..296341.588 rows=0 loops=1)
         Node 16388: (actual time=303356.287..303356.287 rows=0 loops=1)
         CTE tmp
           ->  Delete on public.t_thousand_million  (cost=0.00..12.91 rows=460 width=18) (actual time=0.041..0.042 rows=0 loops=1)
                 Plan id: 4
                 Output: t_thousand_million.id, t_thousand_million.value
                 Node 16385: (actual time=0.207..129183.374 rows=24997800 loops=1)
                 Node 16387: (actual time=4318.516..90104.208 rows=16672669 loops=1)
                 Node 16386: (actual time=3918.944..100601.275 rows=16666117 loops=1)
                 Node 16388: (actual time=3858.099..100402.508 rows=16667591 loops=1)
                 ->  Seq Scan on public.t_thousand_million  (cost=0.00..12.91 rows=460 width=18) (actual time=0.038..0.038 rows=0 loops=1)
                       Plan id: 5
                       Output: t_thousand_million.id, t_thousand_million.ctid, t_thousand_million.xc_node_id
                       Filter: (('[0:2]={16388,16386,16387}'::oid[])[COALESCE(int4abs((hashint8(t_thousand_million.id) % 3)), 0)] <> adb_node_oid())
                       Remote node: 16388,16386,16387,16385
                       Node 16385: (actual time=0.138..23994.713 rows=24997800 loops=1)
                       Node 16387: (actual time=4318.478..21444.014 rows=16672669 loops=1)
                       Node 16386: (actual time=3918.890..19805.282 rows=16666117 loops=1)
                       Node 16388: (actual time=3858.047..19951.104 rows=16667591 loops=1)
         ->  Cluster Reduce  (cost=1.00..18.97 rows=614 width=16) (actual time=0.120..0.120 rows=0 loops=1)
               Plan id: 2
               Reduce: ('[0:2]={16388,16386,16387}'::oid[])[COALESCE(int4abs((hashint8(tmp.id) % 3)), 0)]
               Node 16385: (actual time=233747.393..233747.393 rows=0 loops=1)
               Node 16387: (actual time=150785.753..161866.379 rows=25000997 loops=1)
               Node 16386: (actual time=166170.688..178206.491 rows=24998324 loops=1)
               Node 16388: (actual time=173194.376..184757.500 rows=25004856 loops=1)
               ->  CTE Scan on tmp  (cost=0.00..12.91 rows=460 width=16) (actual time=0.045..0.045 rows=0 loops=1)
                     Plan id: 3
                     Output: tmp.id, tmp.value
                     Node 16385: (actual time=0.211..143127.262 rows=24997800 loops=1)
                     Node 16387: (actual time=4318.521..99346.392 rows=16672669 loops=1)
                     Node 16386: (actual time=3918.948..116278.998 rows=16666117 loops=1)
                     Node 16388: (actual time=3858.103..115040.120 rows=16667591 loops=1)
 Planning time: 1.233 ms
 Execution time: 303513.533 ms
(42 rows)

Time: 303742.111 ms
postgres=# select node_name, count(1)
postgres-#   from (select xc_node_id,*
postgres(#           from t_thousand_million
postgres(#         union all
postgres(#         select xc_node_id,*
postgres(#           from t_thousand_million_new2) a,
postgres-#        pgxc_node b
postgres-#  where a.xc_node_id = b.node_id
postgres-#  group by 1
postgres-#  order by 1;
 node_name |  count   
-----------+----------
 dn1       | 33340379
 dn2       | 33327029
 dn3       | 33332592
(3 rows)

Time: 127507.301 ms
postgres=# select node_name, count(1) from t_thousand_million_new a, pgxc_node b where a.xc_node_id = b.node_id group by 1 order by 1;
 node_name |  count   
-----------+----------
 dn1       | 33340379
 dn2       | 33327029
 dn3       | 33332592
(3 rows)

Time: 104912.304 ms

优化方案结论

通过对比结果可以发现，本方案结果正确。同等条件下，本方案效率要比插入一张新表低，但比原PGXC的重分布方案高很多，可以尝试本方案。

数据重分布（ms）插入新表（ms）插入&删除（ms）
10万1241.957266.723459.616
100万7308.2351355.5312611.913
1000万67223.16317984.77223878.725
1亿682586.634197551.749303513.533

三种方法对比图

constzl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AntDB 性能测试篇（一）：Jmeter工具
BillyZhu的博客
02-07 1186
AntDB现已开源： 开源url：https://github.com/ADBSQL/AntDB QQ交流群：496464280 背景： AntDB 是一款源自于 PG 内核的通用分布式事务性关系数据库。目前需要验证数据库的读写能力。第一个想到的是pgbench，postgresql提供的一个压测工具，不过内部使用的是libpq通讯协议，与生产使用的jdbc扩展协议有点差别；第二个想到的L
AntDB OLAP测试之--TPC-DS基准测试
BillyZhu的博客
03-04 1588
AntDB OLAP测试之–TPC-DS基准测试 一、下载安装TPC-DS工具 下载TPC-DS源码： http://www.tpc.org/tpc_documents_current_versions/current_specifications.asp 选择合适的版本，本次选择：tpc-ds-tool-v2.1.0.zip 编译安装： make前需要检测依赖：gcc gcc-c++ libs...
AntDB 重分布性能测试记录一
chushan6669的博客
01-31 174
AntDB重分布（rebalance）性能对比记录一 AntDB集群环境 postgres=# table pgxc_node; node_name | node_type | node_port | node_host | nodeis_primary | nodeis_prefer...
AntDB重分布（rebalance）性能对比记录一
constzl的博客
01-31 487
AntDB重分布（rebalance）性能对比记录一 AntDB集群环境 postgres=# table pgxc_node; node_name | node_type | node_port | node_host | nodeis_primary | nodeis_preferred | node_id -----------+-----------+----
AntDB重分布流程记录
constzl的博客
01-31 696
AntDB基于PGXC开发，保留了原PGXC的重分布逻辑，本文记录了常见的重分布流程。 集群环境 coordinator节点：cd1、cd2 datanode节点：dn1、dn2、dn3 案例1 概述 重分布前 重分布后 重分布CASE 重分布SQL 分片方式 分片函数 分片字段 分片节
AntDB_Oracle兼容性开发者手册v31
08-08
2. **SQL语法**：AntDB支持Oracle的SQL语法，使得开发者可以使用熟悉的查询语句进行数据操作。 3. **系统和内置函数**：AntDB包含与Oracle兼容的系统和内置函数，允许在SQL语句和程序逻辑中无缝使用。 4. **存储...
二次开发开源pgxl antdb数据库
06-06
【标题】"二次开发开源pgxl antdb数据库"揭示了我们今天要探讨的主题，即一个基于PostgreSQL的国产开源数据库——AntDB。AntDB在PostgreSQL的基础上进行了深度的二次开发，旨在提供更高效、可扩展的数据库解决方案，...
PostgresChina2018_党宏博_亚信AntDB在业务驱动下的创新-v0.2
01-25
PostgresChina2018_党宏博_亚信AntDB在业务驱动下的创新-v0.2，分布式架构
PostgreSQL AntDB数据库复制介绍.pptx
10-14
**PostgreSQL AntDB 数据库复制介绍** PostgreSQL 是一款开源的关系型数据库管理系统，以其高度的稳定性和灵活性而受到广泛认可。AntDB 是基于 PostgreSQL 的分布式数据库系统，它在原生 PostgreSQL 的基础上添加了...
antdb_uuid_swcs_分词器
03-14
"AntDB_uuid_swcs_分词器"是一个针对开源PostgreSQL（简称PG）集群的优化解决方案，旨在提供比常规集群高出十倍的性能，并且具备动态扩容能力以及简便的主备配置。AntDB是一个高性能、分布式的关系型数据库系统，它...
cpp-AntDB是一种分布式数据库提供可扩展性和大规模并行处理
08-16
AntDB是一种分布式数据库，提供可扩展性和大规模并行处理
antsdb：AntsDB是用于HBase的低延迟，高并发，MySQL兼容SQL层
02-03
antsdb：AntsDB是用于HBase的低延迟，高并发，MySQL兼容SQL层
AntDB-单机oracle兼容版本TPCC性能分析(一)
BillyZhu的博客
08-08 1069
背景 AntDB-单机oracle语法兼容版本，
AntDB日常调试GDB脚本
constzl的博客
01-30 390
AntDB日常调试GDB脚本 为了更方便的调试AntDB，生成gdb调试脚本。 gdb调试脚本gengdb.sh # !/bin/bash # Author Sunny # Version 2016-11-11 function Usage() { echo "\ Help Just keep enum NodeTag which read from
PostgreSQL/AntDB应用实践总结
小小默：进无止境
03-28 597
【1】根据B表更新A表的字段 背景 ： 根据B表中的字段更新A表的字段值。 实例如下 ： 根据copy2中的字段值更新test2表的值。 update tb_bound_users test2,tb_bound_users_copy2 set test2.number = tb_bound_users_copy2.number, test2.user_type=tb_bound_use...
分布式事务型关系数据库 AntDB介绍
qq_16817425的博客
01-26 1974
分布式事务型数据库AntDB 简介：AISWare AntDB采用share-nothing的MPP架构，支持分布式并行计算，可高效处理PB级别的结构化和半结构化数据，支撑亿级用户，具有横向可扩展，秒级在线扩容的能力，是一款高度兼容Oracle、PostgreSQL、MySQL等语法的多模型分布式关系型数据库产品。
AGTM对antdb性能测试场景（一）
BillyZhu的博客
06-29 836
测试主要分为两大类场景：一是，agtm+coord1+db1/coord+db1/单pg架构对比；二是，agtm+coord1+两个db/coord+两个db架构性能对比；                    细分为下面6组测试场景：...
AntDB是一种高性能的分布式数据库系统
最新发布
科猫网
10-29 428
除了高性能和强大的事务处理能力，AntDB还提供了丰富的功能和工具，以方便用户管理和操作数据库。同时，AntDB还支持在线扩容和缩容操作，可以动态调整集群规模，以适应不断增长的数据需求。AntDB还具备强大的事务处理能力。此外，AntDB还提供了分布式事务的支持，可以跨节点执行事务操作，确保数据的一致性和可靠性。总结起来，AntDB是一种基于PostgreSQL开发的分布式数据库系统，具备高性能、高可用性和强大的事务处理能力。它的分布式架构和丰富的功能使得它成为处理大规模数据集和高并发负载的理想选择。
分布式事务型关系数据库 AntDB
晨风
03-01 3611
转载来自：分布式事务型关系数据库 AntDB 分布式事务型数据库AntDB AntDB 是一款源自于 PG 内核的通用分布式事务性关系数据库，是一款面向金融、电信、政务、安全、能源等行业的国产、自主、安全可靠、高性能的企业级分布式事务型关系数据库产品。具备持续的集群自动高可用，秒级在线扩缩容，强大的 Oracle 兼容，异地容灾，SQL 语句级自定义分片，分布式事务和 MV...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值