mirror of
https://github.com/postgres/postgres.git
synced 2025-09-03 15:22:11 +03:00
46f9acd3ef
If a row that potentially violates a deferred exclusion constraint is HOT-updated later in the same transaction, the exclusion constraint would be reported as violated when the check finally occurs, even if the row(s) the new row originally conflicted with have since been removed. This happened because the wrong TID was passed to check_exclusion_constraint(), causing the live HOT-updated row to be seen as a conflicting row rather than recognized as the row-under-test. Per bug #13148 from Evan Martin. It's been broken since exclusion constraints were invented, so back-patch to all supported branches.
469 lines
12 KiB
Plaintext
469 lines
12 KiB
Plaintext
--
|
|
-- CONSTRAINTS
|
|
-- Constraints can be specified with:
|
|
-- - DEFAULT clause
|
|
-- - CHECK clauses
|
|
-- - PRIMARY KEY clauses
|
|
-- - UNIQUE clauses
|
|
-- - EXCLUDE clauses
|
|
--
|
|
|
|
--
|
|
-- DEFAULT syntax
|
|
--
|
|
|
|
CREATE TABLE DEFAULT_TBL (i int DEFAULT 100,
|
|
x text DEFAULT 'vadim', f float8 DEFAULT 123.456);
|
|
|
|
INSERT INTO DEFAULT_TBL VALUES (1, 'thomas', 57.0613);
|
|
INSERT INTO DEFAULT_TBL VALUES (1, 'bruce');
|
|
INSERT INTO DEFAULT_TBL (i, f) VALUES (2, 987.654);
|
|
INSERT INTO DEFAULT_TBL (x) VALUES ('marc');
|
|
INSERT INTO DEFAULT_TBL VALUES (3, null, 1.0);
|
|
|
|
SELECT '' AS five, * FROM DEFAULT_TBL;
|
|
|
|
CREATE SEQUENCE DEFAULT_SEQ;
|
|
|
|
CREATE TABLE DEFAULTEXPR_TBL (i1 int DEFAULT 100 + (200-199) * 2,
|
|
i2 int DEFAULT nextval('default_seq'));
|
|
|
|
INSERT INTO DEFAULTEXPR_TBL VALUES (-1, -2);
|
|
INSERT INTO DEFAULTEXPR_TBL (i1) VALUES (-3);
|
|
INSERT INTO DEFAULTEXPR_TBL (i2) VALUES (-4);
|
|
INSERT INTO DEFAULTEXPR_TBL (i2) VALUES (NULL);
|
|
|
|
SELECT '' AS four, * FROM DEFAULTEXPR_TBL;
|
|
|
|
-- syntax errors
|
|
-- test for extraneous comma
|
|
CREATE TABLE error_tbl (i int DEFAULT (100, ));
|
|
-- this will fail because gram.y uses b_expr not a_expr for defaults,
|
|
-- to avoid a shift/reduce conflict that arises from NOT NULL being
|
|
-- part of the column definition syntax:
|
|
CREATE TABLE error_tbl (b1 bool DEFAULT 1 IN (1, 2));
|
|
-- this should work, however:
|
|
CREATE TABLE error_tbl (b1 bool DEFAULT (1 IN (1, 2)));
|
|
|
|
DROP TABLE error_tbl;
|
|
|
|
--
|
|
-- CHECK syntax
|
|
--
|
|
|
|
CREATE TABLE CHECK_TBL (x int,
|
|
CONSTRAINT CHECK_CON CHECK (x > 3));
|
|
|
|
INSERT INTO CHECK_TBL VALUES (5);
|
|
INSERT INTO CHECK_TBL VALUES (4);
|
|
INSERT INTO CHECK_TBL VALUES (3);
|
|
INSERT INTO CHECK_TBL VALUES (2);
|
|
INSERT INTO CHECK_TBL VALUES (6);
|
|
INSERT INTO CHECK_TBL VALUES (1);
|
|
|
|
SELECT '' AS three, * FROM CHECK_TBL;
|
|
|
|
CREATE SEQUENCE CHECK_SEQ;
|
|
|
|
CREATE TABLE CHECK2_TBL (x int, y text, z int,
|
|
CONSTRAINT SEQUENCE_CON
|
|
CHECK (x > 3 and y <> 'check failed' and z < 8));
|
|
|
|
INSERT INTO CHECK2_TBL VALUES (4, 'check ok', -2);
|
|
INSERT INTO CHECK2_TBL VALUES (1, 'x check failed', -2);
|
|
INSERT INTO CHECK2_TBL VALUES (5, 'z check failed', 10);
|
|
INSERT INTO CHECK2_TBL VALUES (0, 'check failed', -2);
|
|
INSERT INTO CHECK2_TBL VALUES (6, 'check failed', 11);
|
|
INSERT INTO CHECK2_TBL VALUES (7, 'check ok', 7);
|
|
|
|
SELECT '' AS two, * from CHECK2_TBL;
|
|
|
|
--
|
|
-- Check constraints on INSERT
|
|
--
|
|
|
|
CREATE SEQUENCE INSERT_SEQ;
|
|
|
|
CREATE TABLE INSERT_TBL (x INT DEFAULT nextval('insert_seq'),
|
|
y TEXT DEFAULT '-NULL-',
|
|
z INT DEFAULT -1 * currval('insert_seq'),
|
|
CONSTRAINT INSERT_CON CHECK (x >= 3 AND y <> 'check failed' AND x < 8),
|
|
CHECK (x + z = 0));
|
|
|
|
INSERT INTO INSERT_TBL(x,z) VALUES (2, -2);
|
|
|
|
SELECT '' AS zero, * FROM INSERT_TBL;
|
|
|
|
SELECT 'one' AS one, nextval('insert_seq');
|
|
|
|
INSERT INTO INSERT_TBL(y) VALUES ('Y');
|
|
INSERT INTO INSERT_TBL(y) VALUES ('Y');
|
|
INSERT INTO INSERT_TBL(x,z) VALUES (1, -2);
|
|
INSERT INTO INSERT_TBL(z,x) VALUES (-7, 7);
|
|
INSERT INTO INSERT_TBL VALUES (5, 'check failed', -5);
|
|
INSERT INTO INSERT_TBL VALUES (7, '!check failed', -7);
|
|
INSERT INTO INSERT_TBL(y) VALUES ('-!NULL-');
|
|
|
|
SELECT '' AS four, * FROM INSERT_TBL;
|
|
|
|
INSERT INTO INSERT_TBL(y,z) VALUES ('check failed', 4);
|
|
INSERT INTO INSERT_TBL(x,y) VALUES (5, 'check failed');
|
|
INSERT INTO INSERT_TBL(x,y) VALUES (5, '!check failed');
|
|
INSERT INTO INSERT_TBL(y) VALUES ('-!NULL-');
|
|
|
|
SELECT '' AS six, * FROM INSERT_TBL;
|
|
|
|
SELECT 'seven' AS one, nextval('insert_seq');
|
|
|
|
INSERT INTO INSERT_TBL(y) VALUES ('Y');
|
|
|
|
SELECT 'eight' AS one, currval('insert_seq');
|
|
|
|
-- According to SQL92, it is OK to insert a record that gives rise to NULL
|
|
-- constraint-condition results. Postgres used to reject this, but it
|
|
-- was wrong:
|
|
INSERT INTO INSERT_TBL VALUES (null, null, null);
|
|
|
|
SELECT '' AS nine, * FROM INSERT_TBL;
|
|
|
|
--
|
|
-- Check inheritance of defaults and constraints
|
|
--
|
|
|
|
CREATE TABLE INSERT_CHILD (cx INT default 42,
|
|
cy INT CHECK (cy > x))
|
|
INHERITS (INSERT_TBL);
|
|
|
|
INSERT INTO INSERT_CHILD(x,z,cy) VALUES (7,-7,11);
|
|
INSERT INTO INSERT_CHILD(x,z,cy) VALUES (7,-7,6);
|
|
INSERT INTO INSERT_CHILD(x,z,cy) VALUES (6,-7,7);
|
|
INSERT INTO INSERT_CHILD(x,y,z,cy) VALUES (6,'check failed',-6,7);
|
|
|
|
SELECT * FROM INSERT_CHILD;
|
|
|
|
DROP TABLE INSERT_CHILD;
|
|
|
|
--
|
|
-- Check NO INHERIT type of constraints and inheritance
|
|
--
|
|
|
|
CREATE TABLE ATACC1 (TEST INT
|
|
CHECK (TEST > 0) NO INHERIT);
|
|
|
|
CREATE TABLE ATACC2 (TEST2 INT) INHERITS (ATACC1);
|
|
-- check constraint is not there on child
|
|
INSERT INTO ATACC2 (TEST) VALUES (-3);
|
|
-- check constraint is there on parent
|
|
INSERT INTO ATACC1 (TEST) VALUES (-3);
|
|
DROP TABLE ATACC1 CASCADE;
|
|
|
|
CREATE TABLE ATACC1 (TEST INT, TEST2 INT
|
|
CHECK (TEST > 0), CHECK (TEST2 > 10) NO INHERIT);
|
|
|
|
CREATE TABLE ATACC2 () INHERITS (ATACC1);
|
|
-- check constraint is there on child
|
|
INSERT INTO ATACC2 (TEST) VALUES (-3);
|
|
-- check constraint is there on parent
|
|
INSERT INTO ATACC1 (TEST) VALUES (-3);
|
|
-- check constraint is not there on child
|
|
INSERT INTO ATACC2 (TEST2) VALUES (3);
|
|
-- check constraint is there on parent
|
|
INSERT INTO ATACC1 (TEST2) VALUES (3);
|
|
DROP TABLE ATACC1 CASCADE;
|
|
|
|
--
|
|
-- Check constraints on INSERT INTO
|
|
--
|
|
|
|
DELETE FROM INSERT_TBL;
|
|
|
|
ALTER SEQUENCE INSERT_SEQ RESTART WITH 4;
|
|
|
|
CREATE TABLE tmp (xd INT, yd TEXT, zd INT);
|
|
|
|
INSERT INTO tmp VALUES (null, 'Y', null);
|
|
INSERT INTO tmp VALUES (5, '!check failed', null);
|
|
INSERT INTO tmp VALUES (null, 'try again', null);
|
|
INSERT INTO INSERT_TBL(y) select yd from tmp;
|
|
|
|
SELECT '' AS three, * FROM INSERT_TBL;
|
|
|
|
INSERT INTO INSERT_TBL SELECT * FROM tmp WHERE yd = 'try again';
|
|
INSERT INTO INSERT_TBL(y,z) SELECT yd, -7 FROM tmp WHERE yd = 'try again';
|
|
INSERT INTO INSERT_TBL(y,z) SELECT yd, -8 FROM tmp WHERE yd = 'try again';
|
|
|
|
SELECT '' AS four, * FROM INSERT_TBL;
|
|
|
|
DROP TABLE tmp;
|
|
|
|
--
|
|
-- Check constraints on UPDATE
|
|
--
|
|
|
|
UPDATE INSERT_TBL SET x = NULL WHERE x = 5;
|
|
UPDATE INSERT_TBL SET x = 6 WHERE x = 6;
|
|
UPDATE INSERT_TBL SET x = -z, z = -x;
|
|
UPDATE INSERT_TBL SET x = z, z = x;
|
|
|
|
SELECT * FROM INSERT_TBL;
|
|
|
|
-- DROP TABLE INSERT_TBL;
|
|
|
|
--
|
|
-- Check constraints on COPY FROM
|
|
--
|
|
|
|
CREATE TABLE COPY_TBL (x INT, y TEXT, z INT,
|
|
CONSTRAINT COPY_CON
|
|
CHECK (x > 3 AND y <> 'check failed' AND x < 7 ));
|
|
|
|
COPY COPY_TBL FROM '@abs_srcdir@/data/constro.data';
|
|
|
|
SELECT '' AS two, * FROM COPY_TBL;
|
|
|
|
COPY COPY_TBL FROM '@abs_srcdir@/data/constrf.data';
|
|
|
|
SELECT * FROM COPY_TBL;
|
|
|
|
--
|
|
-- Primary keys
|
|
--
|
|
|
|
CREATE TABLE PRIMARY_TBL (i int PRIMARY KEY, t text);
|
|
|
|
INSERT INTO PRIMARY_TBL VALUES (1, 'one');
|
|
INSERT INTO PRIMARY_TBL VALUES (2, 'two');
|
|
INSERT INTO PRIMARY_TBL VALUES (1, 'three');
|
|
INSERT INTO PRIMARY_TBL VALUES (4, 'three');
|
|
INSERT INTO PRIMARY_TBL VALUES (5, 'one');
|
|
INSERT INTO PRIMARY_TBL (t) VALUES ('six');
|
|
|
|
SELECT '' AS four, * FROM PRIMARY_TBL;
|
|
|
|
DROP TABLE PRIMARY_TBL;
|
|
|
|
CREATE TABLE PRIMARY_TBL (i int, t text,
|
|
PRIMARY KEY(i,t));
|
|
|
|
INSERT INTO PRIMARY_TBL VALUES (1, 'one');
|
|
INSERT INTO PRIMARY_TBL VALUES (2, 'two');
|
|
INSERT INTO PRIMARY_TBL VALUES (1, 'three');
|
|
INSERT INTO PRIMARY_TBL VALUES (4, 'three');
|
|
INSERT INTO PRIMARY_TBL VALUES (5, 'one');
|
|
INSERT INTO PRIMARY_TBL (t) VALUES ('six');
|
|
|
|
SELECT '' AS three, * FROM PRIMARY_TBL;
|
|
|
|
DROP TABLE PRIMARY_TBL;
|
|
|
|
--
|
|
-- Unique keys
|
|
--
|
|
|
|
CREATE TABLE UNIQUE_TBL (i int UNIQUE, t text);
|
|
|
|
INSERT INTO UNIQUE_TBL VALUES (1, 'one');
|
|
INSERT INTO UNIQUE_TBL VALUES (2, 'two');
|
|
INSERT INTO UNIQUE_TBL VALUES (1, 'three');
|
|
INSERT INTO UNIQUE_TBL VALUES (4, 'four');
|
|
INSERT INTO UNIQUE_TBL VALUES (5, 'one');
|
|
INSERT INTO UNIQUE_TBL (t) VALUES ('six');
|
|
INSERT INTO UNIQUE_TBL (t) VALUES ('seven');
|
|
|
|
SELECT '' AS five, * FROM UNIQUE_TBL;
|
|
|
|
DROP TABLE UNIQUE_TBL;
|
|
|
|
CREATE TABLE UNIQUE_TBL (i int, t text,
|
|
UNIQUE(i,t));
|
|
|
|
INSERT INTO UNIQUE_TBL VALUES (1, 'one');
|
|
INSERT INTO UNIQUE_TBL VALUES (2, 'two');
|
|
INSERT INTO UNIQUE_TBL VALUES (1, 'three');
|
|
INSERT INTO UNIQUE_TBL VALUES (1, 'one');
|
|
INSERT INTO UNIQUE_TBL VALUES (5, 'one');
|
|
INSERT INTO UNIQUE_TBL (t) VALUES ('six');
|
|
|
|
SELECT '' AS five, * FROM UNIQUE_TBL;
|
|
|
|
DROP TABLE UNIQUE_TBL;
|
|
|
|
--
|
|
-- Deferrable unique constraints
|
|
--
|
|
|
|
CREATE TABLE unique_tbl (i int UNIQUE DEFERRABLE, t text);
|
|
|
|
INSERT INTO unique_tbl VALUES (0, 'one');
|
|
INSERT INTO unique_tbl VALUES (1, 'two');
|
|
INSERT INTO unique_tbl VALUES (2, 'tree');
|
|
INSERT INTO unique_tbl VALUES (3, 'four');
|
|
INSERT INTO unique_tbl VALUES (4, 'five');
|
|
|
|
BEGIN;
|
|
|
|
-- default is immediate so this should fail right away
|
|
UPDATE unique_tbl SET i = 1 WHERE i = 0;
|
|
|
|
ROLLBACK;
|
|
|
|
-- check is done at end of statement, so this should succeed
|
|
UPDATE unique_tbl SET i = i+1;
|
|
|
|
SELECT * FROM unique_tbl;
|
|
|
|
-- explicitly defer the constraint
|
|
BEGIN;
|
|
|
|
SET CONSTRAINTS unique_tbl_i_key DEFERRED;
|
|
|
|
INSERT INTO unique_tbl VALUES (3, 'three');
|
|
DELETE FROM unique_tbl WHERE t = 'tree'; -- makes constraint valid again
|
|
|
|
COMMIT; -- should succeed
|
|
|
|
SELECT * FROM unique_tbl;
|
|
|
|
-- try adding an initially deferred constraint
|
|
ALTER TABLE unique_tbl DROP CONSTRAINT unique_tbl_i_key;
|
|
ALTER TABLE unique_tbl ADD CONSTRAINT unique_tbl_i_key
|
|
UNIQUE (i) DEFERRABLE INITIALLY DEFERRED;
|
|
|
|
BEGIN;
|
|
|
|
INSERT INTO unique_tbl VALUES (1, 'five');
|
|
INSERT INTO unique_tbl VALUES (5, 'one');
|
|
UPDATE unique_tbl SET i = 4 WHERE i = 2;
|
|
UPDATE unique_tbl SET i = 2 WHERE i = 4 AND t = 'four';
|
|
DELETE FROM unique_tbl WHERE i = 1 AND t = 'one';
|
|
DELETE FROM unique_tbl WHERE i = 5 AND t = 'five';
|
|
|
|
COMMIT;
|
|
|
|
SELECT * FROM unique_tbl;
|
|
|
|
-- should fail at commit-time
|
|
BEGIN;
|
|
INSERT INTO unique_tbl VALUES (3, 'Three'); -- should succeed for now
|
|
COMMIT; -- should fail
|
|
|
|
-- make constraint check immediate
|
|
BEGIN;
|
|
|
|
SET CONSTRAINTS ALL IMMEDIATE;
|
|
|
|
INSERT INTO unique_tbl VALUES (3, 'Three'); -- should fail
|
|
|
|
COMMIT;
|
|
|
|
-- forced check when SET CONSTRAINTS is called
|
|
BEGIN;
|
|
|
|
SET CONSTRAINTS ALL DEFERRED;
|
|
|
|
INSERT INTO unique_tbl VALUES (3, 'Three'); -- should succeed for now
|
|
|
|
SET CONSTRAINTS ALL IMMEDIATE; -- should fail
|
|
|
|
COMMIT;
|
|
|
|
-- test a HOT update that invalidates the conflicting tuple.
|
|
-- the trigger should still fire and catch the violation
|
|
|
|
BEGIN;
|
|
|
|
INSERT INTO unique_tbl VALUES (3, 'Three'); -- should succeed for now
|
|
UPDATE unique_tbl SET t = 'THREE' WHERE i = 3 AND t = 'Three';
|
|
|
|
COMMIT; -- should fail
|
|
|
|
SELECT * FROM unique_tbl;
|
|
|
|
-- test a HOT update that modifies the newly inserted tuple,
|
|
-- but should succeed because we then remove the other conflicting tuple.
|
|
|
|
BEGIN;
|
|
|
|
INSERT INTO unique_tbl VALUES(3, 'tree'); -- should succeed for now
|
|
UPDATE unique_tbl SET t = 'threex' WHERE t = 'tree';
|
|
DELETE FROM unique_tbl WHERE t = 'three';
|
|
|
|
SELECT * FROM unique_tbl;
|
|
|
|
COMMIT;
|
|
|
|
SELECT * FROM unique_tbl;
|
|
|
|
DROP TABLE unique_tbl;
|
|
|
|
--
|
|
-- EXCLUDE constraints
|
|
--
|
|
|
|
CREATE TABLE circles (
|
|
c1 CIRCLE,
|
|
c2 TEXT,
|
|
EXCLUDE USING gist
|
|
(c1 WITH &&, (c2::circle) WITH &&)
|
|
WHERE (circle_center(c1) <> '(0,0)')
|
|
);
|
|
|
|
-- these should succeed because they don't match the index predicate
|
|
INSERT INTO circles VALUES('<(0,0), 5>', '<(0,0), 5>');
|
|
INSERT INTO circles VALUES('<(0,0), 5>', '<(0,0), 4>');
|
|
|
|
-- succeed
|
|
INSERT INTO circles VALUES('<(10,10), 10>', '<(0,0), 5>');
|
|
-- fail, overlaps
|
|
INSERT INTO circles VALUES('<(20,20), 10>', '<(0,0), 4>');
|
|
-- succeed because c1 doesn't overlap
|
|
INSERT INTO circles VALUES('<(20,20), 1>', '<(0,0), 5>');
|
|
-- succeed because c2 doesn't overlap
|
|
INSERT INTO circles VALUES('<(20,20), 10>', '<(10,10), 5>');
|
|
|
|
-- should fail on existing data without the WHERE clause
|
|
ALTER TABLE circles ADD EXCLUDE USING gist
|
|
(c1 WITH &&, (c2::circle) WITH &&);
|
|
|
|
-- try reindexing an existing constraint
|
|
REINDEX INDEX circles_c1_c2_excl;
|
|
|
|
DROP TABLE circles;
|
|
|
|
-- Check deferred exclusion constraint
|
|
|
|
CREATE TABLE deferred_excl (
|
|
f1 int,
|
|
f2 int,
|
|
CONSTRAINT deferred_excl_con EXCLUDE (f1 WITH =) INITIALLY DEFERRED
|
|
);
|
|
|
|
INSERT INTO deferred_excl VALUES(1);
|
|
INSERT INTO deferred_excl VALUES(2);
|
|
INSERT INTO deferred_excl VALUES(1); -- fail
|
|
BEGIN;
|
|
INSERT INTO deferred_excl VALUES(2); -- no fail here
|
|
COMMIT; -- should fail here
|
|
BEGIN;
|
|
INSERT INTO deferred_excl VALUES(3);
|
|
INSERT INTO deferred_excl VALUES(3); -- no fail here
|
|
COMMIT; -- should fail here
|
|
|
|
-- bug #13148: deferred constraint versus HOT update
|
|
BEGIN;
|
|
INSERT INTO deferred_excl VALUES(2, 1); -- no fail here
|
|
DELETE FROM deferred_excl WHERE f1 = 2 AND f2 IS NULL; -- remove old row
|
|
UPDATE deferred_excl SET f2 = 2 WHERE f1 = 2;
|
|
COMMIT; -- should not fail
|
|
|
|
SELECT * FROM deferred_excl;
|
|
|
|
ALTER TABLE deferred_excl DROP CONSTRAINT deferred_excl_con;
|
|
|
|
-- This should fail, but worth testing because of HOT updates
|
|
UPDATE deferred_excl SET f1 = 3;
|
|
|
|
ALTER TABLE deferred_excl ADD EXCLUDE (f1 WITH =);
|
|
|
|
DROP TABLE deferred_excl;
|