PostgreSQL：文档：17：29.4. 行过滤器

支持版本：当前 (17) / 16 / 15

开发版本：devel

29.4. 行过滤器
上一个	上级	第 29 章. 逻辑复制	首页	下一个

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 子句表达式使用与复制连接相同的角色进行计算（即在 CONNECTION 子句中指定的CREATE SUBSCRIPTION 角色）。行过滤器对 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。

表 29.1 总结了所应用的转换。

表 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 子句发布，则将复制满足任何表达式的行。有关详细信息，请参见第 29.4.6 节。

警告

因为初始数据同步在复制现有表数据时不考虑 publish 参数，所以可能会复制一些使用 DML 不会复制的行。请参考第 29.8.1 节，并参见第 29.2.2 节以获取示例。

注意

如果订阅者在 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 为假）。

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)

上一个	上级	下一个
29.3. 逻辑复制故障转移	首页	29.5. 列列表

提交更正

如果您在文档中发现任何不正确的内容，与您对特定功能的体验不符，或者需要进一步说明，请使用此表格报告文档问题。