备案控制台
探索云世界
开发者社区 数据库 关系型数据库 文章 正文

PostgreSQL 9.5 新特性之 - 水平分片架构与实践

2016-02-23 14356
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云原生数据库 PolarDB MySQL 版，Serverless 5000PCU 100GB
推荐场景：
PolarDB for MySQL 多主集群体验
云原生数据库 PolarDB 分布式版，标准版 2核8GB
推荐场景：
使用PolarDB-X与Flink搭建实时数据大屏
云数据库 RDS MySQL Serverless，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
简介： PostgreSQL 9.5 在foreign data wrapper这方面有了几块非常好的功能增强：1. 支持创建外部表约束2. 优化器支持外部表查询下推3. 外部表支持继承4. 支持import foreign schema一键创建外部表使用前3点增强的技术点可以支持数据库的水平分片，可以把.

PostgreSQL 9.5 在foreign data wrapper这方面有了几块非常好的功能增强：

  1. 支持创建外部表约束
  2. 优化器支持外部表查询下推
  3. 外部表支持继承
  4. 支持import foreign schema一键创建外部表
    使用前3点增强的技术点可以支持数据库的水平分片，可以把PostgreSQL 9.5作为master，在其他版本作为数据节点。从而实现水平分库的目的。

这种分片技术相比中间件分片技术的好处：

  1. 支持跨库JOIN
  2. 支持绑定变量
  3. 支持ACID
  4. 支持分布式事务（不需要用户干预2PC）
  5. 支持master节点水平扩展
  6. 支持segment节点水平扩展
  7. 支持函数和存储过程

架构如图：
架构1：
维度表存储在上游节点，好处是JOIN时效率更高，缺点是当上层节点需要部署多个时，需要在上层节点之间同步维度表（可以使用前端同步或后端同步的方法），同时如果维度数据量大或者DML频繁的话master库会比较重。
前端同步可以使用外部表的方式，使用触发器实现。insert,update,delete通过父表触发在所有子表执行。SELECT时查询本地表不走触发器。
后端同步可以使用LOGICAL DECODE。
_
架构2：
维度表存储在分片节点，可以选择任一分片节点存储任一维度表。
缺点是JOIN时数据需要传到上层节点，效率低。
还有一个缺点是数据节点可能不平衡。
当维度表使用多副本时，不存在不平横的问题。这种情况下查询指定任意节点，增删改则指定所有节点。
_1
HA架构：
_2

上层节点使用9.5以上的版本，用于存放维度表（全局表），以及数据分片的定义，数据路由算法。
数据分片的定义包括继承关系，分布列约束，外部表定义，插入触发器。
下层节点使用的数据库版本没有要求，用于存放数据分片。

下面是一组测试，创建5个数据库，1个master库用于存放全局数据和数据分片的定义，数据路由算法；4个下层节点数据库，用于存放数据分片；

master=# create database db0;  
master=# create database db1;  
master=# create database db2;  
master=# create database db3;  
master=# create database master;

连接到master库，创建外部server：

d3=# \c master  
master=# create extension postgres_fdw;  
master=# create server db0 foreign data wrapper postgres_fdw options (hostaddr '127.0.0.1', port '1923', dbname 'db0');  
master=# create server db1 foreign data wrapper postgres_fdw options (hostaddr '127.0.0.1', port '1923', dbname 'db1');  
master=# create server db2 foreign data wrapper postgres_fdw options (hostaddr '127.0.0.1', port '1923', dbname 'db2');  
master=# create server db3 foreign data wrapper postgres_fdw options (hostaddr '127.0.0.1', port '1923', dbname 'db3');

创建user mapping：

master=# create user mapping for postgres server db0 options (user 'postgres', password 'postgres');  
master=# create user mapping for postgres server db1 options (user 'postgres', password 'postgres');  
master=# create user mapping for postgres server db2 options (user 'postgres', password 'postgres');  
master=# create user mapping for postgres server db3 options (user 'postgres', password 'postgres');

连接到分片节点，创建分片表（表名请随意）：

master=# \c db0  
db0=# create table tbl0(id int primary key, info text, crt_time timestamp);  
alter table tbl0 add constraint ck1 check (abs(mod(id,4))=0);  
master=# \c db1  
db1=# create table tbl1(id int primary key, info text, crt_time timestamp);  
alter table tbl1 add constraint ck1 check (abs(mod(id,4))=1);  
master=# \c db2  
db2=# create table tbl2(id int primary key, info text, crt_time timestamp);  
alter table tbl2 add constraint ck1 check (abs(mod(id,4))=2);  
master=# \c db3  
db3=# create table tbl3(id int primary key, info text, crt_time timestamp);  
alter table tbl3 add constraint ck1 check (abs(mod(id,4))=3);

连接到主节点，创建外部表，这里使用了import foreign schema语法，一键创建：

db3=# \c master  
You are now connected to database "master" as user "postgres".  
master=# import FOREIGN SCHEMA public from server db0 into public;   
IMPORT FOREIGN SCHEMA  
master=# import FOREIGN SCHEMA public from server db1 into public;   
IMPORT FOREIGN SCHEMA  
master=# import FOREIGN SCHEMA public from server db2 into public;   
IMPORT FOREIGN SCHEMA  
master=# import FOREIGN SCHEMA public from server db3 into public;   
IMPORT FOREIGN SCHEMA  
master=# \det  
 List of foreign tables  
 Schema | Table | Server   
--------+-------+--------  
 public | tbl0  | db0  
 public | tbl1  | db1  
 public | tbl2  | db2  
 public | tbl3  | db3  
(4 rows)

创建主表，用户操作主表即可。（当然用户也可以直接操作子表，PostgreSQL不拦你）

master=# create table tbl(id int, info text, crt_time timestamp);  
CREATE TABLE

设置外部表继承关系，继承到主表下面。

master=# alter foreign table tbl0 inherit tbl;  
ALTER FOREIGN TABLE  
master=# alter foreign table tbl1 inherit tbl;  
ALTER FOREIGN TABLE  
master=# alter foreign table tbl2 inherit tbl;  
ALTER FOREIGN TABLE  
master=# alter foreign table tbl3 inherit tbl;  
ALTER FOREIGN TABLE

创建外部表的约束，约束即路由算法的一部分。
注意，带约束条件的SQL，数据库会自动选择对应的外部表进行操作。
不带约束条件的SQL，数据库会选择所有节点操作。
所以建议每条SQL都带上约束条件。

master=# alter foreign table tbl0 add constraint ck_tbl0 check (abs(mod(id,4))=0);  
ALTER FOREIGN TABLE  
master=# alter foreign table tbl1 add constraint ck_tbl1 check (abs(mod(id,4))=1);  
ALTER FOREIGN TABLE  
master=# alter foreign table tbl2 add constraint ck_tbl2 check (abs(mod(id,4))=2);  
ALTER FOREIGN TABLE  
master=# alter foreign table tbl3 add constraint ck_tbl3 check (abs(mod(id,4))=3);  
ALTER FOREIGN TABLE

带约束条件abs(mod(id, 4)) = (abs(mod(100, 4)))的SQL，选择了对应的外部表进行操作。

master=# explain select * from tbl where id=100 and abs(mod(id, 4)) = (abs(mod(100, 4)));  
                            QUERY PLAN                               
-------------------------------------------------------------------  
 Append  (cost=0.00..134.10 rows=2 width=44)  
   ->  Seq Scan on tbl  (cost=0.00..0.00 rows=1 width=44)  
         Filter: ((id = 100) AND (abs(mod(id, 4)) = 0))  
   ->  Foreign Scan on tbl0  (cost=100.00..134.10 rows=1 width=44)  
(4 rows)  
  
master=# explain select * from tbl where id=101 and abs(mod(id, 4)) = (abs(mod(101, 4)));  
                            QUERY PLAN                               
-------------------------------------------------------------------  
 Append  (cost=0.00..134.10 rows=2 width=44)  
   ->  Seq Scan on tbl  (cost=0.00..0.00 rows=1 width=44)  
         Filter: ((id = 101) AND (abs(mod(id, 4)) = 1))  
   ->  Foreign Scan on tbl1  (cost=100.00..134.10 rows=1 width=44)  
(4 rows)

不带约束条件abs(mod(id, 4)) = (abs(mod(100, 4)))的SQL，选择了所有外部表进行操作。

master=# explain select * from tbl where id=100;  
                            QUERY PLAN                               
-------------------------------------------------------------------  
 Append  (cost=0.00..500.68 rows=25 width=44)  
   ->  Seq Scan on tbl  (cost=0.00..0.00 rows=1 width=44)  
         Filter: (id = 100)  
   ->  Foreign Scan on tbl0  (cost=100.00..125.17 rows=6 width=44)  
   ->  Foreign Scan on tbl1  (cost=100.00..125.17 rows=6 width=44)  
   ->  Foreign Scan on tbl2  (cost=100.00..125.17 rows=6 width=44)  
   ->  Foreign Scan on tbl3  (cost=100.00..125.17 rows=6 width=44)  
(7 rows)  
  
master=# explain select count(*),sum(id),avg(id+id) from tbl;  
                                QUERY PLAN                                   
---------------------------------------------------------------------------  
 Aggregate  (cost=908.01..908.02 rows=1 width=4)  
   ->  Append  (cost=0.00..791.00 rows=11701 width=4)  
         ->  Seq Scan on tbl  (cost=0.00..0.00 rows=1 width=4)  
         ->  Foreign Scan on tbl0  (cost=100.00..197.75 rows=2925 width=4)  
         ->  Foreign Scan on tbl1  (cost=100.00..197.75 rows=2925 width=4)  
         ->  Foreign Scan on tbl2  (cost=100.00..197.75 rows=2925 width=4)  
         ->  Foreign Scan on tbl3  (cost=100.00..197.75 rows=2925 width=4)  
(7 rows)

创建插入路由触发器函数：

master=# create or replace function f_tbl_ins() returns trigger as 
$$
  
declare  
begin  
  case abs(mod(NEW.id, 4))   
    when 0 then  
      insert into tbl0 (id, info, crt_time) values (NEW.*);  
    when 1 then  
      insert into tbl1 (id, info, crt_time) values (NEW.*);  
    when 2 then  
      insert into tbl2 (id, info, crt_time) values (NEW.*);  
    when 3 then  
      insert into tbl3 (id, info, crt_time) values (NEW.*);  
    else  
      return null;  
  end case;  
    return null;  
end;  

$$
 language plpgsql;

创建插入触发器：

master=# create trigger tg1 before insert on tbl for each row execute procedure f_tbl_ins();  
CREATE TRIGGER

测试插入路由是否正确：

master=# insert into tbl values (1,'abc',now());  
INSERT 0 0  
master=# select * from tbl;  
 id | info |          crt_time            
----+------+----------------------------  
  1 | abc  | 2016-02-23 09:17:43.054333  
(1 row)  
  
master=# insert into tbl values (2,'abc',now());  
INSERT 0 0  
master=# select * from tbl;  
 id | info |          crt_time            
----+------+----------------------------  
  1 | abc  | 2016-02-23 09:17:43.054333  
  2 | abc  | 2016-02-23 09:17:55.065332  
(2 rows)  
  
master=# select * from tbl where id=2;  
 id | info |          crt_time            
----+------+----------------------------  
  2 | abc  | 2016-02-23 09:17:55.065332  
(1 row)  
  
master=# select * from tbl where id=2 and abs(mod(id, 4))=abs(mod(2, 4));  
 id | info |          crt_time            
----+------+----------------------------  
  2 | abc  | 2016-02-23 09:17:55.065332  
(1 row)

带约束条件abs(mod(id, 4)) = (abs(mod(100, 4)))的SQL，选择了对应的外部表进行操作。

master=# explain select * from tbl where id=2 and abs(mod(id, 4))=abs(mod(2, 4));  
                            QUERY PLAN                               
-------------------------------------------------------------------  
 Append  (cost=0.00..134.10 rows=2 width=44)  
   ->  Seq Scan on tbl  (cost=0.00..0.00 rows=1 width=44)  
         Filter: ((id = 2) AND (abs(mod(id, 4)) = 2))  
   ->  Foreign Scan on tbl2  (cost=100.00..134.10 rows=1 width=44)  
(4 rows)

空值操作，在触发器中已经绕过：

master=# insert into tbl values (null,'abc',now());  
INSERT 0 0  
master=# select * from tbl;  
 id | info |          crt_time            
----+------+----------------------------  
  1 | abc  | 2016-02-23 09:17:43.054333  
  2 | abc  | 2016-02-23 09:17:55.065332  
(2 rows)

支持分布式事务，看执行计划，远程用了for update，然后在上层先提交远程节点，再提交本地节点：

master=# explain (verbose) update tbl set info='new' where id=2 and abs(mod(id, 4))=abs(mod(2, 4));  
                                                       QUERY PLAN                                                         
------------------------------------------------------------------------------------------------------------------------  
 Update on public.tbl  (cost=0.00..149.02 rows=2 width=18)  
   Update on public.tbl  
   Foreign Update on public.tbl2  
     Remote SQL: UPDATE public.tbl2 SET info = $2 WHERE ctid = $1  
   ->  Seq Scan on public.tbl  (cost=0.00..0.00 rows=1 width=18)  
         Output: tbl.id, 'new'::text, tbl.crt_time, tbl.ctid  
         Filter: ((tbl.id = 2) AND (abs(mod(tbl.id, 4)) = 2))  
   ->  Foreign Scan on public.tbl2  (cost=100.00..149.02 rows=1 width=18)  
         Output: tbl2.id, 'new'::text, tbl2.crt_time, tbl2.ctid  
         Remote SQL: SELECT id, crt_time, ctid FROM public.tbl2 WHERE ((id = 2)) AND ((abs(mod(id, 4)) = 2)) FOR UPDATE  
(10 rows)  
  
master=# explain (verbose) delete from tbl where id=2 and abs(mod(id, 4))=abs(mod(2, 4));  
                                                QUERY PLAN                                                  
----------------------------------------------------------------------------------------------------------  
 Delete on public.tbl  (cost=0.00..164.62 rows=2 width=6)  
   Delete on public.tbl  
   Foreign Delete on public.tbl2  
     Remote SQL: DELETE FROM public.tbl2 WHERE ctid = $1  
   ->  Seq Scan on public.tbl  (cost=0.00..0.00 rows=1 width=6)  
         Output: tbl.ctid  
         Filter: ((tbl.id = 2) AND (abs(mod(tbl.id, 4)) = 2))  
   ->  Foreign Scan on public.tbl2  (cost=100.00..164.62 rows=1 width=6)  
         Output: tbl2.ctid  
         Remote SQL: SELECT ctid FROM public.tbl2 WHERE ((id = 2)) AND ((abs(mod(id, 4)) = 2)) FOR UPDATE  
(10 rows)

可以回退外部表SQL：

master=# begin ;  
BEGIN  
master=# insert into tbl0 values (0,'abc',now());  
INSERT 0 1  
master=# rollback;  
ROLLBACK  
master=# select * from tbl;  
 id | info |          crt_time            
----+------+----------------------------  
  1 | abc  | 2016-02-23 09:17:43.054333  
  2 | abc  | 2016-02-23 09:17:55.065332  
(2 rows)

有跨库事务时，支持全局一致性：

master=# begin;  
BEGIN  
master=# insert into tbl values(3,'new',now());  
INSERT 0 0  
master=# insert into tbl values(1,'new',now());  
ERROR:  duplicate key value violates unique constraint "pk"  
DETAIL:  Key (id)=(1) already exists.  
CONTEXT:  Remote SQL command: INSERT INTO public.tbl1(id, info, crt_time) VALUES ($1, $2, $3)  
SQL statement "insert into tbl1 (id, info, crt_time) values (NEW.*)"  
PL/pgSQL function f_tbl_ins() line 8 at SQL statement  
master=# end;  
ROLLBACK  
master=# select * from tbl;  
 id | info |          crt_time            
----+------+----------------------------  
  1 | abc  | 2016-02-23 09:17:43.054333  
  2 | abc  | 2016-02-23 09:17:55.065332  
(2 rows)

有跨库事务和本地事务时，支持全局一致性：

master=# create table test(id int primary key, info text);  
CREATE TABLE  
master=# begin;  
BEGIN  
master=# insert into test values (1,'abc');  
INSERT 0 1  
master=# insert into tbl values(3,'new',now());  
INSERT 0 0  
master=# insert into test values (1,'abc');  
ERROR:  duplicate key value violates unique constraint "test_pkey"  
DETAIL:  Key (id)=(1) already exists.  
master=# end;  
ROLLBACK  
master=# select * from tbl;  
 id | info |          crt_time            
----+------+----------------------------  
  1 | abc  | 2016-02-23 09:17:43.054333  
  2 | abc  | 2016-02-23 09:17:55.065332  
(2 rows)  
  
master=# select * from test;  
 id | info   
----+------  
(0 rows)

支持绑定变量：

master=# prepare p1 (int,text,timestamp) as insert into tbl values ($1,$2,$3);  
PREPARE  
master=# prepare p2 (int,int) as select * from tbl where id=$1 and abs(mod($1,4))=$2;  
PREPARE  
master=# prepare p3 (int,int,text,timestamp) as update tbl set info=$3,crt_time=$4 where id=$1 and abs(mod($1,4))=$2;  
PREPARE  
master=# execute p1(1,'abc',now());  
ERROR:  duplicate key value violates unique constraint "pk"  
DETAIL:  Key (id)=(1) already exists.  
CONTEXT:  Remote SQL command: INSERT INTO public.tbl1(id, info, crt_time) VALUES ($1, $2, $3)  
SQL statement "insert into tbl1 (id, info, crt_time) values (NEW.*)"  
PL/pgSQL function f_tbl_ins() line 8 at SQL statement  
master=# execute p1(3,'abc',now());  
INSERT 0 0  
master=# select * from tbl;  
 id | info |          crt_time            
----+------+----------------------------  
  1 | abc  | 2016-02-23 09:17:43.054333  
  2 | abc  | 2016-02-23 09:17:55.065332  
  3 | abc  | 2016-02-23 09:56:00.835324  
(3 rows)  
  
master=# execute p1(4,'abc',now());  
INSERT 0 0  
master=# execute p1(5,'abc',now());  
INSERT 0 0  
master=# execute p1(6,'abc',now());  
INSERT 0 0  
master=# execute p1(7,'abc',now());  
INSERT 0 0  
master=# execute p1(8,'abc',now());  
INSERT 0 0  
master=# execute p1(9,'abc',now());  
INSERT 0 0  
master=# select * from tbl;  
 id | info |          crt_time            
----+------+----------------------------  
  4 | abc  | 2016-02-23 09:56:20.159337  
  8 | abc  | 2016-02-23 09:56:31.034317  
  1 | abc  | 2016-02-23 09:17:43.054333  
  5 | abc  | 2016-02-23 09:56:24.392312  
  9 | abc  | 2016-02-23 09:56:33.303365  
  2 | abc  | 2016-02-23 09:17:55.065332  
  6 | abc  | 2016-02-23 09:56:26.560318  
  3 | abc  | 2016-02-23 09:56:00.835324  
  7 | abc  | 2016-02-23 09:56:28.740312  
(9 rows)  
  
master=# execute p2(1,1);  
 id | info |          crt_time            
----+------+----------------------------  
  1 | abc  | 2016-02-23 09:17:43.054333  
(1 row)  
  
master=# execute p2(10,2);  
 id | info | crt_time   
----+------+----------  
(0 rows)  
  
master=# execute p2(1,2);  
 id | info | crt_time   
----+------+----------  
(0 rows)  
  
master=# execute p2(2,2);  
 id | info |          crt_time            
----+------+----------------------------  
  2 | abc  | 2016-02-23 09:17:55.065332  
(1 row)  
  
master=# execute p3(1,1,'test',now());  
UPDATE 1  
master=# select * from tbl;  
 id | info |          crt_time            
----+------+----------------------------  
  4 | abc  | 2016-02-23 09:56:20.159337  
  8 | abc  | 2016-02-23 09:56:31.034317  
  5 | abc  | 2016-02-23 09:56:24.392312  
  9 | abc  | 2016-02-23 09:56:33.303365  
  1 | test | 2016-02-23 09:57:12.126359  
  2 | abc  | 2016-02-23 09:17:55.065332  
  6 | abc  | 2016-02-23 09:56:26.560318  
  3 | abc  | 2016-02-23 09:56:00.835324  
  7 | abc  | 2016-02-23 09:56:28.740312  
(9 rows)

使用xmin, xmax验证外部表因为事务中其他SQL或其他节点执行失败导致的事务回滚的情况，确保全局事务一致：

db0=# select tableoid,ctid,xmin,xmax,* from tbl0;  
 tableoid |  ctid  |   xmin   | xmax | id | info |          crt_time            
----------+--------+----------+------+----+------+----------------------------  
    20280 | (0,11) | 38232587 |    0 |  4 | test | 2016-02-23 11:25:20.440349  
    20280 | (0,12) | 38232587 |    0 |  8 | test | 2016-02-23 11:25:20.440349  
(2 rows)

注意master节点查看到的外部表的xmin, xmax是不准确的，已经提交了这个BUG给社区。

db0=# \c master  
You are now connected to database "master" as user "postgres".  
master=# select tableoid,ctid,xmin,xmax,* from tbl0;  
 tableoid |  ctid  | xmin |    xmax    | id | info |          crt_time            
----------+--------+------+------------+----+------+----------------------------  
    20304 | (0,11) |  192 | 4294967295 |  4 | test | 2016-02-23 11:25:20.440349  
    20304 | (0,12) |  192 | 4294967295 |  8 | test | 2016-02-23 11:25:20.440349  
(2 rows)

使用以下SQL，在一条SQL中跨库更新多条记录，其中一条涉及到ID从7变成6，会违反数据库分片的表约束，导致SQL失败，看看这种情况下是否能保证全局事务一致性。

master=# update tbl set id=(case id when 4 then 4 when 3 then 3 when 7 then 6 else id end) ;  
ERROR:  new row for relation "tbl3" violates check constraint "ck1"  
DETAIL:  Failing row contains (6, test, 2016-02-23 11:25:20.440349).  
CONTEXT:  Remote SQL command: UPDATE public.tbl3 SET id = $2 WHERE ctid = $1  
master=# select tableoid,ctid,xmin,xmax,* from tbl4;  
ERROR:  relation "tbl4" does not exist  
LINE 1: select tableoid,ctid,xmin,xmax,* from tbl4;  
                                              ^

查看XID：

master=# select tableoid,ctid,xmin,xmax,* from tbl0;  
 tableoid |  ctid  | xmin |    xmax    | id | info |          crt_time            
----------+--------+------+------------+----+------+----------------------------  
    20304 | (0,11) |  192 | 4294967295 |  4 | test | 2016-02-23 11:25:20.440349  
    20304 | (0,12) |  192 | 4294967295 |  8 | test | 2016-02-23 11:25:20.440349  
(2 rows)

可以看到xmax值已经变更了，说明发生了回退，从而确保了全局事务的一致性。

master=# \c db0  
You are now connected to database "db0" as user "postgres".  
db0=# select tableoid,ctid,xmin,xmax,* from tbl0;  
 tableoid |  ctid  |   xmin   |   xmax   | id | info |          crt_time            
----------+--------+----------+----------+----+------+----------------------------  
    20280 | (0,11) | 38232587 | 38232588 |  4 | test | 2016-02-23 11:25:20.440349  
    20280 | (0,12) | 38232587 | 38232588 |  8 | test | 2016-02-23 11:25:20.440349  
(2 rows)

外部表和外部表的跨库JOIN

master=# explain select * from tbl, t where t.id=tbl.id and tbl.id=1 and abs(mod(tbl.id,4))=1;  
                                  QUERY PLAN                                     
-------------------------------------------------------------------------------  
 Nested Loop  (cost=0.00..635.41 rows=50 width=88)  
   ->  Append  (cost=0.00..500.68 rows=25 width=44)  
         ->  Seq Scan on t  (cost=0.00..0.00 rows=1 width=44)  
               Filter: (id = 1)  
         ->  Foreign Scan on db0_t  (cost=100.00..125.17 rows=6 width=44)  
         ->  Foreign Scan on db1_t  (cost=100.00..125.17 rows=6 width=44)  
         ->  Foreign Scan on db2_t  (cost=100.00..125.17 rows=6 width=44)  
         ->  Foreign Scan on db3_t  (cost=100.00..125.17 rows=6 width=44)  
   ->  Materialize  (cost=0.00..134.11 rows=2 width=44)  
         ->  Append  (cost=0.00..134.10 rows=2 width=44)  
               ->  Seq Scan on tbl  (cost=0.00..0.00 rows=1 width=44)  
                     Filter: ((id = 1) AND (abs(mod(id, 4)) = 1))  
               ->  Foreign Scan on tbl1  (cost=100.00..134.10 rows=1 width=44)  
(13 rows)

外部表，全局表的JOIN

master=# explain select * from tbl, t, test where t.id=tbl.id and test.id=t.id and tbl.id=1 and abs(mod(tbl.id,4))=1;  
                                       QUERY PLAN                                          
-----------------------------------------------------------------------------------------  
 Nested Loop  (cost=0.15..643.60 rows=50 width=124)  
   ->  Append  (cost=0.00..500.68 rows=25 width=44)  
         ->  Seq Scan on t  (cost=0.00..0.00 rows=1 width=44)  
               Filter: (id = 1)  
         ->  Foreign Scan on db0_t  (cost=100.00..125.17 rows=6 width=44)  
         ->  Foreign Scan on db1_t  (cost=100.00..125.17 rows=6 width=44)  
         ->  Foreign Scan on db2_t  (cost=100.00..125.17 rows=6 width=44)  
         ->  Foreign Scan on db3_t  (cost=100.00..125.17 rows=6 width=44)  
   ->  Materialize  (cost=0.15..142.30 rows=2 width=80)  
         ->  Nested Loop  (cost=0.15..142.29 rows=2 width=80)  
               ->  Index Scan using test_pkey on test  (cost=0.15..8.17 rows=1 width=36)  
                     Index Cond: (id = 1)  
               ->  Append  (cost=0.00..134.10 rows=2 width=44)  
                     ->  Seq Scan on tbl  (cost=0.00..0.00 rows=1 width=44)  
                           Filter: ((id = 1) AND (abs(mod(id, 4)) = 1))  
                     ->  Foreign Scan on tbl1  (cost=100.00..134.10 rows=1 width=44)  
(16 rows)

扩展能力和性能：
master和数据分片都可以水平扩展。
性能可以随着节点数的增加线性提升。
更适合OLTP。OLAP目前还是MPP做得比较好。
如果要下推JOIN，目前的方法是使用数据节点视图，将JOIN封装在视图中，在上层节点建立视图的外部表，通过访问这类外部表来实现JOIN的下推。未来PG会提供JOIN下推的功能，不需要这么麻烦。

其他
truncate 目前不支持外部表
JOIN目前不能下推到数据节点执行
条件可以下推到数据节点

不要走开，马上下一篇会介绍利用PostgreSQL特性实现 Oracle 水平分库的方案和技术实现。
没错，是 Oracle 水平分库，而且不限 Oracle 的版本。
文章来咯：
https://yq.aliyun.com/articles/6637

文章标签：
云原生数据库 PolarDB
关系型数据库
SQL
PostgreSQL
数据库
存储
关键词：
架构实践
云原生数据库 PolarDB架构
云原生数据库 PolarDB实践
架构postgresql
云数据库 RDS PostgreSQL 版新特性
相关实践学习
使用PolarDB和ECS搭建门户网站
本场景主要介绍基于PolarDB和ECS实现搭建门户网站。
阿里云数据库产品家族及特性
阿里云智能数据库产品团队一直致力于不断健全产品体系，提升产品性能，打磨产品功能，从而帮助客户实现更加极致的弹性能力、具备更强的扩展能力、并利用云设施进一步降低企业成本。以云原生+分布式为核心技术抓手，打造以自研的在线事务型(OLTP)数据库Polar DB和在线分析型(OLAP)数据库Analytic DB为代表的新一代企业级云原生数据库产品体系， 结合NoSQL数据库、数据库生态工具、云原生智能化数据库管控平台，为阿里巴巴经济体以及各个行业的企业客户和开发者提供从公共云到混合云再到私有云的完整解决方案，提供基于云基础设施进行数据从处理、到存储、再到计算与分析的一体化解决方案。本节课带你了解阿里云数据库产品家族及特性。
德哥,digoal
目录
相关文章
游客nmbcre4jd7shs
|
1月前
|
负载均衡 测试技术 持续交付
高效后端开发实践：构建可扩展的微服务架构
在当今快速发展的互联网时代，后端开发扮演着至关重要的角色。本文将重点探讨如何构建可扩展的微服务架构，以及在后端开发中提高效率的一些实践方法。通过合理的架构设计和技术选型，我们可以更好地应对日益复杂的业务需求，实现高效可靠的后端系统。
游客nmbcre4jd7shs
129 3
兮叶William
|
7天前
|
存储 关系型数据库 分布式数据库
电子好书发您分享《PolarDB分布式版架构介绍PolarDB分布式版架构介绍》
**《PolarDB分布式版架构介绍》电子书分享：** 探索阿里云PolarDB分布式设计，采用计算存储分离，借助GMS、CN组件实现大规模扩展。[阅读更多](https://developer.aliyun.com/ebook/8332/116553?spm=a2c6h.26392459.ebook-detail.5.3b3b2ccbVVjjt0)
兮叶William
14 3
请看我回答~
|
3天前
|
消息中间件 持续交付 数据库
构建高效可靠的微服务架构：策略与实践
【4月更文挑战第25天】 随着现代软件开发的复杂性日益增加，传统的单体应用已难以满足快速迭代和灵活部署的需求。本文深入探讨了如何构建一个高效且可靠的微服务架构，包括关键的设计原则、技术选型以及实践中的挑战和应对策略。通过分析多个成功案例，我们总结了一系列最佳实践，并提出了一套可量化的性能优化方法。文章不仅为开发者提供了具体的技术指导，同时也强调了团队协作和持续学习在微服务转型过程中的重要性。
请看我回答~
10 1
游客uul6wusao3sds
|
19天前
|
Kubernetes 安全 Java
构建高效微服务架构：从理论到实践
【4月更文挑战第9天】 在当今快速迭代与竞争激烈的软件市场中，微服务架构以其灵活性、可扩展性及容错性，成为众多企业转型的首选。本文将深入探讨如何从零开始构建一个高效的微服务系统，覆盖从概念理解、设计原则、技术选型到部署维护的各个阶段。通过实际案例分析与最佳实践分享，旨在为后端工程师提供一套全面的微服务构建指南，帮助读者在面对复杂系统设计时能够做出明智的决策，并提升系统的可靠性与维护效率。
游客uul6wusao3sds
246 13
天下无贼001
|
1月前
|
消息中间件 敏捷开发 运维
构建高效可靠的微服务架构：策略与实践
随着现代软件开发的复杂性增加，微服务架构逐渐成为企业解决大型应用系统分解、敏捷开发和持续部署问题的有效手段。本文深入探讨了构建一个高效且可靠的微服务架构的关键策略，包括服务的合理划分、通信机制的选择、数据一致性保障以及容错处理。通过分析这些策略在具体案例中的应用，我们旨在为开发者提供一套可行的微服务设计及实施指南。
天下无贼001
138 6
请看我回答~
|
1月前
|
Cloud Native 安全 持续交付
构建未来：云原生架构的演进与实践
【2月更文挑战第30天】 随着数字化转型的深入，企业对于信息技术的需求日益复杂化和动态化。传统的IT架构已难以满足快速迭代、灵活扩展及成本效率的双重要求。云原生技术作为解决这一矛盾的关键途径，通过容器化、微服务、持续集成/持续部署（CI/CD）等手段，实现了应用的快速开发、部署及运维。本文将探讨云原生架构的最新发展，分析其如何助力企业构建更加灵活、高效的业务系统，并结合实际案例，展示云原生转型过程中的最佳实践和面临的挑战。
请看我回答~
106 0
兮叶William
|
5天前
|
关系型数据库 分布式数据库 数据库
电子好书发您分享《PolarDB分布式版架构介绍》
阅读阿里云电子书《PolarDB分布式版架构介绍》，深入理解这款高性能数据库的分布式架构设计。书中通过图文并茂的方式揭示了PolarDB在分布式场景下的核心特性和技术优势，适合数据库爱好者和云计算从业者学习。[阅读链接](https://developer.aliyun.com/ebook/8332/116553?spm=a2c6h.26392459.ebook-detail.5.4ab72ccbIzDq2Q)
兮叶William
8 1
兮叶William
|
6天前
|
存储 SQL 关系型数据库
电子好书发您分享《PolarDB分布式版架构介绍》
**PolarDB分布式版详解：** 阿里云的PolarDB采用计算存储分离架构，利用GMS进行元数据管理，CN处理分布式SQL。结合PolarFS，实现高效存储与计算，支持大规模扩展。[阅读完整架构介绍](https://developer.aliyun.com/ebook/8332/116553?spm=a2c6h.26392459.ebook-detail.5.5b912ccbE20nqg)
兮叶William
8 2
叫个什么名字
|
11天前
|
消息中间件 运维 监控
现代化软件开发中的微服务架构设计与实践
本文将深入探讨现代化软件开发中微服务架构的设计原则和实践经验。通过分析微服务架构的优势、挑战以及常见的设计模式，结合实际案例，帮助开发者更好地理解如何构建可靠、可扩展、高效的微服务系统。
叫个什么名字
15 4
桃李春风一杯酒
|
11天前
|
负载均衡 Java 开发者
细解微服务架构实践：如何使用Spring Cloud进行Java微服务治理
【4月更文挑战第17天】Spring Cloud是Java微服务治理的首选框架，整合了Eureka（服务发现）、Ribbon（客户端负载均衡）、Hystrix（熔断器）、Zuul（API网关）和Config Server（配置中心）。通过Eureka实现服务注册与发现，Ribbon提供负载均衡，Hystrix实现熔断保护，Zuul作为API网关，Config Server集中管理配置。理解并运用Spring Cloud进行微服务治理是现代Java开发者的关键技能。
桃李春风一杯酒
26 3
数据库

关系型数据库

热门文章

最新文章

  • 1
    PolarDB闪电助攻，《香肠派对》百亿好友关系实现毫秒级查询
  • 2
    为PostgreSQL讨说法 - 浅析《UBER ENGINEERING SWITCHED FROM POSTGRES TO MYSQL》
  • 3
    德哥的PostgreSQL私房菜 - 史上最屌PG资料合集
  • 4
    什么场景应该用 MongoDB ？
  • 5
    PostgreSQL 如何实现批量更新、删除、插入
  • 6
    PostgreSQL upsert功能(insert on conflict do)的用法
  • 7
    Linux 性能诊断 perf使用指南
  • 8
    PostgreSQL 9种索引的原理和应用场景
  • 9
    PostgreSQL 如何潇洒的处理每天上百TB的数据增量
  • 10
    Jedis常见异常汇总
  • 1
    数据存储成本飙升？莫慌！RDS数据归档功能来了
    16
  • 2
    下次老板问你MySQL如何优化时，你可以这样说，老板默默给你加工资
    23
  • 3
    MySQL慢日志的介绍以及如何使用问题
    10
  • 4
    MySQL的事务（看看也许有帮助呢）
    18
  • 5
    MySQL学习手册（第一部分）
    62
  • 6
    MySQL字段的时间类型该如何选择？千万数据下性能提升10%~30%🚀
    31
  • 7
    【设计模式系列笔记】建造者模式
    102
  • 8
    【设计模式系列笔记】工厂模式
    109
  • 9
    【设计模式系列笔记】抽象工厂模式
    106
  • 10
    【设计模式系列笔记】单例模式
    118

    • 相关产品

  • 云原生数据库 PolarDB
    文档详情 产品详情

    • 相关课程

    更多
  • PolarDB for PostgreSQL 入门
  • PostgreSQL云上开发实践
  • MySQL企业常见架构与调优经验分享
  • 企业Web常用架构LAMP-LNMP实战
  • 企业级互联网分布式系统应用架构学习
  • 高校精品课-上海交通大学 -企业级应用体系架构

    • 相关电子书

    更多
  • 微服务×容器Meetup：云原生架构与应用专场PPT合辑
  • 云原生架构容器&微服务优秀案例集
  • 以银行架构视角解读和落实银行数字化转型的两份重磅指导文件

    • 相关实验场景

    更多
  • 每个IT人都想学的“Web应用上云经典架构”实战
  • PolarDB NL2SQL：自然语言驱动的数据智能
  • 阿里云百炼xAnalyticDB PostgreSQL构建AIGC应用
  • 云原生数据库PolarDB快速入门
  • MySQL引擎及架构优化
  • PolarDB for AI：在数据库中通过SQL实现AI能力

    • 推荐镜像

    更多
  • postgresql
  • oceanbase
  • mysql
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）