mirror of
https://git.postgresql.org/git/postgresql.git
synced 2024-09-28 00:21:50 +02:00
270af6f0df
... and in particular don't return them as replica identity. The motivation for this change is letting the primary keys be seen by code that derives NOT NULL constraints from them, when creating inheritance children; before this change, if you had a deferrable PK, pg_dump would not recreate the attnotnull marking properly, because the column would not be considered as having anything to back said marking after dropping the throwaway NOT NULL constraint. The reason we don't want these PKs as replica identities is that replication can corrupt data, if the uniqueness constraint is transiently broken. Reported-by: Amul Sul <sulamul@gmail.com> Reviewed-by: Dean Rasheed <dean.a.rasheed@gmail.com> Discussion: https://postgr.es/m/CAAJ_b94QonkgsbDXofakHDnORQNgafd1y3Oa5QXfpQNJyXyQ7A@mail.gmail.com
300 lines
14 KiB
Plaintext
300 lines
14 KiB
Plaintext
CREATE TABLE test_replica_identity (
|
|
id serial primary key,
|
|
keya text not null,
|
|
keyb text not null,
|
|
nonkey text,
|
|
CONSTRAINT test_replica_identity_unique_defer UNIQUE (keya, keyb) DEFERRABLE,
|
|
CONSTRAINT test_replica_identity_unique_nondefer UNIQUE (keya, keyb)
|
|
) ;
|
|
CREATE TABLE test_replica_identity_othertable (id serial primary key);
|
|
CREATE TABLE test_replica_identity_t3 (id serial constraint pk primary key deferrable);
|
|
CREATE INDEX test_replica_identity_keyab ON test_replica_identity (keya, keyb);
|
|
CREATE UNIQUE INDEX test_replica_identity_keyab_key ON test_replica_identity (keya, keyb);
|
|
CREATE UNIQUE INDEX test_replica_identity_nonkey ON test_replica_identity (keya, nonkey);
|
|
CREATE INDEX test_replica_identity_hash ON test_replica_identity USING hash (nonkey);
|
|
CREATE UNIQUE INDEX test_replica_identity_expr ON test_replica_identity (keya, keyb, (3));
|
|
CREATE UNIQUE INDEX test_replica_identity_partial ON test_replica_identity (keya, keyb) WHERE keyb != '3';
|
|
-- default is 'd'/DEFAULT for user created tables
|
|
SELECT relreplident FROM pg_class WHERE oid = 'test_replica_identity'::regclass;
|
|
relreplident
|
|
--------------
|
|
d
|
|
(1 row)
|
|
|
|
-- but 'none' for system tables
|
|
SELECT relreplident FROM pg_class WHERE oid = 'pg_class'::regclass;
|
|
relreplident
|
|
--------------
|
|
n
|
|
(1 row)
|
|
|
|
SELECT relreplident FROM pg_class WHERE oid = 'pg_constraint'::regclass;
|
|
relreplident
|
|
--------------
|
|
n
|
|
(1 row)
|
|
|
|
----
|
|
-- Make sure we detect ineligible indexes
|
|
----
|
|
-- fail, not unique
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY USING INDEX test_replica_identity_keyab;
|
|
ERROR: cannot use non-unique index "test_replica_identity_keyab" as replica identity
|
|
-- fail, not a candidate key, nullable column
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY USING INDEX test_replica_identity_nonkey;
|
|
ERROR: index "test_replica_identity_nonkey" cannot be used as replica identity because column "nonkey" is nullable
|
|
-- fail, hash indexes cannot do uniqueness
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY USING INDEX test_replica_identity_hash;
|
|
ERROR: cannot use non-unique index "test_replica_identity_hash" as replica identity
|
|
-- fail, expression index
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY USING INDEX test_replica_identity_expr;
|
|
ERROR: cannot use expression index "test_replica_identity_expr" as replica identity
|
|
-- fail, partial index
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY USING INDEX test_replica_identity_partial;
|
|
ERROR: cannot use partial index "test_replica_identity_partial" as replica identity
|
|
-- fail, not our index
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY USING INDEX test_replica_identity_othertable_pkey;
|
|
ERROR: "test_replica_identity_othertable_pkey" is not an index for table "test_replica_identity"
|
|
-- fail, deferrable
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY USING INDEX test_replica_identity_unique_defer;
|
|
ERROR: cannot use non-immediate index "test_replica_identity_unique_defer" as replica identity
|
|
-- fail, deferrable
|
|
ALTER TABLE test_replica_identity_t3 REPLICA IDENTITY USING INDEX pk;
|
|
ERROR: cannot use non-immediate index "pk" as replica identity
|
|
SELECT relreplident FROM pg_class WHERE oid = 'test_replica_identity'::regclass;
|
|
relreplident
|
|
--------------
|
|
d
|
|
(1 row)
|
|
|
|
----
|
|
-- Make sure index cases succeed
|
|
----
|
|
-- succeed, primary key
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY USING INDEX test_replica_identity_pkey;
|
|
SELECT relreplident FROM pg_class WHERE oid = 'test_replica_identity'::regclass;
|
|
relreplident
|
|
--------------
|
|
i
|
|
(1 row)
|
|
|
|
\d test_replica_identity
|
|
Table "public.test_replica_identity"
|
|
Column | Type | Collation | Nullable | Default
|
|
--------+---------+-----------+----------+---------------------------------------------------
|
|
id | integer | | not null | nextval('test_replica_identity_id_seq'::regclass)
|
|
keya | text | | not null |
|
|
keyb | text | | not null |
|
|
nonkey | text | | |
|
|
Indexes:
|
|
"test_replica_identity_pkey" PRIMARY KEY, btree (id) REPLICA IDENTITY
|
|
"test_replica_identity_expr" UNIQUE, btree (keya, keyb, (3))
|
|
"test_replica_identity_hash" hash (nonkey)
|
|
"test_replica_identity_keyab" btree (keya, keyb)
|
|
"test_replica_identity_keyab_key" UNIQUE, btree (keya, keyb)
|
|
"test_replica_identity_nonkey" UNIQUE, btree (keya, nonkey)
|
|
"test_replica_identity_partial" UNIQUE, btree (keya, keyb) WHERE keyb <> '3'::text
|
|
"test_replica_identity_unique_defer" UNIQUE CONSTRAINT, btree (keya, keyb) DEFERRABLE
|
|
"test_replica_identity_unique_nondefer" UNIQUE CONSTRAINT, btree (keya, keyb)
|
|
|
|
-- succeed, nondeferrable unique constraint over nonnullable cols
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY USING INDEX test_replica_identity_unique_nondefer;
|
|
-- succeed unique index over nonnullable cols
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY USING INDEX test_replica_identity_keyab_key;
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY USING INDEX test_replica_identity_keyab_key;
|
|
SELECT relreplident FROM pg_class WHERE oid = 'test_replica_identity'::regclass;
|
|
relreplident
|
|
--------------
|
|
i
|
|
(1 row)
|
|
|
|
\d test_replica_identity
|
|
Table "public.test_replica_identity"
|
|
Column | Type | Collation | Nullable | Default
|
|
--------+---------+-----------+----------+---------------------------------------------------
|
|
id | integer | | not null | nextval('test_replica_identity_id_seq'::regclass)
|
|
keya | text | | not null |
|
|
keyb | text | | not null |
|
|
nonkey | text | | |
|
|
Indexes:
|
|
"test_replica_identity_pkey" PRIMARY KEY, btree (id)
|
|
"test_replica_identity_expr" UNIQUE, btree (keya, keyb, (3))
|
|
"test_replica_identity_hash" hash (nonkey)
|
|
"test_replica_identity_keyab" btree (keya, keyb)
|
|
"test_replica_identity_keyab_key" UNIQUE, btree (keya, keyb) REPLICA IDENTITY
|
|
"test_replica_identity_nonkey" UNIQUE, btree (keya, nonkey)
|
|
"test_replica_identity_partial" UNIQUE, btree (keya, keyb) WHERE keyb <> '3'::text
|
|
"test_replica_identity_unique_defer" UNIQUE CONSTRAINT, btree (keya, keyb) DEFERRABLE
|
|
"test_replica_identity_unique_nondefer" UNIQUE CONSTRAINT, btree (keya, keyb)
|
|
|
|
SELECT count(*) FROM pg_index WHERE indrelid = 'test_replica_identity'::regclass AND indisreplident;
|
|
count
|
|
-------
|
|
1
|
|
(1 row)
|
|
|
|
----
|
|
-- Make sure non index cases work
|
|
----
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY DEFAULT;
|
|
SELECT relreplident FROM pg_class WHERE oid = 'test_replica_identity'::regclass;
|
|
relreplident
|
|
--------------
|
|
d
|
|
(1 row)
|
|
|
|
SELECT count(*) FROM pg_index WHERE indrelid = 'test_replica_identity'::regclass AND indisreplident;
|
|
count
|
|
-------
|
|
0
|
|
(1 row)
|
|
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY FULL;
|
|
SELECT relreplident FROM pg_class WHERE oid = 'test_replica_identity'::regclass;
|
|
relreplident
|
|
--------------
|
|
f
|
|
(1 row)
|
|
|
|
\d+ test_replica_identity
|
|
Table "public.test_replica_identity"
|
|
Column | Type | Collation | Nullable | Default | Storage | Stats target | Description
|
|
--------+---------+-----------+----------+---------------------------------------------------+----------+--------------+-------------
|
|
id | integer | | not null | nextval('test_replica_identity_id_seq'::regclass) | plain | |
|
|
keya | text | | not null | | extended | |
|
|
keyb | text | | not null | | extended | |
|
|
nonkey | text | | | | extended | |
|
|
Indexes:
|
|
"test_replica_identity_pkey" PRIMARY KEY, btree (id)
|
|
"test_replica_identity_expr" UNIQUE, btree (keya, keyb, (3))
|
|
"test_replica_identity_hash" hash (nonkey)
|
|
"test_replica_identity_keyab" btree (keya, keyb)
|
|
"test_replica_identity_keyab_key" UNIQUE, btree (keya, keyb)
|
|
"test_replica_identity_nonkey" UNIQUE, btree (keya, nonkey)
|
|
"test_replica_identity_partial" UNIQUE, btree (keya, keyb) WHERE keyb <> '3'::text
|
|
"test_replica_identity_unique_defer" UNIQUE CONSTRAINT, btree (keya, keyb) DEFERRABLE
|
|
"test_replica_identity_unique_nondefer" UNIQUE CONSTRAINT, btree (keya, keyb)
|
|
Not-null constraints:
|
|
"test_replica_identity_id_not_null" NOT NULL "id"
|
|
"test_replica_identity_keya_not_null" NOT NULL "keya"
|
|
"test_replica_identity_keyb_not_null" NOT NULL "keyb"
|
|
Replica Identity: FULL
|
|
|
|
ALTER TABLE test_replica_identity REPLICA IDENTITY NOTHING;
|
|
SELECT relreplident FROM pg_class WHERE oid = 'test_replica_identity'::regclass;
|
|
relreplident
|
|
--------------
|
|
n
|
|
(1 row)
|
|
|
|
---
|
|
-- Test that ALTER TABLE rewrite preserves nondefault replica identity
|
|
---
|
|
-- constraint variant
|
|
CREATE TABLE test_replica_identity2 (id int UNIQUE NOT NULL);
|
|
ALTER TABLE test_replica_identity2 REPLICA IDENTITY USING INDEX test_replica_identity2_id_key;
|
|
\d test_replica_identity2
|
|
Table "public.test_replica_identity2"
|
|
Column | Type | Collation | Nullable | Default
|
|
--------+---------+-----------+----------+---------
|
|
id | integer | | not null |
|
|
Indexes:
|
|
"test_replica_identity2_id_key" UNIQUE CONSTRAINT, btree (id) REPLICA IDENTITY
|
|
|
|
ALTER TABLE test_replica_identity2 ALTER COLUMN id TYPE bigint;
|
|
\d test_replica_identity2
|
|
Table "public.test_replica_identity2"
|
|
Column | Type | Collation | Nullable | Default
|
|
--------+--------+-----------+----------+---------
|
|
id | bigint | | not null |
|
|
Indexes:
|
|
"test_replica_identity2_id_key" UNIQUE CONSTRAINT, btree (id) REPLICA IDENTITY
|
|
|
|
-- straight index variant
|
|
CREATE TABLE test_replica_identity3 (id int NOT NULL);
|
|
CREATE UNIQUE INDEX test_replica_identity3_id_key ON test_replica_identity3 (id);
|
|
ALTER TABLE test_replica_identity3 REPLICA IDENTITY USING INDEX test_replica_identity3_id_key;
|
|
\d test_replica_identity3
|
|
Table "public.test_replica_identity3"
|
|
Column | Type | Collation | Nullable | Default
|
|
--------+---------+-----------+----------+---------
|
|
id | integer | | not null |
|
|
Indexes:
|
|
"test_replica_identity3_id_key" UNIQUE, btree (id) REPLICA IDENTITY
|
|
|
|
ALTER TABLE test_replica_identity3 ALTER COLUMN id TYPE bigint;
|
|
\d test_replica_identity3
|
|
Table "public.test_replica_identity3"
|
|
Column | Type | Collation | Nullable | Default
|
|
--------+--------+-----------+----------+---------
|
|
id | bigint | | not null |
|
|
Indexes:
|
|
"test_replica_identity3_id_key" UNIQUE, btree (id) REPLICA IDENTITY
|
|
|
|
-- ALTER TABLE DROP NOT NULL is not allowed for columns part of an index
|
|
-- used as replica identity.
|
|
ALTER TABLE test_replica_identity3 ALTER COLUMN id DROP NOT NULL;
|
|
ERROR: column "id" is in index used as replica identity
|
|
-- but it's OK when the identity is FULL
|
|
ALTER TABLE test_replica_identity3 REPLICA IDENTITY FULL;
|
|
ALTER TABLE test_replica_identity3 ALTER COLUMN id DROP NOT NULL;
|
|
--
|
|
-- Test that replica identity can be set on an index that's not yet valid.
|
|
-- (This matches the way pg_dump will try to dump a partitioned table.)
|
|
--
|
|
CREATE TABLE test_replica_identity4(id integer NOT NULL) PARTITION BY LIST (id);
|
|
CREATE TABLE test_replica_identity4_1(id integer NOT NULL);
|
|
ALTER TABLE ONLY test_replica_identity4
|
|
ATTACH PARTITION test_replica_identity4_1 FOR VALUES IN (1);
|
|
ALTER TABLE ONLY test_replica_identity4
|
|
ADD CONSTRAINT test_replica_identity4_pkey PRIMARY KEY (id);
|
|
ALTER TABLE ONLY test_replica_identity4
|
|
REPLICA IDENTITY USING INDEX test_replica_identity4_pkey;
|
|
ALTER TABLE ONLY test_replica_identity4_1
|
|
ADD CONSTRAINT test_replica_identity4_1_pkey PRIMARY KEY (id);
|
|
\d+ test_replica_identity4
|
|
Partitioned table "public.test_replica_identity4"
|
|
Column | Type | Collation | Nullable | Default | Storage | Stats target | Description
|
|
--------+---------+-----------+----------+---------+---------+--------------+-------------
|
|
id | integer | | not null | | plain | |
|
|
Partition key: LIST (id)
|
|
Indexes:
|
|
"test_replica_identity4_pkey" PRIMARY KEY, btree (id) INVALID REPLICA IDENTITY
|
|
Not-null constraints:
|
|
"test_replica_identity4_id_not_null" NOT NULL "id"
|
|
Partitions: test_replica_identity4_1 FOR VALUES IN (1)
|
|
|
|
ALTER INDEX test_replica_identity4_pkey
|
|
ATTACH PARTITION test_replica_identity4_1_pkey;
|
|
\d+ test_replica_identity4
|
|
Partitioned table "public.test_replica_identity4"
|
|
Column | Type | Collation | Nullable | Default | Storage | Stats target | Description
|
|
--------+---------+-----------+----------+---------+---------+--------------+-------------
|
|
id | integer | | not null | | plain | |
|
|
Partition key: LIST (id)
|
|
Indexes:
|
|
"test_replica_identity4_pkey" PRIMARY KEY, btree (id) REPLICA IDENTITY
|
|
Not-null constraints:
|
|
"test_replica_identity4_id_not_null" NOT NULL "id"
|
|
Partitions: test_replica_identity4_1 FOR VALUES IN (1)
|
|
|
|
-- Dropping the primary key is not allowed if that would leave the replica
|
|
-- identity as nullable
|
|
CREATE TABLE test_replica_identity5 (a int not null, b int, c int,
|
|
PRIMARY KEY (b, c));
|
|
CREATE UNIQUE INDEX test_replica_identity5_a_b_key ON test_replica_identity5 (a, b);
|
|
ALTER TABLE test_replica_identity5 REPLICA IDENTITY USING INDEX test_replica_identity5_a_b_key;
|
|
ALTER TABLE test_replica_identity5 DROP CONSTRAINT test_replica_identity5_pkey;
|
|
ERROR: column "b" is in index used as replica identity
|
|
ALTER TABLE test_replica_identity5 ALTER b SET NOT NULL;
|
|
ALTER TABLE test_replica_identity5 DROP CONSTRAINT test_replica_identity5_pkey;
|
|
ALTER TABLE test_replica_identity5 ALTER b DROP NOT NULL;
|
|
ERROR: column "b" is in index used as replica identity
|
|
DROP TABLE test_replica_identity;
|
|
DROP TABLE test_replica_identity2;
|
|
DROP TABLE test_replica_identity3;
|
|
DROP TABLE test_replica_identity4;
|
|
DROP TABLE test_replica_identity5;
|
|
DROP TABLE test_replica_identity_othertable;
|
|
DROP TABLE test_replica_identity_t3;
|