2026年2月26日： PostgreSQL 18.3、17.9、16.13、15.17 和 14.22 发布！
受支持版本： 当前版本 (18) / 17 / 16 / 15
开发版本： devel
29.4. 行过滤器
Prev  Up Chapter 29. 逻辑复制 Home  Next

29.4. 行过滤器 #

29.4.1. 行过滤规则
29.4.2. 表达式限制
29.4.3. UPDATE 转换
29.4.4. 分区表
29.4.5. 初始数据同步
29.4.6. 组合多个行过滤器
29.4.7. 示例

默认情况下，所有已发布表中的全部数据都会复制到相应的订阅端。可以使用行过滤器来减少被复制的数据。 用户可能出于行为、安全或性能方面的原因选择使用行过滤器。如果某个已发布表设置了行过滤器，则只有当某一行的数据满足该行过滤器表达式时，该行才会被复制。 这样就可以只复制一组表中的部分数据。行过滤器按表定义。对于每个需要过滤数据的已发布表，在表名后使用WHERE子句。 WHERE子句必须用括号括起来。详见CREATE PUBLICATION。

29.4.1. 行过滤规则 #

行过滤器会在发布更改之前应用。如果行过滤器求值为false或NULL， 则该行不会被复制。WHERE子句表达式会使用复制连接所用的同一角色来求值（即在 CREATE SUBSCRIPTION的CONNECTION 子句中指定的角色）。行过滤器对TRUNCATE命令没有影响。

29.4.2. 表达式限制 #

WHERE子句只允许简单表达式。它不能包含用户定义的函数、操作符、类型和排序规则、系统列引用，或非不可变内置函数。

如果某个发布发布UPDATE或DELETE操作， 则行过滤器的WHERE子句只能包含被复制标识覆盖的列 （参见REPLICA IDENTITY）。如果某个发布只发布 INSERT操作，则行过滤器的WHERE子句可以使用任意列。

29.4.3. UPDATE 转换 #

每当处理UPDATE时，都会针对旧行和新行分别计算行过滤表达式（即分别使用更新前和更新后的数据）。 如果两次求值都为true，则复制该UPDATE更改。 如果两次求值都为false，则不复制该更改。 如果旧行和新行中只有一个满足行过滤表达式，则会把UPDATE转换为INSERT或DELETE， 以避免任何数据不一致。订阅端上的行应当反映发布端行过滤表达式所定义的结果。

如果旧行满足行过滤表达式（即它已发送到订阅端），而新行不满足，那么从数据一致性的角度看， 应当从订阅端移除旧行。因此UPDATE会被转换为DELETE。

如果旧行不满足行过滤表达式（即它未发送到订阅端），而新行满足，那么从数据一致性的角度看， 应当将新行加入订阅端。 因此，UPDATE会被转换为INSERT。

Table 29.1 总结了会应用哪些转换。

Table 29.1. UPDATE 转换摘要

旧行 新行 转换
不匹配 不匹配 不复制
不匹配 匹配 INSERT
匹配 不匹配 DELETE
匹配 匹配 UPDATE

29.4.4. 分区表 #

如果发布包含分区表，则发布参数publish_via_partition_root确定使用哪个行过滤器。 如果publish_via_partition_root为true，则使用根分区表的行过滤器。 否则，如果publish_via_partition_root为false（默认值），则使用各个分区的行过滤器。

29.4.5. 初始数据同步 #

如果订阅需要复制预先存在的表数据，且某个发布包含WHERE子句， 则只有满足行过滤表达式的数据才会被复制到订阅端。

如果某个订阅包含多个发布，而其中某张表带有不同的WHERE子句， 那么满足这些表达式中任意一个的行都会被复制。详见 Section 29.4.6。

Warning

由于初始数据同步在复制现有表数据时不会考虑publish参数， 因此有些使用 DML 时本不会复制的行，也可能在此阶段被复制。参见 Section 29.8.1，并查看 Section 29.2.2中的示例。

Note

如果订阅端使用的是 15 之前的版本，那么即使发布中定义了行过滤器，复制预先存在的数据时也不会使用这些行过滤器。 这是因为旧版本只能复制整张表的全部数据。

29.4.6. 组合多个行过滤器 #

如果某个订阅包含多个发布，而其中同一张表针对相同的publish操作使用了不同的行过滤器， 那么这些表达式会按 OR 组合，因此满足任意一个表达式的行都会被复制。这意味着，如果出现以下任一情况，那么同一张表上的其他所有行过滤器都会变得多余：

  • 其中某个发布没有行过滤器。

  • 其中某个发布是使用FOR ALL TABLES创建的。该子句不允许行过滤器。

  • 其中某个发布是使用FOR TABLES IN SCHEMA创建的，并且该表属于所引用的模式。该子句不允许行过滤器。

29.4.7. 示例 #

创建一些表，供下面的示例使用。

test_pub=# CREATE TABLE t1(a int, b int, c text, PRIMARY KEY(a,c));
CREATE TABLE
test_pub=# CREATE TABLE t2(d int, e int, f int, PRIMARY KEY(d));
CREATE TABLE
test_pub=# CREATE TABLE t3(g int, h int, i int, PRIMARY KEY(g));
CREATE TABLE

创建一些发布。发布p1包含一个表（t1），该表带有行过滤器。 发布p2包含两个表，其中t1没有行过滤器，而t2带有行过滤器。 发布p3包含两个表，并且这两个表都带有行过滤器。

test_pub=# CREATE PUBLICATION p1 FOR TABLE t1 WHERE (a > 5 AND c = 'NSW');
CREATE PUBLICATION
test_pub=# CREATE PUBLICATION p2 FOR TABLE t1, t2 WHERE (e = 99);
CREATE PUBLICATION
test_pub=# CREATE PUBLICATION p3 FOR TABLE t2 WHERE (d = 10), t3 WHERE (g = 10);
CREATE PUBLICATION

psql可用于显示每个发布的行过滤表达式（如果已定义）。

test_pub=# \dRp+
                               Publication p1
  Owner   | All tables | Inserts | Updates | Deletes | Truncates | Via root
----------+------------+---------+---------+---------+-----------+----------
 postgres | f          | t       | t       | t       | t         | f
Tables:
    "public.t1" WHERE ((a > 5) AND (c = 'NSW'::text))

                               Publication p2
  Owner   | All tables | Inserts | Updates | Deletes | Truncates | Via root
----------+------------+---------+---------+---------+-----------+----------
 postgres | f          | t       | t       | t       | t         | f
Tables:
    "public.t1"
    "public.t2" WHERE (e = 99)

                               Publication p3
  Owner   | All tables | Inserts | Updates | Deletes | Truncates | Via root
----------+------------+---------+---------+---------+-----------+----------
 postgres | f          | t       | t       | t       | t         | f
Tables:
    "public.t2" WHERE (d = 10)
    "public.t3" WHERE (g = 10)

psql可用于显示每个表的行过滤表达式（如果已定义）。可以看到，表t1属于两个发布，但只有在p1中带有行过滤器； 表t2也属于两个发布，并且在这两个发布中具有不同的行过滤器。

test_pub=# \d t1
                 Table "public.t1"
 Column |  Type   | Collation | Nullable | Default
--------+---------+-----------+----------+---------
 a      | integer |           | not null |
 b      | integer |           |          |
 c      | text    |           | not null |
Indexes:
    "t1_pkey" PRIMARY KEY, btree (a, c)
Publications:
    "p1" WHERE ((a > 5) AND (c = 'NSW'::text))
    "p2"

test_pub=# \d t2
                 Table "public.t2"
 Column |  Type   | Collation | Nullable | Default
--------+---------+-----------+----------+---------
 d      | integer |           | not null |
 e      | integer |           |          |
 f      | integer |           |          |
Indexes:
    "t2_pkey" PRIMARY KEY, btree (d)
Publications:
    "p2" WHERE (e = 99)
    "p3" WHERE (d = 10)

test_pub=# \d t3
                 Table "public.t3"
 Column |  Type   | Collation | Nullable | Default
--------+---------+-----------+----------+---------
 g      | integer |           | not null |
 h      | integer |           |          |
 i      | integer |           |          |
Indexes:
    "t3_pkey" PRIMARY KEY, btree (g)
Publications:
    "p3" WHERE (g = 10)

在订阅端节点上，创建一个与发布端定义相同的表t1， 然后创建订阅s1来订阅发布p1。

test_sub=# CREATE TABLE t1(a int, b int, c text, PRIMARY KEY(a,c));
CREATE TABLE
test_sub=# CREATE SUBSCRIPTION s1
test_sub-# CONNECTION 'host=localhost dbname=test_pub application_name=s1'
test_sub-# PUBLICATION p1;
CREATE SUBSCRIPTION

插入一些行。只有满足发布p1中t1 WHERE子句的那些行会被复制。

test_pub=# INSERT INTO t1 VALUES (2, 102, 'NSW');
INSERT 0 1
test_pub=# INSERT INTO t1 VALUES (3, 103, 'QLD');
INSERT 0 1
test_pub=# INSERT INTO t1 VALUES (4, 104, 'VIC');
INSERT 0 1
test_pub=# INSERT INTO t1 VALUES (5, 105, 'ACT');
INSERT 0 1
test_pub=# INSERT INTO t1 VALUES (6, 106, 'NSW');
INSERT 0 1
test_pub=# INSERT INTO t1 VALUES (7, 107, 'NT');
INSERT 0 1
test_pub=# INSERT INTO t1 VALUES (8, 108, 'QLD');
INSERT 0 1
test_pub=# INSERT INTO t1 VALUES (9, 109, 'NSW');
INSERT 0 1

test_pub=# SELECT * FROM t1;
 a |  b  |  c
---+-----+-----
 2 | 102 | NSW
 3 | 103 | QLD
 4 | 104 | VIC
 5 | 105 | ACT
 6 | 106 | NSW
 7 | 107 | NT
 8 | 108 | QLD
 9 | 109 | NSW
(8 rows)

test_sub=# SELECT * FROM t1;
 a |  b  |  c
---+-----+-----
 6 | 106 | NSW
 9 | 109 | NSW
(2 rows)

更新一些数据，此时旧行和新行的值都满足发布p1中t1 WHERE子句。该UPDATE会像平常一样复制该更改。

test_pub=# UPDATE t1 SET b = 999 WHERE a = 6;
UPDATE 1

test_pub=# SELECT * FROM t1;
 a |  b  |  c
---+-----+-----
 2 | 102 | NSW
 3 | 103 | QLD
 4 | 104 | VIC
 5 | 105 | ACT
 7 | 107 | NT
 8 | 108 | QLD
 9 | 109 | NSW
 6 | 999 | NSW
(8 rows)

test_sub=# SELECT * FROM t1;
 a |  b  |  c
---+-----+-----
 9 | 109 | NSW
 6 | 999 | NSW
(2 rows)

更新一些数据，此时旧行的值不满足发布p1中t1 WHERE子句，而新行的值满足该子句。 UPDATE会被转换为INSERT，并且该更改会被复制。可以在订阅端看到新行。

test_pub=# UPDATE t1 SET a = 555 WHERE a = 2;
UPDATE 1

test_pub=# SELECT * FROM t1;
  a  |  b  |  c
-----+-----+-----
   3 | 103 | QLD
   4 | 104 | VIC
   5 | 105 | ACT
   7 | 107 | NT
   8 | 108 | QLD
   9 | 109 | NSW
   6 | 999 | NSW
 555 | 102 | NSW
(8 rows)

test_sub=# SELECT * FROM t1;
  a  |  b  |  c
-----+-----+-----
   9 | 109 | NSW
   6 | 999 | NSW
 555 | 102 | NSW
(3 rows)

更新一些数据，此时旧行的值满足发布p1中t1 WHERE子句，而新行的值不再满足该子句。 UPDATE会被转换为DELETE，并且该更改会被复制。可以看到该行已从订阅端移除。

test_pub=# UPDATE t1 SET c = 'VIC' WHERE a = 9;
UPDATE 1

test_pub=# SELECT * FROM t1;
  a  |  b  |  c
-----+-----+-----
   3 | 103 | QLD
   4 | 104 | VIC
   5 | 105 | ACT
   7 | 107 | NT
   8 | 108 | QLD
   6 | 999 | NSW
 555 | 102 | NSW
   9 | 109 | VIC
(8 rows)

test_sub=# SELECT * FROM t1;
  a  |  b  |  c
-----+-----+-----
   6 | 999 | NSW
 555 | 102 | NSW
(2 rows)

下面的示例展示了发布参数publish_via_partition_root 在分区表场景下如何决定使用父表还是子表的行过滤器。

在发布端创建一个分区表。

test_pub=# CREATE TABLE parent(a int PRIMARY KEY) PARTITION BY RANGE(a);
CREATE TABLE
test_pub=# CREATE TABLE child PARTITION OF parent DEFAULT;
CREATE TABLE

在订阅端创建相同的表。

test_sub=# CREATE TABLE parent(a int PRIMARY KEY) PARTITION BY RANGE(a);
CREATE TABLE
test_sub=# CREATE TABLE child PARTITION OF parent DEFAULT;
CREATE TABLE

创建一个发布p4，然后订阅它。发布参数publish_via_partition_root设置为 true。 分区表（parent）和分区（child）上都定义了行过滤器。

test_pub=# CREATE PUBLICATION p4 FOR TABLE parent WHERE (a < 5), child WHERE (a >= 5)
test_pub-# WITH (publish_via_partition_root=true);
CREATE PUBLICATION

test_sub=# CREATE SUBSCRIPTION s4
test_sub-# CONNECTION 'host=localhost dbname=test_pub application_name=s4'
test_sub-# PUBLICATION p4;
CREATE SUBSCRIPTION

直接向parent和child表插入一些值。它们会使用parent的行过滤器进行复制（因为publish_via_partition_root为 true）。

test_pub=# INSERT INTO parent VALUES (2), (4), (6);
INSERT 0 3
test_pub=# INSERT INTO child VALUES (3), (5), (7);
INSERT 0 3

test_pub=# SELECT * FROM parent ORDER BY a;
 a
---
 2
 3
 4
 5
 6
 7
(6 rows)

test_sub=# SELECT * FROM parent ORDER BY a;
 a
---
 2
 3
 4
(3 rows)

重复相同的测试，但将publish_via_partition_root设为不同的值。 这里发布参数publish_via_partition_root设置为 false，并且在分区（child）上定义了行过滤器。

test_pub=# DROP PUBLICATION p4;
DROP PUBLICATION
test_pub=# CREATE PUBLICATION p4 FOR TABLE parent, child WHERE (a >= 5)
test_pub-# WITH (publish_via_partition_root=false);
CREATE PUBLICATION

test_sub=# ALTER SUBSCRIPTION s4 REFRESH PUBLICATION;
ALTER SUBSCRIPTION

像前面一样在发布端执行插入。它们会使用child的行过滤器进行复制（因为publish_via_partition_root为 false）。

test_pub=# TRUNCATE parent;
TRUNCATE TABLE
test_pub=# INSERT INTO parent VALUES (2), (4), (6);
INSERT 0 3
test_pub=# INSERT INTO child VALUES (3), (5), (7);
INSERT 0 3

test_pub=# SELECT * FROM parent ORDER BY a;
 a
---
 2
 3
 4
 5
 6
 7
(6 rows)

test_sub=# SELECT * FROM child ORDER BY a;
 a
---
 5
 6
 7
(3 rows)
Prev  Up  Next
29.3. 逻辑复制故障切换  Home  29.5. 列列表

提交更正

如果您发现文档中有不正确的内容、与您使用特定功能的经验不符或需要进一步说明，请使用此表单来报告文档问题。