1 files changed, 69 insertions, 0 deletions
diff --git a/src/test/isolation/specs/detach-partition-concurrently-1.spec b/src/test/isolation/specs/detach-partition-concurrently-1.spec
new file mode 100644
index 0000000..835fe89
--- /dev/null
+++ b/src/test/isolation/specs/detach-partition-concurrently-1.spec
@@ -0,0 +1,69 @@
+# Test that detach partition concurrently makes the partition invisible at the
+# correct time.
+
+setup
+{
+  DROP TABLE IF EXISTS d_listp, d_listp1, d_listp2;
+  CREATE TABLE d_listp (a int) PARTITION BY LIST(a);
+  CREATE TABLE d_listp1 PARTITION OF d_listp FOR VALUES IN (1);
+  CREATE TABLE d_listp2 PARTITION OF d_listp FOR VALUES IN (2);
+  INSERT INTO d_listp VALUES (1),(2);
+}
+
+teardown {
+    DROP TABLE IF EXISTS d_listp, d_listp2, d_listp_foobar;
+}
+
+session s1
+step s1b		{ BEGIN; }
+step s1brr		{ BEGIN ISOLATION LEVEL REPEATABLE READ; }
+step s1s		{ SELECT * FROM d_listp; }
+step s1ins		{ INSERT INTO d_listp VALUES (1); }
+step s1ins2		{ INSERT INTO d_listp VALUES (2); }
+step s1prep		{ PREPARE f(int) AS INSERT INTO d_listp VALUES ($1); }
+step s1prep1	{ PREPARE f(int) AS INSERT INTO d_listp VALUES (1); }
+step s1prep2	{ PREPARE f(int) AS INSERT INTO d_listp VALUES (2); }
+step s1exec1	{ EXECUTE f(1); }
+step s1exec2	{ EXECUTE f(2); }
+step s1dealloc	{ DEALLOCATE f; }
+step s1c		{ COMMIT; }
+
+session s2
+step s2detach	{ ALTER TABLE d_listp DETACH PARTITION d_listp2 CONCURRENTLY; }
+step s2drop		{ DROP TABLE d_listp2; }
+
+session s3
+step s3s		{ SELECT * FROM d_listp; }
+step s3i		{ SELECT relpartbound IS NULL FROM pg_class where relname = 'd_listp2'; }
+step s3ins2		{ INSERT INTO d_listp VALUES (2); }
+
+# The transaction that detaches hangs until it sees any older transaction
+# terminate, as does anybody else.
+permutation s1b s1s s2detach s1s s1c s1s
+
+# relpartbound remains set until s1 commits
+# XXX this could be timing dependent :-(
+permutation s1b s1s s2detach s1s s3s s3i s1c s3i s2drop s1s
+
+# In read-committed mode, the partition disappears from view of concurrent
+# transactions immediately.  But if a write lock is held, then the detach
+# has to wait.
+permutation s1b   s1s          s2detach s1ins s1s s1c
+permutation s1b   s1s s1ins2 s2detach s1ins s1s s1c
+
+# In repeatable-read mode, the partition remains visible until commit even
+# if the to-be-detached partition is not locked for write.
+permutation s1brr s1s          s2detach s1ins s1s s1c
+permutation s1brr s1s          s2detach         s1s s1c
+
+# Another process trying to acquire a write lock will be blocked behind the
+# detacher
+permutation s1b s1ins2 s2detach s3ins2 s1c
+
+# a prepared query is not blocked
+permutation s1brr s1prep s1s s2detach s1s s1exec1 s3s s1dealloc s1c
+permutation s1brr s1prep s1exec2 s2detach s1s s1exec2 s3s s1c s1dealloc
+permutation s1brr s1prep s1s s2detach s1s s1exec2 s1c s1dealloc
+permutation s1brr s1prep s2detach s1s s1exec2 s1c s1dealloc
+permutation s1brr s1prep1 s2detach s1s s1exec2 s1c s1dealloc
+permutation s1brr s1prep2 s2detach s1s s1exec2 s1c s1dealloc