Reducing lock strength of adding foreign keys
Started by Andreas Karlssonabout 11 years ago39 messages
Hi,
I have been thinking about why we need to grab an AccessExclusiveLock on
the table with the PK when we add a foreign key. Adding new tables with
foreign keys to old ones is common so it would be really nice if the
lock strength could be reduced.
A comment in the code claims that we need to lock so no rows are deleted
under us and that adding a trigger will lock in AccessExclusive anyway.
But with MVCC catalog access and the removal of SnapshotNow I do not see
why adding a trigger would require an exclusive lock. Just locking for
data changes should be enough.
Looking at the code the only see the duplicate name check use the fact
that we have grabbed an exclusive lock and that should work anyway due
to the unique constraint, but since I am pretty new to the code base I
could be missing something obvious. I have attached a proof of concept
patch which reduces the lock strength to ShareLock.
What do you say? Am I missing something?
My gut feel also says that if we know it is a RI trigger we are adding
then AccessShare should be enough for the PK table, since we could rely
on row locks to prevent rows from being deleted. It would be really nice
though if this was possible since this would make it possible to add a
new table with foreign keys and data without locking anything more than
the referred rows.
Andreas
Attachments:
add-fk-lock-strength.patchtext/x-patch; name=add-fk-lock-strength.patchDownload
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
new file mode 100644
index ecdff1e..49ad323
*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
*************** ATAddForeignKeyConstraint(AlteredTableIn
*** 6016,6031 ****
ListCell *old_pfeqop_item = list_head(fkconstraint->old_conpfeqop);
/*
! * Grab an exclusive lock on the pk table, so that someone doesn't delete
! * rows out from under us. (Although a lesser lock would do for that
! * purpose, we'll need exclusive lock anyway to add triggers to the pk
! * table; trying to start with a lesser lock will just create a risk of
! * deadlock.)
*/
if (OidIsValid(fkconstraint->old_pktable_oid))
! pkrel = heap_open(fkconstraint->old_pktable_oid, AccessExclusiveLock);
else
! pkrel = heap_openrv(fkconstraint->pktable, AccessExclusiveLock);
/*
* Validity checks (permission checks wait till we have the column
--- 6016,6028 ----
ListCell *old_pfeqop_item = list_head(fkconstraint->old_conpfeqop);
/*
! * Grab an share lock on the pk table, so that someone doesn't delete
! * rows out from under us.
*/
if (OidIsValid(fkconstraint->old_pktable_oid))
! pkrel = heap_open(fkconstraint->old_pktable_oid, ShareLock);
else
! pkrel = heap_openrv(fkconstraint->pktable, ShareLock);
/*
* Validity checks (permission checks wait till we have the column
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
new file mode 100644
index f4c0ffa..214755d
*** a/src/backend/commands/trigger.c
--- b/src/backend/commands/trigger.c
*************** CreateTrigger(CreateTrigStmt *stmt, cons
*** 157,165 ****
referenced;
if (OidIsValid(relOid))
! rel = heap_open(relOid, AccessExclusiveLock);
else
! rel = heap_openrv(stmt->relation, AccessExclusiveLock);
/*
* Triggers must be on tables or views, and there are additional
--- 157,165 ----
referenced;
if (OidIsValid(relOid))
! rel = heap_open(relOid, ShareLock);
else
! rel = heap_openrv(stmt->relation, ShareLock);
/*
* Triggers must be on tables or views, and there are additional
*************** CreateTrigger(CreateTrigStmt *stmt, cons
*** 525,532 ****
* can skip this for internally generated triggers, since the name
* modification above should be sufficient.
*
! * NOTE that this is cool only because we have AccessExclusiveLock on the
! * relation, so the trigger set won't be changing underneath us.
*/
if (!isInternal)
{
--- 525,531 ----
* can skip this for internally generated triggers, since the name
* modification above should be sufficient.
*
! * NOTE that this is cool only because of the unique contraint.
*/
if (!isInternal)
{
*************** RemoveTriggerById(Oid trigOid)
*** 1102,1108 ****
*/
relid = ((Form_pg_trigger) GETSTRUCT(tup))->tgrelid;
! rel = heap_open(relid, AccessExclusiveLock);
if (rel->rd_rel->relkind != RELKIND_RELATION &&
rel->rd_rel->relkind != RELKIND_VIEW &&
--- 1101,1107 ----
*/
relid = ((Form_pg_trigger) GETSTRUCT(tup))->tgrelid;
! rel = heap_open(relid, ShareLock);
if (rel->rd_rel->relkind != RELKIND_RELATION &&
rel->rd_rel->relkind != RELKIND_VIEW &&
*************** renametrig(RenameStmt *stmt)
*** 1257,1263 ****
* Look up name, check permissions, and acquire lock (which we will NOT
* release until end of transaction).
*/
! relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
false, false,
RangeVarCallbackForRenameTrigger,
NULL);
--- 1256,1262 ----
* Look up name, check permissions, and acquire lock (which we will NOT
* release until end of transaction).
*/
! relid = RangeVarGetRelidExtended(stmt->relation, ShareLock,
false, false,
RangeVarCallbackForRenameTrigger,
NULL);
*************** renametrig(RenameStmt *stmt)
*** 1271,1278 ****
* on tgrelid/tgname would complain anyway) and to ensure a trigger does
* exist with oldname.
*
! * NOTE that this is cool only because we have AccessExclusiveLock on the
! * relation, so the trigger set won't be changing underneath us.
*/
tgrel = heap_open(TriggerRelationId, RowExclusiveLock);
--- 1270,1276 ----
* on tgrelid/tgname would complain anyway) and to ensure a trigger does
* exist with oldname.
*
! * NOTE that this is cool only because there is a unique constraint.
*/
tgrel = heap_open(TriggerRelationId, RowExclusiveLock);
diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out
new file mode 100644
index 10f45f2..636b951
*** a/src/test/regress/expected/alter_table.out
--- b/src/test/regress/expected/alter_table.out
*************** create trigger ttdummy
*** 1935,1943 ****
execute procedure
ttdummy (1, 1);
select * from my_locks order by 1;
! relname | max_lockmode
! -----------+---------------------
! alterlock | AccessExclusiveLock
(1 row)
rollback;
--- 1935,1943 ----
execute procedure
ttdummy (1, 1);
select * from my_locks order by 1;
! relname | max_lockmode
! -----------+--------------
! alterlock | ShareLock
(1 row)
rollback;
*************** alter table alterlock2 add foreign key (
*** 1951,1957 ****
select * from my_locks order by 1;
relname | max_lockmode
-----------------+---------------------
! alterlock | AccessExclusiveLock
alterlock2 | AccessExclusiveLock
alterlock2_pkey | AccessShareLock
alterlock_pkey | AccessShareLock
--- 1951,1957 ----
select * from my_locks order by 1;
relname | max_lockmode
-----------------+---------------------
! alterlock | ShareLock
alterlock2 | AccessExclusiveLock
alterlock2_pkey | AccessShareLock
alterlock_pkey | AccessShareLock
*************** add constraint alterlock2nv foreign key
*** 1964,1970 ****
select * from my_locks order by 1;
relname | max_lockmode
------------+---------------------
! alterlock | AccessExclusiveLock
alterlock2 | AccessExclusiveLock
(2 rows)
--- 1964,1970 ----
select * from my_locks order by 1;
relname | max_lockmode
------------+---------------------
! alterlock | ShareLock
alterlock2 | AccessExclusiveLock
(2 rows)
Re: Reducing lock strength of adding foreign keys
Andreas Karlsson <andreas@proxel.se> writes:
I have attached a proof of concept
patch which reduces the lock strength to ShareLock.
You're kidding, right? ShareLock isn't even self-exclusive.
regards, tom lane
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
On 10/22/2014 04:13 PM, Tom Lane wrote:
Andreas Karlsson <andreas@proxel.se> writes:
I have attached a proof of concept
patch which reduces the lock strength to ShareLock.You're kidding, right? ShareLock isn't even self-exclusive.
Why would it have to be self-exclusive? As far as I know we only need to
ensure that nobody changes the rows while we add the trigger. Adding
multiple triggers concurrently should not pose a problem unless I am
missing something (which I probably am).
Andreas
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
On Wed, Oct 22, 2014 at 3:06 AM, Andreas Karlsson <andreas@proxel.se> wrote:
I have been thinking about why we need to grab an AccessExclusiveLock on the
table with the PK when we add a foreign key. Adding new tables with foreign
keys to old ones is common so it would be really nice if the lock strength
could be reduced.A comment in the code claims that we need to lock so no rows are deleted
under us and that adding a trigger will lock in AccessExclusive anyway. But
with MVCC catalog access and the removal of SnapshotNow I do not see why
adding a trigger would require an exclusive lock. Just locking for data
changes should be enough.
The use of MVCC catalog access doesn't necessarily mean that adding a
trigger doesn't require an AccessExclusive lock. Those changes - if I
dare to say so myself - solved a complex and important problem, but
only one of many problems in this area, and people seem prone to
thinking that they solved more problems than they in fact did.
I think instead of focusing on foreign keys, we should rewind a bit
and think about the locking level required to add a trigger. If we
figure something out there, then we can consider how it affects
foreign keys. I went looking for previous discussions of remaining
hazards and found these postings:
/messages/by-id/CA+TgmoY4GLsXZk0tAO29-LJtcuj0SL1xWCwQ51xb-HFYsgi5RQ@mail.gmail.com
/messages/by-id/20893.1393892127@sss.pgh.pa.us
/messages/by-id/20140306224340.GA3551655@tornado.leadboat.com
As far as triggers are concerned, the issue of skew between the
transaction snapshot and what the ruleutils.c snapshots do seems to be
the principal issue. Commit e5550d5fec66aa74caad1f79b79826ec64898688
changed pg_get_constraintdef() to use an MVCC snapshot rather than a
current MVCC snapshot; if that change is safe, I am not aware of any
reason why we couldn't change pg_get_triggerdef() similarly. Barring
further hazards I haven't thought of, I would expect that we could add
a trigger to a relation with only ShareRowExclusiveLock. Anything
less than ShareRowExclusiveLock would open up strange timing races
around the firing of triggers by transactions writing the table: they
might or might not notice that a trigger had been added before
end-of-transaction, depending on the timing of cache flushes, which
certainly seems no good. But even RowExclusiveLock seems like a large
improvement over AccessExclusiveLock.
When a constraint trigger - which is used to implement a foreign key -
is added, there are actually TWO tables involved: the table upon which
the trigger will actually fire, and some other table which is
mentioned in passing in the trigger definition. It's possible that
the locking requirements for the secondary table are weaker since I
don't think the presence of the trigger actually affects runtime
behavior there. However, there's probably little point in try to
weaken the lock to less than the level required for the main table
because a foreign key involves adding referential integrity triggers
to both tables.
So I tentatively propose (and with due regard for the possibility
others may see dangers that I've missed) that a reasonable goal would
be to lower the lock strength required for both CREATE TRIGGER and ADD
FOREIGN KEY from AccessExclusiveLock to ShareRowExclusiveLock,
allowing concurrent SELECT and SELECT FOR SHARE against the tables,
but not any actual write operations.
--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
On Fri, Oct 24, 2014 at 12:07:42PM -0400, Robert Haas wrote:
I think instead of focusing on foreign keys, we should rewind a bit
and think about the locking level required to add a trigger.
Agreed.
/messages/by-id/CA+TgmoY4GLsXZk0tAO29-LJtcuj0SL1xWCwQ51xb-HFYsgi5RQ@mail.gmail.com
/messages/by-id/20893.1393892127@sss.pgh.pa.us
/messages/by-id/20140306224340.GA3551655@tornado.leadboat.comAs far as triggers are concerned, the issue of skew between the
transaction snapshot and what the ruleutils.c snapshots do seems to be
the principal issue. Commit e5550d5fec66aa74caad1f79b79826ec64898688
changed pg_get_constraintdef() to use an MVCC snapshot rather than a
current MVCC snapshot; if that change is safe, I am not aware of any
reason why we couldn't change pg_get_triggerdef() similarly.
pg_get_triggerdef() is fine as-is with concurrent CREATE TRIGGER. The
pg_get_constraintdef() change arose to ensure a consistent result when
concurrent ALTER TABLE VALIDATE CONSTRAINT mutates a constraint definition.
(Reducing the lock level of DROP TRIGGER or ALTER TRIGGER, however, would
create the analogous problem for pg_get_triggerdef().)
So I tentatively propose (and with due regard for the possibility
others may see dangers that I've missed) that a reasonable goal would
be to lower the lock strength required for both CREATE TRIGGER and ADD
FOREIGN KEY from AccessExclusiveLock to ShareRowExclusiveLock,
allowing concurrent SELECT and SELECT FOR SHARE against the tables,
but not any actual write operations.
+1
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
On 10/24/2014 06:07 PM, Robert Haas wrote:
I think instead of focusing on foreign keys, we should rewind a bit
and think about the locking level required to add a trigger.
Agreed.
As far as triggers are concerned, the issue of skew between the
transaction snapshot and what the ruleutils.c snapshots do seems to be
the principal issue. Commit e5550d5fec66aa74caad1f79b79826ec64898688
changed pg_get_constraintdef() to use an MVCC snapshot rather than a
current MVCC snapshot; if that change is safe, I am not aware of any
reason why we couldn't change pg_get_triggerdef() similarly. Barring
further hazards I haven't thought of, I would expect that we could add
a trigger to a relation with only ShareRowExclusiveLock.
Thanks for the info. This is just the kind of issues I was worrying about.
Anything
less than ShareRowExclusiveLock would open up strange timing races
around the firing of triggers by transactions writing the table: they
might or might not notice that a trigger had been added before
end-of-transaction, depending on the timing of cache flushes, which
certainly seems no good. But even RowExclusiveLock seems like a large
improvement over AccessExclusiveLock.
Would not ShareLock give the same result, except for also allowing
concurrent CREATE INDEX and concurrent other CREATE TRIGGER which does
not look dangerous to me?
From a user point of view ShareRowExclusiveLock should be as useful as
ShareLock.
When a constraint trigger - which is used to implement a foreign key -
is added, there are actually TWO tables involved: the table upon which
the trigger will actually fire, and some other table which is
mentioned in passing in the trigger definition. It's possible that
the locking requirements for the secondary table are weaker since I
don't think the presence of the trigger actually affects runtime
behavior there. However, there's probably little point in try to
weaken the lock to less than the level required for the main table
because a foreign key involves adding referential integrity triggers
to both tables.So I tentatively propose (and with due regard for the possibility
others may see dangers that I've missed) that a reasonable goal would
be to lower the lock strength required for both CREATE TRIGGER and ADD
FOREIGN KEY from AccessExclusiveLock to ShareRowExclusiveLock,
allowing concurrent SELECT and SELECT FOR SHARE against the tables,
but not any actual write operations.
Agreed.. But I think reducing the lock level of the secondary table is
much more important than doing the same for the primary table due to the
case where the secondary table is an existing table which is hit by a
workload of long running queries and DML while the primary is a new
table which is added now. In my dream world I could add the new table
without any disruption at all of queries using the secondary table, no
matter the duration of the transaction adding the table (barring
insertion of actual data into the primary table, which would take row
locks).
This is just a dream scenario though, and focusing on triggers is indeed
the reasonable goal for 9.5.
--
Andreas Karlsson
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
There are actually TWO tables involved: the table upon which
the trigger will actually fire, and some other table which is
mentioned in passing in the trigger definition. It's possible that
the locking requirements for the secondary table are weaker since I
don't think the presence of the trigger actually affects runtime
behavior there. However, there's probably little point in try to
weaken the lock to less than the level required for the main table
because a foreign key involves adding referential integrity triggers
to both tables.
-----
GUL
--
View this message in context: http://postgresql.1045698.n5.nabble.com/Reducing-lock-strength-of-adding-foreign-keys-tp5823894p5824376.html
Sent from the PostgreSQL - hackers mailing list archive at Nabble.com.
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
Thanks for weighing in, Noah.
On Sat, Oct 25, 2014 at 2:00 PM, Noah Misch <noah@leadboat.com> wrote:
/messages/by-id/CA+TgmoY4GLsXZk0tAO29-LJtcuj0SL1xWCwQ51xb-HFYsgi5RQ@mail.gmail.com
/messages/by-id/20893.1393892127@sss.pgh.pa.us
/messages/by-id/20140306224340.GA3551655@tornado.leadboat.comAs far as triggers are concerned, the issue of skew between the
transaction snapshot and what the ruleutils.c snapshots do seems to be
the principal issue. Commit e5550d5fec66aa74caad1f79b79826ec64898688
changed pg_get_constraintdef() to use an MVCC snapshot rather than a
current MVCC snapshot; if that change is safe, I am not aware of any
reason why we couldn't change pg_get_triggerdef() similarly.pg_get_triggerdef() is fine as-is with concurrent CREATE TRIGGER. The
pg_get_constraintdef() change arose to ensure a consistent result when
concurrent ALTER TABLE VALIDATE CONSTRAINT mutates a constraint definition.
(Reducing the lock level of DROP TRIGGER or ALTER TRIGGER, however, would
create the analogous problem for pg_get_triggerdef().)
Maybe so, but I'd favor changing it anyway and getting it over with.
The current situation seems to have little to recommend it; moreover,
it would be nice, if it's possible and safe, to weaken the lock levels
for all three of those commands at the same time. Do you see any
hazards for ALTER or DROP that do not exist for CREATE?
--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
On Sun, Oct 26, 2014 at 9:48 PM, Andreas Karlsson <andreas@proxel.se> wrote:
Agreed.. But I think reducing the lock level of the secondary table is much
more important than doing the same for the primary table due to the case
where the secondary table is an existing table which is hit by a workload of
long running queries and DML while the primary is a new table which is added
now. In my dream world I could add the new table without any disruption at
all of queries using the secondary table, no matter the duration of the
transaction adding the table (barring insertion of actual data into the
primary table, which would take row locks).
That would indeed be nice, but it doesn't seem very practical, because
the parent needs triggers, too: if you try to delete a row from the
parent, or update the key, it's got to go look at the child and see
whether there are rows against the old value. Then it's got to either
update those rows, or null out the value, or throw an error.
Regardless of which of those things it does (which depends on the ON
DELETE and ON UPDATE settings you choose), it's hard to imagine that
it would be a good idea for any of those things to start happening in
the middle of a transaction or statement.
So, let's take what we can get. :-)
--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
On Mon, Oct 27, 2014 at 08:24:15AM -0400, Robert Haas wrote:
On Sat, Oct 25, 2014 at 2:00 PM, Noah Misch <noah@leadboat.com> wrote:
/messages/by-id/CA+TgmoY4GLsXZk0tAO29-LJtcuj0SL1xWCwQ51xb-HFYsgi5RQ@mail.gmail.com
/messages/by-id/20893.1393892127@sss.pgh.pa.us
/messages/by-id/20140306224340.GA3551655@tornado.leadboat.comAs far as triggers are concerned, the issue of skew between the
transaction snapshot and what the ruleutils.c snapshots do seems to be
the principal issue. Commit e5550d5fec66aa74caad1f79b79826ec64898688
changed pg_get_constraintdef() to use an MVCC snapshot rather than a
current MVCC snapshot; if that change is safe, I am not aware of any
reason why we couldn't change pg_get_triggerdef() similarly.pg_get_triggerdef() is fine as-is with concurrent CREATE TRIGGER. The
pg_get_constraintdef() change arose to ensure a consistent result when
concurrent ALTER TABLE VALIDATE CONSTRAINT mutates a constraint definition.
(Reducing the lock level of DROP TRIGGER or ALTER TRIGGER, however, would
create the analogous problem for pg_get_triggerdef().)Maybe so, but I'd favor changing it anyway and getting it over with.
The current situation seems to have little to recommend it; moreover,
it would be nice, if it's possible and safe, to weaken the lock levels
for all three of those commands at the same time. Do you see any
hazards for ALTER or DROP that do not exist for CREATE?
ALTER TRIGGER is not bad; like you say, change pg_get_triggerdef_worker() the
way commit e5550d5 changed pg_get_constraintdef_worker(). DROP TRIGGER is
more difficult. pg_constraint.tgqual of a dropped trigger may reference other
dropped objects, which calls for equipping get_rule_expr() to use the
transaction snapshot. That implicates quite a bit of ruleutils.c code.
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
On 10/28/2014 01:33 AM, Noah Misch wrote:
ALTER TRIGGER is not bad; like you say, change pg_get_triggerdef_worker() the
way commit e5550d5 changed pg_get_constraintdef_worker(). DROP TRIGGER is
more difficult. pg_constraint.tgqual of a dropped trigger may reference other
dropped objects, which calls for equipping get_rule_expr() to use the
transaction snapshot. That implicates quite a bit of ruleutils.c code.
I started looking into this again and fixed
pg_get_constraintdef_worker() as suggested.
But I have no idea how to fix get_rule_expr() since it relies on doing
lookups in the catcache. Replacing these with uncached lookups sounds
like it could cause quite some slowdown. Any ideas?
Indexes should suffer from the same problems since they too have emay
contain expressions but they seem to solve this by having a higher lock
level on DROP INDEX, but I do wonder about the CONCURRENTLY case.
By the way, unless I am mistaken there is currently no protection
against having a concurrent ALTER FUNCTION ... RENAME mess up what is
dumped in by pg_get_triggerdef().
--
Andreas Karlsson
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
PATCH: Reducing lock strength of trigger and foreign key DDL
Hi,
I have attached a patch with the current status of my work on reducing
the lock level of trigger and foreign key related DDL.
This commit reduces the lock level of the following commands from ACCESS
EXCLUSIVE to SHARE ROW EXCLUSIVE, plus that it does the same for the
referred table of the foreign key.
ADD TRIGGER
ALTER TRIGGER
ALTER TABLE ... ADD FOREIGN KEY
ALTER TABLE ... DISABLE TRIGGER
ALTER TABLE ... ENABLE TRIGGER
The patch does currently not reducing the lock level of the following
two commands, but I think it would be really nice to fix those too and
here I would like some feedback and ideas.
DROP TRIGGER
ALTER TABLE ... DROP CONSTRAINT -- For foreign keys
Foreign keys and triggers are fixed at the same time because foreign
keys are implemented with two triggers, one at each of the involved tables.
The idea behind the patch is that since we started using MVCC snapshots
we no longer need to hold an exclusive lock on the table when adding a
trigger. Theoretically we only need to lock out writers of the rows of
the table (SHARE ROW EXCLUSIVE/SHARE), but as noted by Robert and Noah
just reducing the lock level will break pg_dump since
pg_get_triggerdef() does not use the current snapshot when reading the
catalog.
I have fixed pg_get_triggerdef() to use the snapshot like how
e5550d5fec66aa74caad1f79b79826ec64898688 fixed pg_get_constraintdef(),
and this fixes the code for the ALTER TRIGGER case (ADD TRIGGER was
already safe). But to fix it for the DROP TRIGGER case we need to also
make the dumping of the WHEN clause (which is dumped by get_rule_expr())
use the current snapshot.
get_rule_expr() relies heavily on the catcache which to me does not look
like it could easily be (and probably not even should be) made to use
the current snapshot. Refactoring ruleutils.c to rely less no the
catcache seems like a reasonable thing to do if we want to reduce
weirdness of how it ignores MVCC but it is quite a bit of work and I
fear it could give us performance regressions.
Do you have any ideas for how to fix get_rule_expr()? Is this patch
worthwhile even without reducing the lock levels of the drop commands?
Andreas
Attachments:
add-fk-lock-strength-v2.patchtext/x-patch; name=add-fk-lock-strength-v2.patchDownload
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 1e737a0..ece6ed5 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -2862,13 +2862,8 @@ AlterTableGetLockLevel(List *cmds)
break;
/*
- * These subcommands affect write operations only. XXX
- * Theoretically, these could be ShareRowExclusiveLock.
+ * These subcommands affect write operations only.
*/
- case AT_ColumnDefault:
- case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
- case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
- case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_EnableTrig:
case AT_EnableAlwaysTrig:
case AT_EnableReplicaTrig:
@@ -2877,6 +2872,17 @@ AlterTableGetLockLevel(List *cmds)
case AT_DisableTrig:
case AT_DisableTrigAll:
case AT_DisableTrigUser:
+ cmd_lockmode = ShareRowExclusiveLock;
+ break;
+
+ /*
+ * These subcommands affect write operations only. XXX
+ * Theoretically, these could be ShareRowExclusiveLock.
+ */
+ case AT_ColumnDefault:
+ case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
+ case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
+ case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_AlterConstraint:
case AT_AddIndex: /* from ADD CONSTRAINT */
case AT_AddIndexConstraint:
@@ -2913,11 +2919,9 @@ AlterTableGetLockLevel(List *cmds)
/*
* We add triggers to both tables when we add a
* Foreign Key, so the lock level must be at least
- * as strong as CREATE TRIGGER. XXX Might be set
- * down to ShareRowExclusiveLock though trigger
- * info is accessed by pg_get_triggerdef
+ * as strong as CREATE TRIGGER.
*/
- cmd_lockmode = AccessExclusiveLock;
+ cmd_lockmode = ShareRowExclusiveLock;
break;
default:
@@ -6034,16 +6038,13 @@ ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
ListCell *old_pfeqop_item = list_head(fkconstraint->old_conpfeqop);
/*
- * Grab an exclusive lock on the pk table, so that someone doesn't delete
- * rows out from under us. (Although a lesser lock would do for that
- * purpose, we'll need exclusive lock anyway to add triggers to the pk
- * table; trying to start with a lesser lock will just create a risk of
- * deadlock.)
+ * Grab an share lock on the pk table, so that someone doesn't delete
+ * rows out from under us.
*/
if (OidIsValid(fkconstraint->old_pktable_oid))
- pkrel = heap_open(fkconstraint->old_pktable_oid, AccessExclusiveLock);
+ pkrel = heap_open(fkconstraint->old_pktable_oid, ShareRowExclusiveLock);
else
- pkrel = heap_openrv(fkconstraint->pktable, AccessExclusiveLock);
+ pkrel = heap_openrv(fkconstraint->pktable, ShareRowExclusiveLock);
/*
* Validity checks (permission checks wait till we have the column
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index ebccfea..b2d5a52 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -158,9 +158,9 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
referenced;
if (OidIsValid(relOid))
- rel = heap_open(relOid, AccessExclusiveLock);
+ rel = heap_open(relOid, ShareRowExclusiveLock);
else
- rel = heap_openrv(stmt->relation, AccessExclusiveLock);
+ rel = heap_openrv(stmt->relation, ShareRowExclusiveLock);
/*
* Triggers must be on tables or views, and there are additional
@@ -526,8 +526,7 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
* can skip this for internally generated triggers, since the name
* modification above should be sufficient.
*
- * NOTE that this is cool only because we have AccessExclusiveLock on the
- * relation, so the trigger set won't be changing underneath us.
+ * NOTE that this is cool only because of the unique contraint.
*/
if (!isInternal)
{
@@ -1258,7 +1257,7 @@ renametrig(RenameStmt *stmt)
* Look up name, check permissions, and acquire lock (which we will NOT
* release until end of transaction).
*/
- relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
+ relid = RangeVarGetRelidExtended(stmt->relation, ShareRowExclusiveLock,
false, false,
RangeVarCallbackForRenameTrigger,
NULL);
@@ -1272,8 +1271,7 @@ renametrig(RenameStmt *stmt)
* on tgrelid/tgname would complain anyway) and to ensure a trigger does
* exist with oldname.
*
- * NOTE that this is cool only because we have AccessExclusiveLock on the
- * relation, so the trigger set won't be changing underneath us.
+ * NOTE that this is cool only because there is a unique constraint.
*/
tgrel = heap_open(TriggerRelationId, RowExclusiveLock);
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 24ade6c..4deb9c2 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -699,7 +699,8 @@ pg_get_triggerdef_worker(Oid trigid, bool pretty)
HeapTuple ht_trig;
Form_pg_trigger trigrec;
StringInfoData buf;
- Relation tgrel;
+ Snapshot snapshot = RegisterSnapshot(GetTransactionSnapshot());
+ Relation tgrel = heap_open(TriggerRelationId, AccessShareLock);
ScanKeyData skey[1];
SysScanDesc tgscan;
int findx = 0;
@@ -710,18 +711,18 @@ pg_get_triggerdef_worker(Oid trigid, bool pretty)
/*
* Fetch the pg_trigger tuple by the Oid of the trigger
*/
- tgrel = heap_open(TriggerRelationId, AccessShareLock);
-
ScanKeyInit(&skey[0],
ObjectIdAttributeNumber,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(trigid));
tgscan = systable_beginscan(tgrel, TriggerOidIndexId, true,
- NULL, 1, skey);
+ snapshot, 1, skey);
ht_trig = systable_getnext(tgscan);
+ UnregisterSnapshot(snapshot);
+
if (!HeapTupleIsValid(ht_trig))
elog(ERROR, "could not find tuple for trigger %u", trigid);
diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out
index d233710..1f7c265 100644
--- a/src/test/regress/expected/alter_table.out
+++ b/src/test/regress/expected/alter_table.out
@@ -1952,9 +1952,9 @@ create trigger ttdummy
execute procedure
ttdummy (1, 1);
select * from my_locks order by 1;
- relname | max_lockmode
------------+---------------------
- alterlock | AccessExclusiveLock
+ relname | max_lockmode
+-----------+-----------------------
+ alterlock | ShareRowExclusiveLock
(1 row)
rollback;
@@ -1966,10 +1966,10 @@ select * from my_locks order by 1;
alter table alterlock2 add foreign key (f1) references alterlock (f1);
select * from my_locks order by 1;
- relname | max_lockmode
------------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+-----------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
alterlock2_pkey | AccessShareLock
alterlock_pkey | AccessShareLock
(4 rows)
@@ -1979,10 +1979,10 @@ begin;
alter table alterlock2
add constraint alterlock2nv foreign key (f1) references alterlock (f1) NOT VALID;
select * from my_locks order by 1;
- relname | max_lockmode
-------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
(2 rows)
commit;
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
I'm not sure about the rest of this but...
On Sat, Dec 13, 2014 at 3:45 PM, Andreas Karlsson <andreas@proxel.se> wrote:
Is this patch
worthwhile even without reducing the lock levels of the drop commands?
Yes! It certainly makes more sense to reduce the lock levels where we
can do that relatively easily, and postpone work on related projects
that are harder, rather than waiting until it all seems to work before
doing anything at all.
--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
On 25 October 2014 19:00, Noah Misch <noah@leadboat.com> wrote:
So I tentatively propose (and with due regard for the possibility
others may see dangers that I've missed) that a reasonable goal would
be to lower the lock strength required for both CREATE TRIGGER and ADD
FOREIGN KEY from AccessExclusiveLock to ShareRowExclusiveLock,
allowing concurrent SELECT and SELECT FOR SHARE against the tables,
but not any actual write operations.+1
All of this is just a replay of the earlier conversations about
reducing lock levels.
My original patch did reduce lock levels for CREATE TRIGGER, but we
stepped back from doing that in 9.4 until we had feedback as to
whether the whole idea of reducing lock levels was safe, which Robert,
Tom and others were slightly uncertain about.
Is there anything different here from work in my original patch series?
--
Simon Riggs http://www.2ndQuadrant.com/
PostgreSQL Development, 24x7 Support, Training & Services
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
On Wed, Dec 17, 2014 at 02:41:39PM +0000, Simon Riggs wrote:
Is there anything different here from work in my original patch series?
Not to my knowledge.
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: Reducing lock strength of adding foreign keys
On 12/17/2014 03:41 PM, Simon Riggs wrote:
All of this is just a replay of the earlier conversations about
reducing lock levels.My original patch did reduce lock levels for CREATE TRIGGER, but we
stepped back from doing that in 9.4 until we had feedback as to
whether the whole idea of reducing lock levels was safe, which Robert,
Tom and others were slightly uncertain about.Is there anything different here from work in my original patch series?
As far as I know, no.
--
Andreas Karlsson
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On Sun, Dec 14, 2014 at 5:45 AM, Andreas Karlsson <andreas@proxel.se> wrote:
get_rule_expr() relies heavily on the catcache which to me does not look
like it could easily be (and probably not even should be) made to use the
current snapshot. Refactoring ruleutils.c to rely less no the catcache seems
like a reasonable thing to do if we want to reduce weirdness of how it
ignores MVCC but it is quite a bit of work and I fear it could give us
performance regressions.
Do you have any ideas for how to fix get_rule_expr()?
Agreed. There are 20 calls to SearchSysCache in ruleutils.c, let's not
focus on that for now though and get things right for this patch.
Is this patch worthwhile even without reducing the lock levels of the drop commands?
Yes. IMV, it is better to do this work slowly and incrementally.
Here are some comments about this patch:
1) There is no documentation. Could you update mvcc.sgml for SHARE ROW
EXCLUSIVE?
2) Some isolation tests would be welcome, the point of the feature is
to test if SELECT and SELECT FOR SHARE/UPDATE are allowed while
running one of the command mentioned above.
3) This patch breaks the isolation test alter-table-1.
Regards,
--
Michael
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
Thanks for the review.
Here is a new version of the patch with updated isolation tests and
documentation.
--
Andreas Karlsson
Attachments:
add-fk-lock-strength-v3.patchtext/x-patch; name=add-fk-lock-strength-v3.patchDownload
diff --git a/doc/src/sgml/mvcc.sgml b/doc/src/sgml/mvcc.sgml
index a0d6867..459e86d 100644
--- a/doc/src/sgml/mvcc.sgml
+++ b/doc/src/sgml/mvcc.sgml
@@ -908,9 +908,10 @@ ERROR: could not serialize access due to read/write dependencies among transact
</para>
<para>
- This lock mode is not automatically acquired by any
- <productname>PostgreSQL</productname> command.
- </para>
+ Acquired by <command>CREATE TRIGGER</command>, <command>ALTER
+ TRIGGER</command>, <command>ALTER TABLE ADD FOREIGN KEY</command>,
+ and <command>ALTER TABLE ENABLE/DISABLE TRIGGER</command>.
+ </para>>
</listitem>
</varlistentry>
diff --git a/doc/src/sgml/ref/alter_table.sgml b/doc/src/sgml/ref/alter_table.sgml
index b5ef09e..0185e39 100644
--- a/doc/src/sgml/ref/alter_table.sgml
+++ b/doc/src/sgml/ref/alter_table.sgml
@@ -405,6 +405,9 @@ ALTER TABLE ALL IN TABLESPACE <replaceable class="PARAMETER">name</replaceable>
mode, and triggers configured as <literal>ENABLE ALWAYS</literal> will
fire regardless of the current replication mode.
</para>
+ <para>
+ Enabling and disabling triggers acquires a <literal>SHARE ROW EXCLUSIVE</literal> lock.
+ </para>
</listitem>
</varlistentry>
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 66d5083..5c3ef1d 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -2858,13 +2858,8 @@ AlterTableGetLockLevel(List *cmds)
break;
/*
- * These subcommands affect write operations only. XXX
- * Theoretically, these could be ShareRowExclusiveLock.
+ * These subcommands affect write operations only.
*/
- case AT_ColumnDefault:
- case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
- case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
- case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_EnableTrig:
case AT_EnableAlwaysTrig:
case AT_EnableReplicaTrig:
@@ -2873,6 +2868,17 @@ AlterTableGetLockLevel(List *cmds)
case AT_DisableTrig:
case AT_DisableTrigAll:
case AT_DisableTrigUser:
+ cmd_lockmode = ShareRowExclusiveLock;
+ break;
+
+ /*
+ * These subcommands affect write operations only. XXX
+ * Theoretically, these could be ShareRowExclusiveLock.
+ */
+ case AT_ColumnDefault:
+ case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
+ case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
+ case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_AlterConstraint:
case AT_AddIndex: /* from ADD CONSTRAINT */
case AT_AddIndexConstraint:
@@ -2909,11 +2915,9 @@ AlterTableGetLockLevel(List *cmds)
/*
* We add triggers to both tables when we add a
* Foreign Key, so the lock level must be at least
- * as strong as CREATE TRIGGER. XXX Might be set
- * down to ShareRowExclusiveLock though trigger
- * info is accessed by pg_get_triggerdef
+ * as strong as CREATE TRIGGER.
*/
- cmd_lockmode = AccessExclusiveLock;
+ cmd_lockmode = ShareRowExclusiveLock;
break;
default:
@@ -6030,16 +6034,13 @@ ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
ListCell *old_pfeqop_item = list_head(fkconstraint->old_conpfeqop);
/*
- * Grab an exclusive lock on the pk table, so that someone doesn't delete
- * rows out from under us. (Although a lesser lock would do for that
- * purpose, we'll need exclusive lock anyway to add triggers to the pk
- * table; trying to start with a lesser lock will just create a risk of
- * deadlock.)
+ * Grab an share lock on the pk table, so that someone doesn't delete
+ * rows out from under us.
*/
if (OidIsValid(fkconstraint->old_pktable_oid))
- pkrel = heap_open(fkconstraint->old_pktable_oid, AccessExclusiveLock);
+ pkrel = heap_open(fkconstraint->old_pktable_oid, ShareRowExclusiveLock);
else
- pkrel = heap_openrv(fkconstraint->pktable, AccessExclusiveLock);
+ pkrel = heap_openrv(fkconstraint->pktable, ShareRowExclusiveLock);
/*
* Validity checks (permission checks wait till we have the column
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 4899a27..33f8448 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -158,9 +158,9 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
referenced;
if (OidIsValid(relOid))
- rel = heap_open(relOid, AccessExclusiveLock);
+ rel = heap_open(relOid, ShareRowExclusiveLock);
else
- rel = heap_openrv(stmt->relation, AccessExclusiveLock);
+ rel = heap_openrv(stmt->relation, ShareRowExclusiveLock);
/*
* Triggers must be on tables or views, and there are additional
@@ -526,8 +526,7 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
* can skip this for internally generated triggers, since the name
* modification above should be sufficient.
*
- * NOTE that this is cool only because we have AccessExclusiveLock on the
- * relation, so the trigger set won't be changing underneath us.
+ * NOTE that this is cool only because of the unique contraint.
*/
if (!isInternal)
{
@@ -1103,7 +1102,7 @@ RemoveTriggerById(Oid trigOid)
*/
relid = ((Form_pg_trigger) GETSTRUCT(tup))->tgrelid;
- rel = heap_open(relid, AccessExclusiveLock);
+ rel = heap_open(relid, ShareRowExclusiveLock);
if (rel->rd_rel->relkind != RELKIND_RELATION &&
rel->rd_rel->relkind != RELKIND_VIEW &&
@@ -1258,7 +1257,7 @@ renametrig(RenameStmt *stmt)
* Look up name, check permissions, and acquire lock (which we will NOT
* release until end of transaction).
*/
- relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
+ relid = RangeVarGetRelidExtended(stmt->relation, ShareRowExclusiveLock,
false, false,
RangeVarCallbackForRenameTrigger,
NULL);
@@ -1272,8 +1271,7 @@ renametrig(RenameStmt *stmt)
* on tgrelid/tgname would complain anyway) and to ensure a trigger does
* exist with oldname.
*
- * NOTE that this is cool only because we have AccessExclusiveLock on the
- * relation, so the trigger set won't be changing underneath us.
+ * NOTE that this is cool only because there is a unique constraint.
*/
tgrel = heap_open(TriggerRelationId, RowExclusiveLock);
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index dd748ac..8eeccf2 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -699,7 +699,8 @@ pg_get_triggerdef_worker(Oid trigid, bool pretty)
HeapTuple ht_trig;
Form_pg_trigger trigrec;
StringInfoData buf;
- Relation tgrel;
+ Snapshot snapshot = RegisterSnapshot(GetTransactionSnapshot());
+ Relation tgrel = heap_open(TriggerRelationId, AccessShareLock);
ScanKeyData skey[1];
SysScanDesc tgscan;
int findx = 0;
@@ -710,18 +711,18 @@ pg_get_triggerdef_worker(Oid trigid, bool pretty)
/*
* Fetch the pg_trigger tuple by the Oid of the trigger
*/
- tgrel = heap_open(TriggerRelationId, AccessShareLock);
-
ScanKeyInit(&skey[0],
ObjectIdAttributeNumber,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(trigid));
tgscan = systable_beginscan(tgrel, TriggerOidIndexId, true,
- NULL, 1, skey);
+ snapshot, 1, skey);
ht_trig = systable_getnext(tgscan);
+ UnregisterSnapshot(snapshot);
+
if (!HeapTupleIsValid(ht_trig))
elog(ERROR, "could not find tuple for trigger %u", trigid);
diff --git a/src/test/isolation/expected/alter-table-1.out b/src/test/isolation/expected/alter-table-1.out
index edf7288..9daa418 100644
--- a/src/test/isolation/expected/alter-table-1.out
+++ b/src/test/isolation/expected/alter-table-1.out
@@ -703,12 +703,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 sc2 wx rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
@@ -724,12 +723,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -745,12 +743,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -766,12 +763,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -787,12 +783,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -808,12 +803,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -829,12 +823,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -850,12 +843,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -871,12 +863,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -892,12 +883,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -913,12 +903,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -934,12 +923,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -955,12 +943,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -976,12 +963,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -997,12 +983,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -1018,12 +1003,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -1039,12 +1023,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1060,12 +1043,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1081,12 +1063,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1102,12 +1083,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 c2 s2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1123,137 +1103,362 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 sc2 c2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 c2 sc2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 c2 at2 sc2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 at1 rx1 wx rx1 c2 sc1 s2 at2 sc2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 at1 sc1 s2 at2 sc2 wx rx1 c2
-step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx sc2 rx1 c2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 sc2 c2
+starting permutation: s1 at1 rx1 wx rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 c2 sc2
+starting permutation: s1 at1 rx1 wx rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx1 c2
+starting permutation: s1 rx1 at1 sc1 s2 at2 sc2 wx rx1 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx1 sc2 c2
step s1: BEGIN;
@@ -1261,8 +1466,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx1 c2 sc2
step s1: BEGIN;
@@ -1270,8 +1486,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 at2 sc2 c2
step s1: BEGIN;
@@ -1279,8 +1506,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 at2 c2 sc2
step s1: BEGIN;
@@ -1288,8 +1526,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 c2 at2 sc2
step s1: BEGIN;
@@ -1297,8 +1546,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 wx s2 at2 sc2 rx1 c2
step s1: BEGIN;
@@ -1306,8 +1566,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 sc2 c2
step s1: BEGIN;
@@ -1315,189 +1586,548 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 c2 s2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 sc2 c2
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 c2 sc2
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 c2 at2 sc2
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 c2 sc2
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 at1 wx rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 c2 s2 at2 sc2
+starting permutation: s1 rx1 at1 wx rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx1 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 sc2 rx1 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 c2 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1506,14 +2136,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1522,14 +2152,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1538,14 +2168,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 c2 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1554,14 +2184,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 c2 sc1 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1575,197 +2205,181 @@ step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 sc2 rx1 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
-a_id
-
-1
-step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 sc2 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
-a_id
-
-1
-step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 sc2 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 c2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 c2 at2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 c2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 rx1 c2 s2 at2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx rx1 at1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step c2: COMMIT;
+step at1: <... completed>
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx rx1 c2 at1 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 c2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step sc2: COMMIT;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 c2 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
-step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 sc2 c2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1773,63 +2387,78 @@ a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 c2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 c2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 c2 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1837,20 +2466,19 @@ a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 c2 at1 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1858,174 +2486,189 @@ a_id
3
3
3
-step c2: COMMIT;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step sc1: COMMIT;
-step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx1 c2
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx1 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 sc2 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 c2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx1 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 c2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx1 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 c2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 sc2 c2
+starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 c2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 sc1 wx rx1 s2 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2033,8 +2676,19 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 sc1 wx rx1 c2 s2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2042,8 +2696,19 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2051,9 +2716,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2061,9 +2737,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2071,9 +2758,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2081,9 +2779,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2091,9 +2800,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2101,9 +2821,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2111,9 +2842,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2121,9 +2863,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2131,50 +2884,60 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 wx sc1 rx1 c2 s2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 sc2 c2
+starting permutation: rx1 s1 at1 wx sc1 rx1 c2 s2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 c2 sc2
+starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 c2 sc2
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
-3
-3
-3
+1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 sc1 s2 c2 at2 sc2
@@ -2183,14 +2946,8 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 sc1 c2 s2 at2 sc2
@@ -2199,14 +2956,8 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 c2 sc1 s2 at2 sc2
@@ -2215,20 +2966,9 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
-step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
-step sc2: COMMIT;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
starting permutation: rx1 s1 wx at1 sc1 s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
diff --git a/src/test/isolation/expected/alter-table-2.out b/src/test/isolation/expected/alter-table-2.out
new file mode 100644
index 0000000..679cf7b
--- /dev/null
+++ b/src/test/isolation/expected/alter-table-2.out
@@ -0,0 +1,305 @@
+Parsed test spec with 2 sessions
+
+starting permutation: at1 sc2 rx1 rx1 wx wx c
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc2: COMMIT;
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0);
+step wx: INSERT INTO a VALUES (4);
+step c: COMMIT;
+
+starting permutation: at1 rx1 sc2 rx1 wx wx c
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0);
+step wx: INSERT INTO a VALUES (4);
+step c: COMMIT;
+
+starting permutation: at1 rx1 rx1 sc2 wx wx c
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step sc2: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step wx: INSERT INTO a VALUES (4);
+step c: COMMIT;
+
+starting permutation: at1 rx1 rx1 wx sc2 wx c
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc2: COMMIT;
+step wx: <... completed>
+step wx: INSERT INTO a VALUES (4);
+step c: COMMIT;
+
+starting permutation: at1 rx1 rx1 wx wx sc2 c
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: at1 rx1 rx1 wx wx c sc2
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 at1 sc2 rx1 wx wx c
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0);
+step wx: INSERT INTO a VALUES (4);
+step c: COMMIT;
+
+starting permutation: rx1 at1 rx1 sc2 wx wx c
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step sc2: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step wx: INSERT INTO a VALUES (4);
+step c: COMMIT;
+
+starting permutation: rx1 at1 rx1 wx sc2 wx c
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc2: COMMIT;
+step wx: <... completed>
+step wx: INSERT INTO a VALUES (4);
+step c: COMMIT;
+
+starting permutation: rx1 at1 rx1 wx wx sc2 c
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 at1 rx1 wx wx c sc2
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 rx1 at1 sc2 wx wx c
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc2: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step wx: INSERT INTO a VALUES (4);
+step c: COMMIT;
+
+starting permutation: rx1 rx1 at1 wx sc2 wx c
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc2: COMMIT;
+step wx: <... completed>
+step wx: INSERT INTO a VALUES (4);
+step c: COMMIT;
+
+starting permutation: rx1 rx1 at1 wx wx sc2 c
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 rx1 at1 wx wx c sc2
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 rx1 wx at1 sc2 wx c
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 rx1 wx at1 wx sc2 c
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: rx1 rx1 wx at1 wx c sc2
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO a VALUES (4);
+step c: COMMIT;
+step at1: <... completed>
+step sc2: COMMIT;
+
+starting permutation: rx1 rx1 wx wx at1 sc2 c
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0);
+step wx: INSERT INTO a VALUES (4);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 rx1 wx wx at1 c sc2
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0);
+step wx: INSERT INTO a VALUES (4);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step c: COMMIT;
+step at1: <... completed>
+step sc2: COMMIT;
+
+starting permutation: rx1 rx1 wx wx c at1 sc2
+step rx1: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step wx: INSERT INTO b VALUES (0);
+step wx: INSERT INTO a VALUES (4);
+step c: COMMIT;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc2: COMMIT;
diff --git a/src/test/isolation/expected/create-trigger.out b/src/test/isolation/expected/create-trigger.out
new file mode 100644
index 0000000..eb13e36
--- /dev/null
+++ b/src/test/isolation/expected/create-trigger.out
@@ -0,0 +1,101 @@
+Parsed test spec with 2 sessions
+
+starting permutation: ct sc rx wx c
+step ct: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step sc: COMMIT;
+step rx: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step wx: UPDATE a SET i = 4 WHERE i = 3;
+step c: COMMIT;
+
+starting permutation: ct rx sc wx c
+step ct: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step rx: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step sc: COMMIT;
+step wx: UPDATE a SET i = 4 WHERE i = 3;
+step c: COMMIT;
+
+starting permutation: ct rx wx sc c
+step ct: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step rx: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step wx: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step sc: COMMIT;
+step wx: <... completed>
+step c: COMMIT;
+
+starting permutation: ct rx wx c sc
+step ct: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step rx: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step wx: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: rx ct sc wx c
+step rx: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step ct: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step sc: COMMIT;
+step wx: UPDATE a SET i = 4 WHERE i = 3;
+step c: COMMIT;
+
+starting permutation: rx ct wx sc c
+step rx: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step ct: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step wx: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step sc: COMMIT;
+step wx: <... completed>
+step c: COMMIT;
+
+starting permutation: rx ct wx c sc
+step rx: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step ct: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step wx: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: rx wx ct sc c
+step rx: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step wx: UPDATE a SET i = 4 WHERE i = 3;
+step ct: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: rx wx ct c sc
+step rx: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step wx: UPDATE a SET i = 4 WHERE i = 3;
+step ct: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step c: COMMIT;
+step ct: <... completed>
+step sc: COMMIT;
+
+starting permutation: rx wx c ct sc
+step rx: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step wx: UPDATE a SET i = 4 WHERE i = 3;
+step c: COMMIT;
+step ct: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step sc: COMMIT;
diff --git a/src/test/isolation/isolation_schedule b/src/test/isolation/isolation_schedule
index c055a53..b23428e 100644
--- a/src/test/isolation/isolation_schedule
+++ b/src/test/isolation/isolation_schedule
@@ -34,4 +34,6 @@ test: skip-locked-3
test: skip-locked-4
test: drop-index-concurrently-1
test: alter-table-1
+test: alter-table-2
+test: create-trigger
test: timeouts
diff --git a/src/test/isolation/specs/alter-table-2.spec b/src/test/isolation/specs/alter-table-2.spec
new file mode 100644
index 0000000..2ad7d62
--- /dev/null
+++ b/src/test/isolation/specs/alter-table-2.spec
@@ -0,0 +1,27 @@
+# ALTER TABLE - Add foreign keys with concurrent reads
+
+setup
+{
+ CREATE TABLE a (i int PRIMARY KEY);
+ CREATE TABLE b (a_id int);
+ INSERT INTO a VALUES (0), (1), (2), (3);
+ INSERT INTO b SELECT generate_series(1,1000) % 4;
+}
+
+teardown
+{
+ DROP TABLE a, b;
+}
+
+session "s1"
+setup { BEGIN; }
+step "at1" { ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; }
+step "sc2" { COMMIT; }
+
+session "s2"
+setup { BEGIN; }
+step "rx1" { SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; }
+step "rx1" { SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; }
+step "wx" { INSERT INTO b VALUES (0); }
+step "wx" { INSERT INTO a VALUES (4); }
+step "c" { COMMIT; }
diff --git a/src/test/isolation/specs/create-trigger.spec b/src/test/isolation/specs/create-trigger.spec
new file mode 100644
index 0000000..2a19ab8
--- /dev/null
+++ b/src/test/isolation/specs/create-trigger.spec
@@ -0,0 +1,25 @@
+# CREATE TRIGGER - Add trigger with concurrent reads
+
+setup
+{
+ CREATE TABLE a (i int);
+ CREATE FUNCTION f() RETURNS TRIGGER LANGUAGE plpgsql AS 'BEGIN RETURN NULL; END;';
+ INSERT INTO a VALUES (0), (1), (2), (3);
+}
+
+teardown
+{
+ DROP TABLE a;
+ DROP FUNCTION f();
+}
+
+session "s1"
+setup { BEGIN; }
+step "ct" { CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); }
+step "sc" { COMMIT; }
+
+session "s2"
+setup { BEGIN; }
+step "rx" { SELECT * FROM a WHERE i = 1 FOR UPDATE; }
+step "wx" { UPDATE a SET i = 4 WHERE i = 3; }
+step "c" { COMMIT; }
diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out
index d233710..1f7c265 100644
--- a/src/test/regress/expected/alter_table.out
+++ b/src/test/regress/expected/alter_table.out
@@ -1952,9 +1952,9 @@ create trigger ttdummy
execute procedure
ttdummy (1, 1);
select * from my_locks order by 1;
- relname | max_lockmode
------------+---------------------
- alterlock | AccessExclusiveLock
+ relname | max_lockmode
+-----------+-----------------------
+ alterlock | ShareRowExclusiveLock
(1 row)
rollback;
@@ -1966,10 +1966,10 @@ select * from my_locks order by 1;
alter table alterlock2 add foreign key (f1) references alterlock (f1);
select * from my_locks order by 1;
- relname | max_lockmode
------------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+-----------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
alterlock2_pkey | AccessShareLock
alterlock_pkey | AccessShareLock
(4 rows)
@@ -1979,10 +1979,10 @@ begin;
alter table alterlock2
add constraint alterlock2nv foreign key (f1) references alterlock (f1) NOT VALID;
select * from my_locks order by 1;
- relname | max_lockmode
-------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
(2 rows)
commit;
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On Tue, Jan 13, 2015 at 5:21 PM, Andreas Karlsson <andreas@proxel.se> wrote:
Here is a new version of the patch with updated isolation tests and
documentation.
Thanks.
Some more comments:
- It would be good to have as well tests for ENABLE/DISABLE TRIGGER,
the locks of those commands being reduced as well.
- Patch has some typos, like "an share".
- Documentation can be simplified. Listing the flavors of ALTER TABLE
taking ROW SHARE EXCLUSIVE in mvcc/sgml is clumsy IMO, it is better to
mention that in alter_table.sgml and have a link pointing to the page
of ALTER TABLE in mvcc.sgml.
- In ATAddForeignKeyConstraint, I think that it would be better to not
remove the comment, adding instead that ShareRowExclusiveLock is
actually safe because CREATE TRIGGER uses this level of lock.
All those things gathered give the patch attached. Andreas, if you are
fine with it I think that we could pass it to a committer.
Regards,
--
Michael
Attachments:
add-fk-lock-strength-v4.patchtext/x-patch; charset=US-ASCII; name=add-fk-lock-strength-v4.patchDownload
diff --git a/doc/src/sgml/mvcc.sgml b/doc/src/sgml/mvcc.sgml
index a0d6867..bd3e42a 100644
--- a/doc/src/sgml/mvcc.sgml
+++ b/doc/src/sgml/mvcc.sgml
@@ -908,9 +908,10 @@ ERROR: could not serialize access due to read/write dependencies among transact
</para>
<para>
- This lock mode is not automatically acquired by any
- <productname>PostgreSQL</productname> command.
- </para>
+ Acquired by <command>CREATE TRIGGER</command>, <command>ALTER
+ TRIGGER</command>, and many forms of <command>ALTER TABLE</command>
+ (see <xref linkend="SQL-ALTERTABLE">).
+ </para>>
</listitem>
</varlistentry>
@@ -957,9 +958,9 @@ ERROR: could not serialize access due to read/write dependencies among transact
<command>TRUNCATE</command>, <command>REINDEX</command>,
<command>CLUSTER</command>, and <command>VACUUM FULL</command>
commands. Many forms of <command>ALTER TABLE</> also acquire
- a lock at this level (see <xref linkend="SQL-ALTERTABLE">).
- This is also the default lock mode for <command>LOCK TABLE</command>
- statements that do not specify a mode explicitly.
+ a lock at this level. This is also the default lock mode for
+ <command>LOCK TABLE</command> statements that do not specify
+ a mode explicitly.
</para>
</listitem>
</varlistentry>
diff --git a/doc/src/sgml/ref/alter_table.sgml b/doc/src/sgml/ref/alter_table.sgml
index b5ef09e..5d2534a 100644
--- a/doc/src/sgml/ref/alter_table.sgml
+++ b/doc/src/sgml/ref/alter_table.sgml
@@ -405,6 +405,9 @@ ALTER TABLE ALL IN TABLESPACE <replaceable class="PARAMETER">name</replaceable>
mode, and triggers configured as <literal>ENABLE ALWAYS</literal> will
fire regardless of the current replication mode.
</para>
+ <para>
+ This command acquires a <literal>SHARE ROW EXCLUSIVE</literal> lock.
+ </para>
</listitem>
</varlistentry>
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 66d5083..ce5510e 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -2858,13 +2858,8 @@ AlterTableGetLockLevel(List *cmds)
break;
/*
- * These subcommands affect write operations only. XXX
- * Theoretically, these could be ShareRowExclusiveLock.
+ * These subcommands affect write operations only.
*/
- case AT_ColumnDefault:
- case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
- case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
- case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_EnableTrig:
case AT_EnableAlwaysTrig:
case AT_EnableReplicaTrig:
@@ -2873,6 +2868,17 @@ AlterTableGetLockLevel(List *cmds)
case AT_DisableTrig:
case AT_DisableTrigAll:
case AT_DisableTrigUser:
+ cmd_lockmode = ShareRowExclusiveLock;
+ break;
+
+ /*
+ * These subcommands affect write operations only. XXX
+ * Theoretically, these could be ShareRowExclusiveLock.
+ */
+ case AT_ColumnDefault:
+ case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
+ case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
+ case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_AlterConstraint:
case AT_AddIndex: /* from ADD CONSTRAINT */
case AT_AddIndexConstraint:
@@ -2909,11 +2915,9 @@ AlterTableGetLockLevel(List *cmds)
/*
* We add triggers to both tables when we add a
* Foreign Key, so the lock level must be at least
- * as strong as CREATE TRIGGER. XXX Might be set
- * down to ShareRowExclusiveLock though trigger
- * info is accessed by pg_get_triggerdef
+ * as strong as CREATE TRIGGER.
*/
- cmd_lockmode = AccessExclusiveLock;
+ cmd_lockmode = ShareRowExclusiveLock;
break;
default:
@@ -6030,16 +6034,15 @@ ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
ListCell *old_pfeqop_item = list_head(fkconstraint->old_conpfeqop);
/*
- * Grab an exclusive lock on the pk table, so that someone doesn't delete
- * rows out from under us. (Although a lesser lock would do for that
- * purpose, we'll need exclusive lock anyway to add triggers to the pk
- * table; trying to start with a lesser lock will just create a risk of
- * deadlock.)
+ * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't
+ * delete rows out from under us. Note that this does not create risks
+ * of deadlocks as triggers add added to the pk table using the same
+ * lock.
*/
if (OidIsValid(fkconstraint->old_pktable_oid))
- pkrel = heap_open(fkconstraint->old_pktable_oid, AccessExclusiveLock);
+ pkrel = heap_open(fkconstraint->old_pktable_oid, ShareRowExclusiveLock);
else
- pkrel = heap_openrv(fkconstraint->pktable, AccessExclusiveLock);
+ pkrel = heap_openrv(fkconstraint->pktable, ShareRowExclusiveLock);
/*
* Validity checks (permission checks wait till we have the column
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 4899a27..33f8448 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -158,9 +158,9 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
referenced;
if (OidIsValid(relOid))
- rel = heap_open(relOid, AccessExclusiveLock);
+ rel = heap_open(relOid, ShareRowExclusiveLock);
else
- rel = heap_openrv(stmt->relation, AccessExclusiveLock);
+ rel = heap_openrv(stmt->relation, ShareRowExclusiveLock);
/*
* Triggers must be on tables or views, and there are additional
@@ -526,8 +526,7 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
* can skip this for internally generated triggers, since the name
* modification above should be sufficient.
*
- * NOTE that this is cool only because we have AccessExclusiveLock on the
- * relation, so the trigger set won't be changing underneath us.
+ * NOTE that this is cool only because of the unique contraint.
*/
if (!isInternal)
{
@@ -1103,7 +1102,7 @@ RemoveTriggerById(Oid trigOid)
*/
relid = ((Form_pg_trigger) GETSTRUCT(tup))->tgrelid;
- rel = heap_open(relid, AccessExclusiveLock);
+ rel = heap_open(relid, ShareRowExclusiveLock);
if (rel->rd_rel->relkind != RELKIND_RELATION &&
rel->rd_rel->relkind != RELKIND_VIEW &&
@@ -1258,7 +1257,7 @@ renametrig(RenameStmt *stmt)
* Look up name, check permissions, and acquire lock (which we will NOT
* release until end of transaction).
*/
- relid = RangeVarGetRelidExtended(stmt->relation, AccessExclusiveLock,
+ relid = RangeVarGetRelidExtended(stmt->relation, ShareRowExclusiveLock,
false, false,
RangeVarCallbackForRenameTrigger,
NULL);
@@ -1272,8 +1271,7 @@ renametrig(RenameStmt *stmt)
* on tgrelid/tgname would complain anyway) and to ensure a trigger does
* exist with oldname.
*
- * NOTE that this is cool only because we have AccessExclusiveLock on the
- * relation, so the trigger set won't be changing underneath us.
+ * NOTE that this is cool only because there is a unique constraint.
*/
tgrel = heap_open(TriggerRelationId, RowExclusiveLock);
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index dd748ac..8eeccf2 100644
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -699,7 +699,8 @@ pg_get_triggerdef_worker(Oid trigid, bool pretty)
HeapTuple ht_trig;
Form_pg_trigger trigrec;
StringInfoData buf;
- Relation tgrel;
+ Snapshot snapshot = RegisterSnapshot(GetTransactionSnapshot());
+ Relation tgrel = heap_open(TriggerRelationId, AccessShareLock);
ScanKeyData skey[1];
SysScanDesc tgscan;
int findx = 0;
@@ -710,18 +711,18 @@ pg_get_triggerdef_worker(Oid trigid, bool pretty)
/*
* Fetch the pg_trigger tuple by the Oid of the trigger
*/
- tgrel = heap_open(TriggerRelationId, AccessShareLock);
-
ScanKeyInit(&skey[0],
ObjectIdAttributeNumber,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(trigid));
tgscan = systable_beginscan(tgrel, TriggerOidIndexId, true,
- NULL, 1, skey);
+ snapshot, 1, skey);
ht_trig = systable_getnext(tgscan);
+ UnregisterSnapshot(snapshot);
+
if (!HeapTupleIsValid(ht_trig))
elog(ERROR, "could not find tuple for trigger %u", trigid);
diff --git a/src/test/isolation/expected/alter-table-1.out b/src/test/isolation/expected/alter-table-1.out
index edf7288..9daa418 100644
--- a/src/test/isolation/expected/alter-table-1.out
+++ b/src/test/isolation/expected/alter-table-1.out
@@ -703,12 +703,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 sc2 wx rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
@@ -724,12 +723,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -745,12 +743,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -766,12 +763,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -787,12 +783,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -808,12 +803,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -829,12 +823,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -850,12 +843,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -871,12 +863,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -892,12 +883,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -913,12 +903,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -934,12 +923,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -955,12 +943,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -976,12 +963,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -997,12 +983,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -1018,12 +1003,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -1039,12 +1023,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1060,12 +1043,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1081,12 +1063,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1102,12 +1083,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 c2 s2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1123,137 +1103,362 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 sc2 c2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 c2 sc2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 c2 at2 sc2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 at1 rx1 wx rx1 c2 sc1 s2 at2 sc2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 at1 sc1 s2 at2 sc2 wx rx1 c2
-step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx sc2 rx1 c2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 sc2 c2
+starting permutation: s1 at1 rx1 wx rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 c2 sc2
+starting permutation: s1 at1 rx1 wx rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx1 c2
+starting permutation: s1 rx1 at1 sc1 s2 at2 sc2 wx rx1 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx1 sc2 c2
step s1: BEGIN;
@@ -1261,8 +1466,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx1 c2 sc2
step s1: BEGIN;
@@ -1270,8 +1486,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 at2 sc2 c2
step s1: BEGIN;
@@ -1279,8 +1506,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 at2 c2 sc2
step s1: BEGIN;
@@ -1288,8 +1526,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 c2 at2 sc2
step s1: BEGIN;
@@ -1297,8 +1546,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 wx s2 at2 sc2 rx1 c2
step s1: BEGIN;
@@ -1306,8 +1566,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 sc2 c2
step s1: BEGIN;
@@ -1315,189 +1586,548 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 c2 s2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 sc2 c2
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 c2 sc2
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 c2 at2 sc2
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 c2 sc2
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 at1 wx rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 c2 s2 at2 sc2
+starting permutation: s1 rx1 at1 wx rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx1 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 sc2 rx1 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 c2 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1506,14 +2136,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1522,14 +2152,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1538,14 +2168,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 c2 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1554,14 +2184,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 c2 sc1 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1575,197 +2205,181 @@ step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 sc2 rx1 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
-a_id
-
-1
-step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 sc2 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
-a_id
-
-1
-step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 sc2 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 c2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 c2 at2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 c2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 rx1 c2 s2 at2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx rx1 at1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step c2: COMMIT;
+step at1: <... completed>
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx rx1 c2 at1 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 c2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step sc2: COMMIT;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 c2 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
-step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 sc2 c2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1773,63 +2387,78 @@ a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 c2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 c2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 c2 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1837,20 +2466,19 @@ a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 c2 at1 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1858,174 +2486,189 @@ a_id
3
3
3
-step c2: COMMIT;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step sc1: COMMIT;
-step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx1 c2
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx1 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 sc2 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 c2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx1 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 c2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx1 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 c2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 sc2 c2
+starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 c2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 sc1 wx rx1 s2 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2033,8 +2676,19 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 sc1 wx rx1 c2 s2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2042,8 +2696,19 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2051,9 +2716,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2061,9 +2737,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2071,9 +2758,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2081,9 +2779,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2091,9 +2800,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2101,9 +2821,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2111,9 +2842,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2121,9 +2863,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2131,50 +2884,60 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 wx sc1 rx1 c2 s2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 sc2 c2
+starting permutation: rx1 s1 at1 wx sc1 rx1 c2 s2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 c2 sc2
+starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 c2 sc2
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
-3
-3
-3
+1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 sc1 s2 c2 at2 sc2
@@ -2183,14 +2946,8 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 sc1 c2 s2 at2 sc2
@@ -2199,14 +2956,8 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 c2 sc1 s2 at2 sc2
@@ -2215,20 +2966,9 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
-step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
-step sc2: COMMIT;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
starting permutation: rx1 s1 wx at1 sc1 s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
diff --git a/src/test/isolation/expected/alter-table-2.out b/src/test/isolation/expected/alter-table-2.out
new file mode 100644
index 0000000..cef7516
--- /dev/null
+++ b/src/test/isolation/expected/alter-table-2.out
@@ -0,0 +1,1389 @@
+Parsed test spec with 2 sessions
+
+starting permutation: s1a s1b s1c s2a s2b s2c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s1c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s2d s1c s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s2d s2e s1c s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s2c s2d s2e s2f s1c
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s1c s2b s2c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s1c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s2d s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s2d s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s2c s2d s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s1c s2c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s1c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s2d s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s2d s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s2c s2d s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s1c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s2d s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s2d s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s2d s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s1b s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s1b s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s1b s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s2e s1b s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s2e s1b s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s2e s2f s1b s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s1c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s2d s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s2d s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s2c s2d s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s1c s2c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s1c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s2d s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s2d s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s2c s2d s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s1c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s2d s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s2d s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s2d s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s1b s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s1b s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s1b s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s2e s1b s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s2e s1b s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s2e s2f s1b s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s1c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s2d s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s2d s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s1b s2c s2d s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s1c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s2d s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s2d s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s2d s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s1b s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s1b s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s1b s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s2e s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s2e s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s2e s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s2d s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s2d s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s1b s2d s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s1b s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s1b s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s1b s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s2e s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s2e s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s2e s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s1b s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s1a s1b s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s1a s1b s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s2e s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s1a s2e s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s2e s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s2e s1a s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s2e s1a s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s2e s1a s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1a: BEGIN;
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s2e s2f s1a s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
diff --git a/src/test/isolation/expected/alter-table-3.out b/src/test/isolation/expected/alter-table-3.out
new file mode 100644
index 0000000..7dc64df
--- /dev/null
+++ b/src/test/isolation/expected/alter-table-3.out
@@ -0,0 +1,947 @@
+Parsed test spec with 2 sessions
+
+starting permutation: s1a s1b s1c s1d s2a s2b s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s1d s2b s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s2b s1d s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s2b s2c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s2b s2c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s1c s1d s2b s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s1d s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s1c s1d s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s2c s1c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s1c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s2c s2d s1c s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s1c s1d s2b s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s1c s2b s1d s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s1c s2b s2c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s1c s2b s2c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s1c s1d s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s2c s1c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s1c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s2c s2d s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s1c s1d s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s1c s2c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s1c s2c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s2c s1c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s1c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s2c s2d s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s1c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s1c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s2d s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s1b s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s1d s2b s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s1d s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s1c s1d s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s2c s1c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s1c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s2c s2d s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s1c s1d s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s1c s2c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s1c s2c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s2c s1c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s1c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s2c s2d s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s1c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s1c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s2d s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s1b s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s1d s2c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s1b s2c s1c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s1c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s1b s2c s2d s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s1c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s1c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s2d s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s1b s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s2d s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s1b s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s1b s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
diff --git a/src/test/isolation/expected/create-trigger.out b/src/test/isolation/expected/create-trigger.out
new file mode 100644
index 0000000..e8bb740
--- /dev/null
+++ b/src/test/isolation/expected/create-trigger.out
@@ -0,0 +1,421 @@
+Parsed test spec with 2 sessions
+
+starting permutation: s1a s1b s1c s2a s2b s2c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s1c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s2d s1c
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s1c s2b s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s1c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s2d s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s1c s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s1c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s2d s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s1c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s2d s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s1b s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s1c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s2d s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s1c s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s1c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s2d s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s1c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s2d s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s1b s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s1c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s2d s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s1c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s2d s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s1b s2d s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1a: BEGIN;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
diff --git a/src/test/isolation/isolation_schedule b/src/test/isolation/isolation_schedule
index c055a53..3e2614e 100644
--- a/src/test/isolation/isolation_schedule
+++ b/src/test/isolation/isolation_schedule
@@ -34,4 +34,7 @@ test: skip-locked-3
test: skip-locked-4
test: drop-index-concurrently-1
test: alter-table-1
+test: alter-table-2
+test: alter-table-3
+test: create-trigger
test: timeouts
diff --git a/src/test/isolation/specs/alter-table-2.spec b/src/test/isolation/specs/alter-table-2.spec
new file mode 100644
index 0000000..e6a02e0
--- /dev/null
+++ b/src/test/isolation/specs/alter-table-2.spec
@@ -0,0 +1,30 @@
+# ALTER TABLE - Add foreign keys with concurrent reads
+#
+# ADD CONSTRAINT uses ShareRowExclusiveLock so we mix writes with it
+# to see what works or waits.
+
+setup
+{
+ CREATE TABLE a (i int PRIMARY KEY);
+ CREATE TABLE b (a_id int);
+ INSERT INTO a VALUES (0), (1), (2), (3);
+ INSERT INTO b SELECT generate_series(1,1000) % 4;
+}
+
+teardown
+{
+ DROP TABLE a, b;
+}
+
+session "s1"
+step "s1a" { BEGIN; }
+step "s1b" { ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; }
+step "s1c" { COMMIT; }
+
+session "s2"
+step "s2a" { BEGIN; }
+step "s2b" { SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; }
+step "s2c" { SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; }
+step "s2d" { INSERT INTO b VALUES (0); }
+step "s2e" { INSERT INTO a VALUES (4); }
+step "s2f" { COMMIT; }
diff --git a/src/test/isolation/specs/alter-table-3.spec b/src/test/isolation/specs/alter-table-3.spec
new file mode 100644
index 0000000..d252620
--- /dev/null
+++ b/src/test/isolation/specs/alter-table-3.spec
@@ -0,0 +1,30 @@
+# ALTER TABLE - Enable and disable triggers with concurrent reads
+#
+# ENABLE/DISABLE TRIGGER uses ShareRowExclusiveLock so we mix writes with
+# it to see what works or waits.
+
+setup
+{
+ CREATE TABLE a (i int PRIMARY KEY);
+ INSERT INTO a VALUES (0), (1), (2), (3);
+ CREATE FUNCTION f() RETURNS TRIGGER LANGUAGE plpgsql AS 'BEGIN RETURN NULL; END;';
+ CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+}
+
+teardown
+{
+ DROP TABLE a;
+ DROP FUNCTION f();
+}
+
+session "s1"
+step "s1a" { BEGIN; }
+step "s1b" { ALTER TABLE a DISABLE TRIGGER t; }
+step "s1c" { ALTER TABLE a ENABLE TRIGGER t; }
+step "s1d" { COMMIT; }
+
+session "s2"
+step "s2a" { BEGIN; }
+step "s2b" { SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; }
+step "s2c" { INSERT INTO a VALUES (0); }
+step "s2d" { COMMIT; }
diff --git a/src/test/isolation/specs/create-trigger.spec b/src/test/isolation/specs/create-trigger.spec
new file mode 100644
index 0000000..34fad75
--- /dev/null
+++ b/src/test/isolation/specs/create-trigger.spec
@@ -0,0 +1,28 @@
+# CREATE TRIGGER - Add trigger with concurrent reads
+#
+# CREATE TRIGGER uses ShareRowExclusiveLock so we mix writes with it
+# to see what works or waits.
+
+setup
+{
+ CREATE TABLE a (i int);
+ CREATE FUNCTION f() RETURNS TRIGGER LANGUAGE plpgsql AS 'BEGIN RETURN NULL; END;';
+ INSERT INTO a VALUES (0), (1), (2), (3);
+}
+
+teardown
+{
+ DROP TABLE a;
+ DROP FUNCTION f();
+}
+
+session "s1"
+step "s1a" { BEGIN; }
+step "s1b" { CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); }
+step "s1c" { COMMIT; }
+
+session "s2"
+step "s2a" { BEGIN; }
+step "s2b" { SELECT * FROM a WHERE i = 1 FOR UPDATE; }
+step "s2c" { UPDATE a SET i = 4 WHERE i = 3; }
+step "s2d" { COMMIT; }
diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out
index d233710..1f7c265 100644
--- a/src/test/regress/expected/alter_table.out
+++ b/src/test/regress/expected/alter_table.out
@@ -1952,9 +1952,9 @@ create trigger ttdummy
execute procedure
ttdummy (1, 1);
select * from my_locks order by 1;
- relname | max_lockmode
------------+---------------------
- alterlock | AccessExclusiveLock
+ relname | max_lockmode
+-----------+-----------------------
+ alterlock | ShareRowExclusiveLock
(1 row)
rollback;
@@ -1966,10 +1966,10 @@ select * from my_locks order by 1;
alter table alterlock2 add foreign key (f1) references alterlock (f1);
select * from my_locks order by 1;
- relname | max_lockmode
------------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+-----------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
alterlock2_pkey | AccessShareLock
alterlock_pkey | AccessShareLock
(4 rows)
@@ -1979,10 +1979,10 @@ begin;
alter table alterlock2
add constraint alterlock2nv foreign key (f1) references alterlock (f1) NOT VALID;
select * from my_locks order by 1;
- relname | max_lockmode
-------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
(2 rows)
commit;
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
I wrote:
I think that we could pass it to a committer.
Marked as such.
--
Michael
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 01/14/2015 08:48 AM, Michael Paquier wrote:
All those things gathered give the patch attached. Andreas, if you are
fine with it I think that we could pass it to a committer.
Excellent changes. Thanks for the patch and the reviews.
--
Andreas Karlsson
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
Hi,
/* - * Grab an exclusive lock on the pk table, so that someone doesn't delete - * rows out from under us. (Although a lesser lock would do for that - * purpose, we'll need exclusive lock anyway to add triggers to the pk - * table; trying to start with a lesser lock will just create a risk of - * deadlock.) + * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't + * delete rows out from under us. Note that this does not create risks + * of deadlocks as triggers add added to the pk table using the same + * lock. */
"add added" doesn't look intended. The rest of the sentence doesn't look
entirely right either.
/* * Triggers must be on tables or views, and there are additional @@ -526,8 +526,7 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString, * can skip this for internally generated triggers, since the name * modification above should be sufficient. * - * NOTE that this is cool only because we have AccessExclusiveLock on the - * relation, so the trigger set won't be changing underneath us. + * NOTE that this is cool only because of the unique contraint.
I fail to see what the unique constraint has to do with this? The
previous comment refers to the fact that the AccessExclusiveLock is what
prevents a race where another transaction adds a trigger with the same
name already exists. Yes, the unique index would, as noted earlier in
the comment, catch the error. But that's not the point of the
check. Unless I miss something the comment is just as true if you
replace the access exclusive with share row exlusive as it's also self
conflicting.
@@ -1272,8 +1271,7 @@ renametrig(RenameStmt *stmt) * on tgrelid/tgname would complain anyway) and to ensure a trigger does * exist with oldname. * - * NOTE that this is cool only because we have AccessExclusiveLock on the - * relation, so the trigger set won't be changing underneath us. + * NOTE that this is cool only because there is a unique constraint. */
Same as above.
tgrel = heap_open(TriggerRelationId, RowExclusiveLock);
diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index dd748ac..8eeccf2 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -699,7 +699,8 @@ pg_get_triggerdef_worker(Oid trigid, bool pretty) HeapTuple ht_trig; Form_pg_trigger trigrec; StringInfoData buf; - Relation tgrel; + Snapshot snapshot = RegisterSnapshot(GetTransactionSnapshot()); + Relation tgrel = heap_open(TriggerRelationId, AccessShareLock); ScanKeyData skey[1]; SysScanDesc tgscan; int findx = 0; @@ -710,18 +711,18 @@ pg_get_triggerdef_worker(Oid trigid, bool pretty) /* * Fetch the pg_trigger tuple by the Oid of the trigger */ - tgrel = heap_open(TriggerRelationId, AccessShareLock); - ScanKeyInit(&skey[0], ObjectIdAttributeNumber, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(trigid));tgscan = systable_beginscan(tgrel, TriggerOidIndexId, true, - NULL, 1, skey); + snapshot, 1, skey);ht_trig = systable_getnext(tgscan);
+ UnregisterSnapshot(snapshot); + if (!HeapTupleIsValid(ht_trig)) elog(ERROR, "could not find tuple for trigger %u", trigid);
Hm. Pushing the snapshot is supposed to make this fully mvcc? Idon't
think that's actually sufficient because of the deparsing of the WHEN
clause and of the function name.
Greetings,
Andres Freund
--
Andres Freund http://www.2ndQuadrant.com/
PostgreSQL Development, 24x7 Support, Training & Services
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 01/16/2015 03:01 PM, Andres Freund wrote:
Hi,
/* - * Grab an exclusive lock on the pk table, so that someone doesn't delete - * rows out from under us. (Although a lesser lock would do for that - * purpose, we'll need exclusive lock anyway to add triggers to the pk - * table; trying to start with a lesser lock will just create a risk of - * deadlock.) + * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't + * delete rows out from under us. Note that this does not create risks + * of deadlocks as triggers add added to the pk table using the same + * lock. */"add added" doesn't look intended. The rest of the sentence doesn't look
entirely right either.
It was intended to be "are added", but the sentence is pretty awful
anyway. I am not sure the sentence is really necessary anyway.
/* * Triggers must be on tables or views, and there are additional @@ -526,8 +526,7 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString, * can skip this for internally generated triggers, since the name * modification above should be sufficient. * - * NOTE that this is cool only because we have AccessExclusiveLock on the - * relation, so the trigger set won't be changing underneath us. + * NOTE that this is cool only because of the unique contraint.I fail to see what the unique constraint has to do with this? The
previous comment refers to the fact that the AccessExclusiveLock is what
prevents a race where another transaction adds a trigger with the same
name already exists. Yes, the unique index would, as noted earlier in
the comment, catch the error. But that's not the point of the
check. Unless I miss something the comment is just as true if you
replace the access exclusive with share row exlusive as it's also self
conflicting.
Yeah, this must have been a remainder from the version where I only
grabbed a ShareLock. The comment should be restored.
Hm. Pushing the snapshot is supposed to make this fully mvcc? Idon't
think that's actually sufficient because of the deparsing of the WHEN
clause and of the function name.
Indeed. As Noah and I discussed previously in this thread we would need
to do quite a bit of refactoring of ruleutils.c to make it fully MVCC.
For this reason I opted to only lower the lock levels of ADD and ALTER
TRIGGER, and not DROP TRIGGER. Neither of those require MVCC of then
WHEN clause.
Andreas
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 2015-01-16 15:16:20 +0100, Andreas Karlsson wrote:
Indeed. As Noah and I discussed previously in this thread we would need to
do quite a bit of refactoring of ruleutils.c to make it fully MVCC.
Right.
For this reason I opted to only lower the lock levels of ADD and ALTER
TRIGGER, and not DROP TRIGGER. Neither of those require MVCC of then
WHEN clause.
I'm unconvinced that this is true. Using a snapshot for part of getting
a definition certainly opens the door for getting strange
results.
Acquiring a lock that prevents schema changes on the table and then
getting the definition using the syscaches guarantees that that
definition is at least self consistent because no further schema changes
are possible and the catalog caches will be up2date.
What you're doing though is doing part of the scan using the
transaction's snapshot (as used by pg_dump that will usually be a
repeatable read snapshot and possibly quite old) and the other using a
fresh catalog snapshot. This can result in rather odd things.
Just consider:
S1: CREATE TABLE flubber(id serial primary key, data text);
S1: CREATE FUNCTION blarg() RETURNS TRIGGER LANGUAGE plpgsql AS $$BEGIN RETURN NEW; END;$$;
S1: CREATE TRIGGER flubber_blarg BEFORE INSERT ON flubber FOR EACH ROW WHEN (NEW.data IS NOT NULL) EXECUTE PROCEDURE blarg();
S2: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;
S2: SELECT 'dosomethingelse';
S1: ALTER TABLE flubber RENAME TO wasflubber;
S1: ALTER TABLE wasflubber RENAME COLUMN data TO wasdata;
S1: ALTER TRIGGER flubber_blarg ON wasflubber RENAME TO wasflubber_blarg;
S1: ALTER FUNCTION blarg() RENAME TO wasblarg;
S2: SELECT pg_get_triggerdef(oid) FROM pg_trigger;
This will give you: The old trigger name. The new table name. The new
column name. The new function name.
I don't think using a snapshot for tiny parts of these functions
actually buys anything. Now, this isn't a pattern you introduced. But I
think we should think about this for a second before expanding it
further.
Before you argue that this isn't relevant for pg_dump: It is. Precisely
the above can happen - just replace the 'dosomethingelse' with several
LOCK TABLEs as pg_dump does. The first blocks after a snapshot has been
acquired. While waiting, all the ALTERs happen.
Arguably the benefit here is that the window for this issue is becoming
smaller as pg_dump (and hopefully other possible callers) acquire
exclusive locks on the table. I.e. that the lowering of the lock level
doesn't introduce new races. But on the other side of the coin, this
makes the result of pg_get_triggerdef() even *more* inaccurate in many
cases.
Greetings,
Andres Freund
--
Andres Freund http://www.2ndQuadrant.com/
PostgreSQL Development, 24x7 Support, Training & Services
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On Fri, Jan 16, 2015 at 10:59 AM, Andres Freund <andres@2ndquadrant.com> wrote:
Just consider:
S1: CREATE TABLE flubber(id serial primary key, data text);
S1: CREATE FUNCTION blarg() RETURNS TRIGGER LANGUAGE plpgsql AS $$BEGIN RETURN NEW; END;$$;
S1: CREATE TRIGGER flubber_blarg BEFORE INSERT ON flubber FOR EACH ROW WHEN (NEW.data IS NOT NULL) EXECUTE PROCEDURE blarg();
S2: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;
S2: SELECT 'dosomethingelse';
S1: ALTER TABLE flubber RENAME TO wasflubber;
S1: ALTER TABLE wasflubber RENAME COLUMN data TO wasdata;
S1: ALTER TRIGGER flubber_blarg ON wasflubber RENAME TO wasflubber_blarg;
S1: ALTER FUNCTION blarg() RENAME TO wasblarg;
S2: SELECT pg_get_triggerdef(oid) FROM pg_trigger;This will give you: The old trigger name. The new table name. The new
column name. The new function name.
Ouch. That's clearly no good. I'm struggling to understand whether
this is a problem with our previous analysis, or a problem with this
patch:
/messages/by-id/20141028003356.GA387814@tornado.leadboat.com
pg_get_triggerdef_worker() relies on generate_function_name(), which
uses the system caches, and on get_rule_expr(), for deparsing the WHEN
clause. If we allowed only ADDING triggers with a lesser lock and
never modifying or dropping them with a lesser lock, then changing the
initial scan of pg_trigger at the top of pg_get_triggerdef_worker() to
use the transaction snapshot might be OK; if we can see the trigger
with the transaction snapshot at all, we know it can't have
subsequently changed. But allowing alterations of any kind isn't
going to work, so I think our previous analysis on that point was
incorrect.
I *think* we could fix that if generate_function_name() and
get_rule_expr() had an option to use the active snapshot instead of a
fresh snapshot. The former doesn't look too hard to arrange, but the
latter is a tougher nut to crack.
--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 01/19/2015 06:14 PM, Robert Haas wrote:
On Fri, Jan 16, 2015 at 10:59 AM, Andres Freund <andres@2ndquadrant.com> wrote:
This will give you: The old trigger name. The new table name. The new
column name. The new function name.Ouch. That's clearly no good. I'm struggling to understand whether
this is a problem with our previous analysis, or a problem with this
patch:/messages/by-id/20141028003356.GA387814@tornado.leadboat.com
pg_get_triggerdef_worker() relies on generate_function_name(), which
uses the system caches, and on get_rule_expr(), for deparsing the WHEN
clause. If we allowed only ADDING triggers with a lesser lock and
never modifying or dropping them with a lesser lock, then changing the
initial scan of pg_trigger at the top of pg_get_triggerdef_worker() to
use the transaction snapshot might be OK; if we can see the trigger
with the transaction snapshot at all, we know it can't have
subsequently changed. But allowing alterations of any kind isn't
going to work, so I think our previous analysis on that point was
incorrect.I *think* we could fix that if generate_function_name() and
get_rule_expr() had an option to use the active snapshot instead of a
fresh snapshot. The former doesn't look too hard to arrange, but the
latter is a tougher nut to crack.
The function name in the trigger should already be broken in master
since changing the name of a function does not lock the table. Would be
really neat to fix though.
A possible way forward I see here is to undo my changes to the lock
level of ALTER TRIGGER and of pg_get_triggerdef_worker(). This should
work if Noah is correct about his analysis in where he came to the
conclusion: "pg_get_triggerdef() is fine as-is with concurrent CREATE
TRIGGER.". Is this still true with the new information?
--
Andreas Karlsson
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On Fri, Jan 16, 2015 at 04:59:56PM +0100, Andres Freund wrote:
On 2015-01-16 15:16:20 +0100, Andreas Karlsson wrote:
For this reason I opted to only lower the lock levels of ADD and ALTER
TRIGGER, and not DROP TRIGGER. Neither of those require MVCC of then
WHEN clause.I'm unconvinced that this is true. Using a snapshot for part of getting
a definition certainly opens the door for getting strange
results.Acquiring a lock that prevents schema changes on the table and then
getting the definition using the syscaches guarantees that that
definition is at least self consistent because no further schema changes
are possible and the catalog caches will be up2date.What you're doing though is doing part of the scan using the
transaction's snapshot (as used by pg_dump that will usually be a
repeatable read snapshot and possibly quite old) and the other using a
fresh catalog snapshot. This can result in rather odd things.Just consider:
S1: CREATE TABLE flubber(id serial primary key, data text);
S1: CREATE FUNCTION blarg() RETURNS TRIGGER LANGUAGE plpgsql AS $$BEGIN RETURN NEW; END;$$;
S1: CREATE TRIGGER flubber_blarg BEFORE INSERT ON flubber FOR EACH ROW WHEN (NEW.data IS NOT NULL) EXECUTE PROCEDURE blarg();
S2: BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE;
S2: SELECT 'dosomethingelse';
S1: ALTER TABLE flubber RENAME TO wasflubber;
S1: ALTER TABLE wasflubber RENAME COLUMN data TO wasdata;
S1: ALTER TRIGGER flubber_blarg ON wasflubber RENAME TO wasflubber_blarg;
S1: ALTER FUNCTION blarg() RENAME TO wasblarg;
S2: SELECT pg_get_triggerdef(oid) FROM pg_trigger;This will give you: The old trigger name. The new table name. The new
column name. The new function name.I don't think using a snapshot for tiny parts of these functions
actually buys anything. Now, this isn't a pattern you introduced. But I
think we should think about this for a second before expanding it
further.
Fair enough. It did reinforce pg_get_constraintdef() as a subroutine of
pg_dump rather than an independent, rigorous interface. It perhaps made the
function worse for non-pg_dump callers. In that vein, each one of these hacks
has a cost. One could make a reasonable argument that ALTER TRIGGER RENAME
locking is not important enough to justify spreading the hack from
pg_get_constraintdef() to pg_get_triggerdef(). Lowering the CREATE TRIGGER
lock level does not require any ruleutils.c change for the benefit of pg_dump,
because pg_dump won't see the pg_trigger row of a too-recent trigger.
Before you argue that this isn't relevant for pg_dump: It is. Precisely
the above can happen - just replace the 'dosomethingelse' with several
LOCK TABLEs as pg_dump does. The first blocks after a snapshot has been
acquired. While waiting, all the ALTERs happen.
We wish pg_dump would take a snapshot of the database; that is, we wish its
output always matched some serial execution of transactions. pg_dump has,
since ancient times, failed to achieve that if non-table DDL commits during
the dump or if table DDL commits between acquiring the dump transaction
snapshot and acquiring the last table lock. My reviews have defended the
standard that table DDL issued after pg_dump has acquired locks does not
change the dump. That's what we bought with pg_get_constraintdef()'s use of
the transaction snapshot and would buy with the same in pg_get_triggerdef().
My reviews have deliberately ignored effects on scenarios where pg_dump
already fails to guarantee snapshot-like output.
Arguably the benefit here is that the window for this issue is becoming
smaller as pg_dump (and hopefully other possible callers) acquire
exclusive locks on the table. I.e. that the lowering of the lock level
doesn't introduce new races. But on the other side of the coin, this
makes the result of pg_get_triggerdef() even *more* inaccurate in many
cases.
What is this about pg_dump acquiring exclusive locks?
To summarize, the problem you raise has been out of scope, because it affects
pg_dump only at times when pg_dump is already wrong.
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 01/20/2015 10:08 AM, Noah Misch wrote:
Fair enough. It did reinforce pg_get_constraintdef() as a subroutine of
pg_dump rather than an independent, rigorous interface. It perhaps made the
function worse for non-pg_dump callers. In that vein, each one of these hacks
has a cost. One could make a reasonable argument that ALTER TRIGGER RENAME
locking is not important enough to justify spreading the hack from
pg_get_constraintdef() to pg_get_triggerdef(). Lowering the CREATE TRIGGER
lock level does not require any ruleutils.c change for the benefit of pg_dump,
because pg_dump won't see the pg_trigger row of a too-recent trigger.
I agree with this view, and am not sure myself that it is worth lowering
the lock level of ALTER TRIGGER RENAME. I have attached a patch without
the changes to ALTER TRIGGER and ruleutils.c and also fixes the comment
issues noted by Andres.
--
Andreas Karlsson
Attachments:
add-fk-lock-strength-v5.patchtext/x-patch; name=add-fk-lock-strength-v5.patchDownload
diff --git a/doc/src/sgml/mvcc.sgml b/doc/src/sgml/mvcc.sgml
index a0d6867..fc86224 100644
--- a/doc/src/sgml/mvcc.sgml
+++ b/doc/src/sgml/mvcc.sgml
@@ -908,9 +908,9 @@ ERROR: could not serialize access due to read/write dependencies among transact
</para>
<para>
- This lock mode is not automatically acquired by any
- <productname>PostgreSQL</productname> command.
- </para>
+ Acquired by <command>CREATE TRIGGER</command> and many forms of
+ <command>ALTER TABLE</command> (see <xref linkend="SQL-ALTERTABLE">).
+ </para>>
</listitem>
</varlistentry>
@@ -957,9 +957,9 @@ ERROR: could not serialize access due to read/write dependencies among transact
<command>TRUNCATE</command>, <command>REINDEX</command>,
<command>CLUSTER</command>, and <command>VACUUM FULL</command>
commands. Many forms of <command>ALTER TABLE</> also acquire
- a lock at this level (see <xref linkend="SQL-ALTERTABLE">).
- This is also the default lock mode for <command>LOCK TABLE</command>
- statements that do not specify a mode explicitly.
+ a lock at this level. This is also the default lock mode for
+ <command>LOCK TABLE</command> statements that do not specify
+ a mode explicitly.
</para>
</listitem>
</varlistentry>
diff --git a/doc/src/sgml/ref/alter_table.sgml b/doc/src/sgml/ref/alter_table.sgml
index b3a4970..f5bbfcd 100644
--- a/doc/src/sgml/ref/alter_table.sgml
+++ b/doc/src/sgml/ref/alter_table.sgml
@@ -406,6 +406,9 @@ ALTER TABLE ALL IN TABLESPACE <replaceable class="PARAMETER">name</replaceable>
mode, and triggers configured as <literal>ENABLE ALWAYS</literal> will
fire regardless of the current replication mode.
</para>
+ <para>
+ This command acquires a <literal>SHARE ROW EXCLUSIVE</literal> lock.
+ </para>
</listitem>
</varlistentry>
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 66d5083..08aa71b 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -2858,13 +2858,8 @@ AlterTableGetLockLevel(List *cmds)
break;
/*
- * These subcommands affect write operations only. XXX
- * Theoretically, these could be ShareRowExclusiveLock.
+ * These subcommands affect write operations only.
*/
- case AT_ColumnDefault:
- case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
- case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
- case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_EnableTrig:
case AT_EnableAlwaysTrig:
case AT_EnableReplicaTrig:
@@ -2873,6 +2868,17 @@ AlterTableGetLockLevel(List *cmds)
case AT_DisableTrig:
case AT_DisableTrigAll:
case AT_DisableTrigUser:
+ cmd_lockmode = ShareRowExclusiveLock;
+ break;
+
+ /*
+ * These subcommands affect write operations only. XXX
+ * Theoretically, these could be ShareRowExclusiveLock.
+ */
+ case AT_ColumnDefault:
+ case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
+ case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
+ case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_AlterConstraint:
case AT_AddIndex: /* from ADD CONSTRAINT */
case AT_AddIndexConstraint:
@@ -2909,11 +2915,9 @@ AlterTableGetLockLevel(List *cmds)
/*
* We add triggers to both tables when we add a
* Foreign Key, so the lock level must be at least
- * as strong as CREATE TRIGGER. XXX Might be set
- * down to ShareRowExclusiveLock though trigger
- * info is accessed by pg_get_triggerdef
+ * as strong as CREATE TRIGGER.
*/
- cmd_lockmode = AccessExclusiveLock;
+ cmd_lockmode = ShareRowExclusiveLock;
break;
default:
@@ -6030,16 +6034,13 @@ ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
ListCell *old_pfeqop_item = list_head(fkconstraint->old_conpfeqop);
/*
- * Grab an exclusive lock on the pk table, so that someone doesn't delete
- * rows out from under us. (Although a lesser lock would do for that
- * purpose, we'll need exclusive lock anyway to add triggers to the pk
- * table; trying to start with a lesser lock will just create a risk of
- * deadlock.)
+ * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't
+ * delete rows out from under us.
*/
if (OidIsValid(fkconstraint->old_pktable_oid))
- pkrel = heap_open(fkconstraint->old_pktable_oid, AccessExclusiveLock);
+ pkrel = heap_open(fkconstraint->old_pktable_oid, ShareRowExclusiveLock);
else
- pkrel = heap_openrv(fkconstraint->pktable, AccessExclusiveLock);
+ pkrel = heap_openrv(fkconstraint->pktable, ShareRowExclusiveLock);
/*
* Validity checks (permission checks wait till we have the column
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 4899a27..d13419d 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -158,9 +158,9 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
referenced;
if (OidIsValid(relOid))
- rel = heap_open(relOid, AccessExclusiveLock);
+ rel = heap_open(relOid, ShareRowExclusiveLock);
else
- rel = heap_openrv(stmt->relation, AccessExclusiveLock);
+ rel = heap_openrv(stmt->relation, ShareRowExclusiveLock);
/*
* Triggers must be on tables or views, and there are additional
diff --git a/src/test/isolation/expected/alter-table-1.out b/src/test/isolation/expected/alter-table-1.out
index edf7288..9daa418 100644
--- a/src/test/isolation/expected/alter-table-1.out
+++ b/src/test/isolation/expected/alter-table-1.out
@@ -703,12 +703,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 sc2 wx rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
@@ -724,12 +723,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -745,12 +743,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -766,12 +763,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -787,12 +783,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -808,12 +803,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -829,12 +823,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -850,12 +843,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -871,12 +863,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -892,12 +883,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -913,12 +903,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -934,12 +923,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -955,12 +943,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -976,12 +963,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -997,12 +983,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -1018,12 +1003,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -1039,12 +1023,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1060,12 +1043,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1081,12 +1063,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1102,12 +1083,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 c2 s2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1123,137 +1103,362 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 sc2 c2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 c2 sc2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 c2 at2 sc2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 at1 rx1 wx rx1 c2 sc1 s2 at2 sc2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 at1 sc1 s2 at2 sc2 wx rx1 c2
-step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx sc2 rx1 c2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 sc2 c2
+starting permutation: s1 at1 rx1 wx rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 c2 sc2
+starting permutation: s1 at1 rx1 wx rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx1 c2
+starting permutation: s1 rx1 at1 sc1 s2 at2 sc2 wx rx1 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx1 sc2 c2
step s1: BEGIN;
@@ -1261,8 +1466,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx1 c2 sc2
step s1: BEGIN;
@@ -1270,8 +1486,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 at2 sc2 c2
step s1: BEGIN;
@@ -1279,8 +1506,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 at2 c2 sc2
step s1: BEGIN;
@@ -1288,8 +1526,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 c2 at2 sc2
step s1: BEGIN;
@@ -1297,8 +1546,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 wx s2 at2 sc2 rx1 c2
step s1: BEGIN;
@@ -1306,8 +1566,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 sc2 c2
step s1: BEGIN;
@@ -1315,189 +1586,548 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 c2 s2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 sc2 c2
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 c2 sc2
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 c2 at2 sc2
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 c2 sc2
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 at1 wx rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 c2 s2 at2 sc2
+starting permutation: s1 rx1 at1 wx rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx1 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 sc2 rx1 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 c2 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1506,14 +2136,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1522,14 +2152,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1538,14 +2168,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 c2 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1554,14 +2184,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 c2 sc1 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1575,197 +2205,181 @@ step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 sc2 rx1 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
-a_id
-
-1
-step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 sc2 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
-a_id
-
-1
-step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 sc2 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 c2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 c2 at2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 c2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 rx1 c2 s2 at2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx rx1 at1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step c2: COMMIT;
+step at1: <... completed>
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx rx1 c2 at1 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 c2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step sc2: COMMIT;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 c2 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
-step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 sc2 c2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1773,63 +2387,78 @@ a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 c2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 c2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 c2 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1837,20 +2466,19 @@ a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 c2 at1 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1858,174 +2486,189 @@ a_id
3
3
3
-step c2: COMMIT;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step sc1: COMMIT;
-step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx1 c2
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx1 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 sc2 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 c2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx1 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 c2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx1 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 c2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 sc2 c2
+starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 c2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 sc1 wx rx1 s2 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2033,8 +2676,19 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 sc1 wx rx1 c2 s2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2042,8 +2696,19 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2051,9 +2716,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2061,9 +2737,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2071,9 +2758,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2081,9 +2779,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2091,9 +2800,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2101,9 +2821,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2111,9 +2842,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2121,9 +2863,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2131,50 +2884,60 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 wx sc1 rx1 c2 s2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 sc2 c2
+starting permutation: rx1 s1 at1 wx sc1 rx1 c2 s2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 c2 sc2
+starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 c2 sc2
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
-3
-3
-3
+1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 sc1 s2 c2 at2 sc2
@@ -2183,14 +2946,8 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 sc1 c2 s2 at2 sc2
@@ -2199,14 +2956,8 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 c2 sc1 s2 at2 sc2
@@ -2215,20 +2966,9 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
-step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
-step sc2: COMMIT;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
starting permutation: rx1 s1 wx at1 sc1 s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
diff --git a/src/test/isolation/isolation_schedule b/src/test/isolation/isolation_schedule
index c055a53..3e2614e 100644
--- a/src/test/isolation/isolation_schedule
+++ b/src/test/isolation/isolation_schedule
@@ -34,4 +34,7 @@ test: skip-locked-3
test: skip-locked-4
test: drop-index-concurrently-1
test: alter-table-1
+test: alter-table-2
+test: alter-table-3
+test: create-trigger
test: timeouts
diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out
index d233710..1f7c265 100644
--- a/src/test/regress/expected/alter_table.out
+++ b/src/test/regress/expected/alter_table.out
@@ -1952,9 +1952,9 @@ create trigger ttdummy
execute procedure
ttdummy (1, 1);
select * from my_locks order by 1;
- relname | max_lockmode
------------+---------------------
- alterlock | AccessExclusiveLock
+ relname | max_lockmode
+-----------+-----------------------
+ alterlock | ShareRowExclusiveLock
(1 row)
rollback;
@@ -1966,10 +1966,10 @@ select * from my_locks order by 1;
alter table alterlock2 add foreign key (f1) references alterlock (f1);
select * from my_locks order by 1;
- relname | max_lockmode
------------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+-----------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
alterlock2_pkey | AccessShareLock
alterlock_pkey | AccessShareLock
(4 rows)
@@ -1979,10 +1979,10 @@ begin;
alter table alterlock2
add constraint alterlock2nv foreign key (f1) references alterlock (f1) NOT VALID;
select * from my_locks order by 1;
- relname | max_lockmode
-------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
(2 rows)
commit;
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 01/22/2015 10:31 PM, Andreas Karlsson wrote:
I agree with this view, and am not sure myself that it is worth lowering
the lock level of ALTER TRIGGER RENAME. I have attached a patch without
the changes to ALTER TRIGGER and ruleutils.c and also fixes the comment
issues noted by Andres.
Whops, forgot to include the isolation tests.
--
Andreas Karlsson
Attachments:
add-fk-lock-strength-v6.patchtext/x-patch; name=add-fk-lock-strength-v6.patchDownload
diff --git a/doc/src/sgml/mvcc.sgml b/doc/src/sgml/mvcc.sgml
index a0d6867..fc86224 100644
--- a/doc/src/sgml/mvcc.sgml
+++ b/doc/src/sgml/mvcc.sgml
@@ -908,9 +908,9 @@ ERROR: could not serialize access due to read/write dependencies among transact
</para>
<para>
- This lock mode is not automatically acquired by any
- <productname>PostgreSQL</productname> command.
- </para>
+ Acquired by <command>CREATE TRIGGER</command> and many forms of
+ <command>ALTER TABLE</command> (see <xref linkend="SQL-ALTERTABLE">).
+ </para>>
</listitem>
</varlistentry>
@@ -957,9 +957,9 @@ ERROR: could not serialize access due to read/write dependencies among transact
<command>TRUNCATE</command>, <command>REINDEX</command>,
<command>CLUSTER</command>, and <command>VACUUM FULL</command>
commands. Many forms of <command>ALTER TABLE</> also acquire
- a lock at this level (see <xref linkend="SQL-ALTERTABLE">).
- This is also the default lock mode for <command>LOCK TABLE</command>
- statements that do not specify a mode explicitly.
+ a lock at this level. This is also the default lock mode for
+ <command>LOCK TABLE</command> statements that do not specify
+ a mode explicitly.
</para>
</listitem>
</varlistentry>
diff --git a/doc/src/sgml/ref/alter_table.sgml b/doc/src/sgml/ref/alter_table.sgml
index b3a4970..f5bbfcd 100644
--- a/doc/src/sgml/ref/alter_table.sgml
+++ b/doc/src/sgml/ref/alter_table.sgml
@@ -406,6 +406,9 @@ ALTER TABLE ALL IN TABLESPACE <replaceable class="PARAMETER">name</replaceable>
mode, and triggers configured as <literal>ENABLE ALWAYS</literal> will
fire regardless of the current replication mode.
</para>
+ <para>
+ This command acquires a <literal>SHARE ROW EXCLUSIVE</literal> lock.
+ </para>
</listitem>
</varlistentry>
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 66d5083..08aa71b 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -2858,13 +2858,8 @@ AlterTableGetLockLevel(List *cmds)
break;
/*
- * These subcommands affect write operations only. XXX
- * Theoretically, these could be ShareRowExclusiveLock.
+ * These subcommands affect write operations only.
*/
- case AT_ColumnDefault:
- case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
- case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
- case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_EnableTrig:
case AT_EnableAlwaysTrig:
case AT_EnableReplicaTrig:
@@ -2873,6 +2868,17 @@ AlterTableGetLockLevel(List *cmds)
case AT_DisableTrig:
case AT_DisableTrigAll:
case AT_DisableTrigUser:
+ cmd_lockmode = ShareRowExclusiveLock;
+ break;
+
+ /*
+ * These subcommands affect write operations only. XXX
+ * Theoretically, these could be ShareRowExclusiveLock.
+ */
+ case AT_ColumnDefault:
+ case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
+ case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
+ case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_AlterConstraint:
case AT_AddIndex: /* from ADD CONSTRAINT */
case AT_AddIndexConstraint:
@@ -2909,11 +2915,9 @@ AlterTableGetLockLevel(List *cmds)
/*
* We add triggers to both tables when we add a
* Foreign Key, so the lock level must be at least
- * as strong as CREATE TRIGGER. XXX Might be set
- * down to ShareRowExclusiveLock though trigger
- * info is accessed by pg_get_triggerdef
+ * as strong as CREATE TRIGGER.
*/
- cmd_lockmode = AccessExclusiveLock;
+ cmd_lockmode = ShareRowExclusiveLock;
break;
default:
@@ -6030,16 +6034,13 @@ ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
ListCell *old_pfeqop_item = list_head(fkconstraint->old_conpfeqop);
/*
- * Grab an exclusive lock on the pk table, so that someone doesn't delete
- * rows out from under us. (Although a lesser lock would do for that
- * purpose, we'll need exclusive lock anyway to add triggers to the pk
- * table; trying to start with a lesser lock will just create a risk of
- * deadlock.)
+ * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't
+ * delete rows out from under us.
*/
if (OidIsValid(fkconstraint->old_pktable_oid))
- pkrel = heap_open(fkconstraint->old_pktable_oid, AccessExclusiveLock);
+ pkrel = heap_open(fkconstraint->old_pktable_oid, ShareRowExclusiveLock);
else
- pkrel = heap_openrv(fkconstraint->pktable, AccessExclusiveLock);
+ pkrel = heap_openrv(fkconstraint->pktable, ShareRowExclusiveLock);
/*
* Validity checks (permission checks wait till we have the column
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 4899a27..d13419d 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -158,9 +158,9 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
referenced;
if (OidIsValid(relOid))
- rel = heap_open(relOid, AccessExclusiveLock);
+ rel = heap_open(relOid, ShareRowExclusiveLock);
else
- rel = heap_openrv(stmt->relation, AccessExclusiveLock);
+ rel = heap_openrv(stmt->relation, ShareRowExclusiveLock);
/*
* Triggers must be on tables or views, and there are additional
diff --git a/src/test/isolation/expected/alter-table-1.out b/src/test/isolation/expected/alter-table-1.out
index edf7288..9daa418 100644
--- a/src/test/isolation/expected/alter-table-1.out
+++ b/src/test/isolation/expected/alter-table-1.out
@@ -703,12 +703,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 sc2 wx rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
@@ -724,12 +723,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -745,12 +743,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -766,12 +763,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -787,12 +783,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -808,12 +803,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -829,12 +823,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -850,12 +843,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -871,12 +863,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -892,12 +883,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -913,12 +903,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -934,12 +923,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -955,12 +943,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -976,12 +963,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -997,12 +983,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -1018,12 +1003,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -1039,12 +1023,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1060,12 +1043,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1081,12 +1063,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1102,12 +1083,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 c2 s2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1123,137 +1103,362 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 sc2 c2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 c2 sc2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 c2 at2 sc2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 at1 rx1 wx rx1 c2 sc1 s2 at2 sc2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 at1 sc1 s2 at2 sc2 wx rx1 c2
-step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx sc2 rx1 c2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 sc2 c2
+starting permutation: s1 at1 rx1 wx rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 c2 sc2
+starting permutation: s1 at1 rx1 wx rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx1 c2
+starting permutation: s1 rx1 at1 sc1 s2 at2 sc2 wx rx1 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx1 sc2 c2
step s1: BEGIN;
@@ -1261,8 +1466,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx1 c2 sc2
step s1: BEGIN;
@@ -1270,8 +1486,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 at2 sc2 c2
step s1: BEGIN;
@@ -1279,8 +1506,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 at2 c2 sc2
step s1: BEGIN;
@@ -1288,8 +1526,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 c2 at2 sc2
step s1: BEGIN;
@@ -1297,8 +1546,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 wx s2 at2 sc2 rx1 c2
step s1: BEGIN;
@@ -1306,8 +1566,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 sc2 c2
step s1: BEGIN;
@@ -1315,189 +1586,548 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 c2 s2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 sc2 c2
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 c2 sc2
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 c2 at2 sc2
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 c2 sc2
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 at1 wx rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 c2 s2 at2 sc2
+starting permutation: s1 rx1 at1 wx rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx1 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 sc2 rx1 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 c2 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1506,14 +2136,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1522,14 +2152,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1538,14 +2168,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 c2 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1554,14 +2184,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 c2 sc1 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1575,197 +2205,181 @@ step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 sc2 rx1 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
-a_id
-
-1
-step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 sc2 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
-a_id
-
-1
-step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 sc2 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 c2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 c2 at2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 c2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 rx1 c2 s2 at2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx rx1 at1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step c2: COMMIT;
+step at1: <... completed>
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx rx1 c2 at1 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 c2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step sc2: COMMIT;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 c2 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
-step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 sc2 c2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1773,63 +2387,78 @@ a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 c2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 c2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 c2 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1837,20 +2466,19 @@ a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 c2 at1 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1858,174 +2486,189 @@ a_id
3
3
3
-step c2: COMMIT;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step sc1: COMMIT;
-step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx1 c2
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx1 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 sc2 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 c2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx1 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 c2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx1 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 c2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 sc2 c2
+starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 c2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 sc1 wx rx1 s2 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2033,8 +2676,19 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 sc1 wx rx1 c2 s2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2042,8 +2696,19 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2051,9 +2716,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2061,9 +2737,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2071,9 +2758,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2081,9 +2779,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2091,9 +2800,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2101,9 +2821,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2111,9 +2842,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2121,9 +2863,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2131,50 +2884,60 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 wx sc1 rx1 c2 s2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 sc2 c2
+starting permutation: rx1 s1 at1 wx sc1 rx1 c2 s2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 c2 sc2
+starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 c2 sc2
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
-3
-3
-3
+1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 sc1 s2 c2 at2 sc2
@@ -2183,14 +2946,8 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 sc1 c2 s2 at2 sc2
@@ -2199,14 +2956,8 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 c2 sc1 s2 at2 sc2
@@ -2215,20 +2966,9 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
-step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
-step sc2: COMMIT;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
starting permutation: rx1 s1 wx at1 sc1 s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
diff --git a/src/test/isolation/expected/alter-table-2.out b/src/test/isolation/expected/alter-table-2.out
new file mode 100644
index 0000000..cef7516
--- /dev/null
+++ b/src/test/isolation/expected/alter-table-2.out
@@ -0,0 +1,1389 @@
+Parsed test spec with 2 sessions
+
+starting permutation: s1a s1b s1c s2a s2b s2c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s1c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s2d s1c s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s2d s2e s1c s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s2c s2d s2e s2f s1c
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s1c s2b s2c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s1c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s2d s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s2d s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s2c s2d s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s1c s2c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s1c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s2d s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s2d s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s2c s2d s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s1c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s2d s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s2d s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s2d s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s1b s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s1b s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s1b s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s2e s1b s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s2e s1b s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s2e s2f s1b s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s1c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s2d s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s2d s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s2c s2d s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s1c s2c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s1c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s2d s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s2d s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s2c s2d s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s1c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s2d s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s2d s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s2d s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s1b s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s1b s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s1b s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s2e s1b s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s2e s1b s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s2e s2f s1b s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s1c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s2d s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s2d s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s1b s2c s2d s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s1c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s2d s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s2d s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s2d s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s1b s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s1b s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s1b s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s2e s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s2e s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s2e s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s2d s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s2d s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s1b s2d s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s1b s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s1b s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s1b s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s2e s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s2e s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s2e s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s1b s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s1a s1b s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s1a s1b s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s2e s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s1a s2e s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s2e s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s2e s1a s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s2e s1a s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s2e s1a s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1a: BEGIN;
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s2e s2f s1a s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
diff --git a/src/test/isolation/expected/alter-table-3.out b/src/test/isolation/expected/alter-table-3.out
new file mode 100644
index 0000000..7dc64df
--- /dev/null
+++ b/src/test/isolation/expected/alter-table-3.out
@@ -0,0 +1,947 @@
+Parsed test spec with 2 sessions
+
+starting permutation: s1a s1b s1c s1d s2a s2b s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s1d s2b s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s2b s1d s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s2b s2c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s2b s2c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s1c s1d s2b s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s1d s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s1c s1d s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s2c s1c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s1c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s2c s2d s1c s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s1c s1d s2b s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s1c s2b s1d s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s1c s2b s2c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s1c s2b s2c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s1c s1d s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s2c s1c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s1c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s2c s2d s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s1c s1d s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s1c s2c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s1c s2c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s2c s1c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s1c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s2c s2d s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s1c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s1c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s2d s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s1b s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s1d s2b s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s1d s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s1c s1d s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s2c s1c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s1c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s2c s2d s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s1c s1d s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s1c s2c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s1c s2c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s2c s1c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s1c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s2c s2d s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s1c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s1c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s2d s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s1b s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s1d s2c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s1b s2c s1c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s1c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s1b s2c s2d s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s1c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s1c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s2d s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s1b s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s2d s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s1b s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s1b s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
diff --git a/src/test/isolation/expected/create-trigger.out b/src/test/isolation/expected/create-trigger.out
new file mode 100644
index 0000000..e8bb740
--- /dev/null
+++ b/src/test/isolation/expected/create-trigger.out
@@ -0,0 +1,421 @@
+Parsed test spec with 2 sessions
+
+starting permutation: s1a s1b s1c s2a s2b s2c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s1c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s2d s1c
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s1c s2b s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s1c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s2d s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s1c s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s1c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s2d s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s1c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s2d s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s1b s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s1c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s2d s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s1c s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s1c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s2d s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s1c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s2d s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s1b s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s1c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s2d s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s1c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s2d s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s1b s2d s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1a: BEGIN;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
diff --git a/src/test/isolation/isolation_schedule b/src/test/isolation/isolation_schedule
index c055a53..3e2614e 100644
--- a/src/test/isolation/isolation_schedule
+++ b/src/test/isolation/isolation_schedule
@@ -34,4 +34,7 @@ test: skip-locked-3
test: skip-locked-4
test: drop-index-concurrently-1
test: alter-table-1
+test: alter-table-2
+test: alter-table-3
+test: create-trigger
test: timeouts
diff --git a/src/test/isolation/specs/alter-table-2.spec b/src/test/isolation/specs/alter-table-2.spec
new file mode 100644
index 0000000..e6a02e0
--- /dev/null
+++ b/src/test/isolation/specs/alter-table-2.spec
@@ -0,0 +1,30 @@
+# ALTER TABLE - Add foreign keys with concurrent reads
+#
+# ADD CONSTRAINT uses ShareRowExclusiveLock so we mix writes with it
+# to see what works or waits.
+
+setup
+{
+ CREATE TABLE a (i int PRIMARY KEY);
+ CREATE TABLE b (a_id int);
+ INSERT INTO a VALUES (0), (1), (2), (3);
+ INSERT INTO b SELECT generate_series(1,1000) % 4;
+}
+
+teardown
+{
+ DROP TABLE a, b;
+}
+
+session "s1"
+step "s1a" { BEGIN; }
+step "s1b" { ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; }
+step "s1c" { COMMIT; }
+
+session "s2"
+step "s2a" { BEGIN; }
+step "s2b" { SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; }
+step "s2c" { SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; }
+step "s2d" { INSERT INTO b VALUES (0); }
+step "s2e" { INSERT INTO a VALUES (4); }
+step "s2f" { COMMIT; }
diff --git a/src/test/isolation/specs/alter-table-3.spec b/src/test/isolation/specs/alter-table-3.spec
new file mode 100644
index 0000000..d252620
--- /dev/null
+++ b/src/test/isolation/specs/alter-table-3.spec
@@ -0,0 +1,30 @@
+# ALTER TABLE - Enable and disable triggers with concurrent reads
+#
+# ENABLE/DISABLE TRIGGER uses ShareRowExclusiveLock so we mix writes with
+# it to see what works or waits.
+
+setup
+{
+ CREATE TABLE a (i int PRIMARY KEY);
+ INSERT INTO a VALUES (0), (1), (2), (3);
+ CREATE FUNCTION f() RETURNS TRIGGER LANGUAGE plpgsql AS 'BEGIN RETURN NULL; END;';
+ CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+}
+
+teardown
+{
+ DROP TABLE a;
+ DROP FUNCTION f();
+}
+
+session "s1"
+step "s1a" { BEGIN; }
+step "s1b" { ALTER TABLE a DISABLE TRIGGER t; }
+step "s1c" { ALTER TABLE a ENABLE TRIGGER t; }
+step "s1d" { COMMIT; }
+
+session "s2"
+step "s2a" { BEGIN; }
+step "s2b" { SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; }
+step "s2c" { INSERT INTO a VALUES (0); }
+step "s2d" { COMMIT; }
diff --git a/src/test/isolation/specs/create-trigger.spec b/src/test/isolation/specs/create-trigger.spec
new file mode 100644
index 0000000..34fad75
--- /dev/null
+++ b/src/test/isolation/specs/create-trigger.spec
@@ -0,0 +1,28 @@
+# CREATE TRIGGER - Add trigger with concurrent reads
+#
+# CREATE TRIGGER uses ShareRowExclusiveLock so we mix writes with it
+# to see what works or waits.
+
+setup
+{
+ CREATE TABLE a (i int);
+ CREATE FUNCTION f() RETURNS TRIGGER LANGUAGE plpgsql AS 'BEGIN RETURN NULL; END;';
+ INSERT INTO a VALUES (0), (1), (2), (3);
+}
+
+teardown
+{
+ DROP TABLE a;
+ DROP FUNCTION f();
+}
+
+session "s1"
+step "s1a" { BEGIN; }
+step "s1b" { CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); }
+step "s1c" { COMMIT; }
+
+session "s2"
+step "s2a" { BEGIN; }
+step "s2b" { SELECT * FROM a WHERE i = 1 FOR UPDATE; }
+step "s2c" { UPDATE a SET i = 4 WHERE i = 3; }
+step "s2d" { COMMIT; }
diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out
index d233710..1f7c265 100644
--- a/src/test/regress/expected/alter_table.out
+++ b/src/test/regress/expected/alter_table.out
@@ -1952,9 +1952,9 @@ create trigger ttdummy
execute procedure
ttdummy (1, 1);
select * from my_locks order by 1;
- relname | max_lockmode
------------+---------------------
- alterlock | AccessExclusiveLock
+ relname | max_lockmode
+-----------+-----------------------
+ alterlock | ShareRowExclusiveLock
(1 row)
rollback;
@@ -1966,10 +1966,10 @@ select * from my_locks order by 1;
alter table alterlock2 add foreign key (f1) references alterlock (f1);
select * from my_locks order by 1;
- relname | max_lockmode
------------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+-----------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
alterlock2_pkey | AccessShareLock
alterlock_pkey | AccessShareLock
(4 rows)
@@ -1979,10 +1979,10 @@ begin;
alter table alterlock2
add constraint alterlock2nv foreign key (f1) references alterlock (f1) NOT VALID;
select * from my_locks order by 1;
- relname | max_lockmode
-------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
(2 rows)
commit;
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On Fri, Jan 23, 2015 at 8:55 AM, Andreas Karlsson <andreas@proxel.se> wrote:
On 01/22/2015 10:31 PM, Andreas Karlsson wrote:
I agree with this view, and am not sure myself that it is worth lowering
the lock level of ALTER TRIGGER RENAME. I have attached a patch without
the changes to ALTER TRIGGER and ruleutils.c and also fixes the comment
issues noted by Andres.Whops, forgot to include the isolation tests.
Ok, so the deal is to finally reduce the locks to
ShareRowExclusiveLock for the following commands :
- CREATE TRIGGER
- ALTER TABLE ENABLE/DISABLE
- ALTER TABLE ADD CONSTRAINT
Looking at the latest patch, it seems that in
AlterTableGetLockLevel@tablecmds.c we ought to put AT_ReAddConstraint,
AT_AddConstraintRecurse and AT_ProcessedConstraint under the same
banner as AT_AddConstraint. Thoughts?
--
Michael
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 01/30/2015 07:48 AM, Michael Paquier wrote:
Ok, so the deal is to finally reduce the locks to
ShareRowExclusiveLock for the following commands :
- CREATE TRIGGER
- ALTER TABLE ENABLE/DISABLE
- ALTER TABLE ADD CONSTRAINT
Correct. I personally still find this useful enough to justify a patch.
Looking at the latest patch, it seems that in
AlterTableGetLockLevel@tablecmds.c we ought to put AT_ReAddConstraint,
AT_AddConstraintRecurse and AT_ProcessedConstraint under the same
banner as AT_AddConstraint. Thoughts?
Good point. I think moving those would be a good thing even though it is
technically not necessary for AT_AddConstraintRecurse, since that one
should only be related to check constraints.
--
Andreas
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On Fri, Jan 30, 2015 at 10:26 PM, Andreas Karlsson wrote:
On 01/30/2015 07:48 AM, Michael Paquier wrote:
Looking at the latest patch, it seems that in
AlterTableGetLockLevel@tablecmds.c we ought to put AT_ReAddConstraint,
AT_AddConstraintRecurse and AT_ProcessedConstraint under the same
banner as AT_AddConstraint. Thoughts?Good point. I think moving those would be a good thing even though it is
technically not necessary for AT_AddConstraintRecurse, since that one should
only be related to check constraints.
Andreas, are you planning to send an updated patch?
--
Michael
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 02/06/2015 08:16 AM, Michael Paquier wrote:
On Fri, Jan 30, 2015 at 10:26 PM, Andreas Karlsson wrote:
On 01/30/2015 07:48 AM, Michael Paquier wrote:
Looking at the latest patch, it seems that in
AlterTableGetLockLevel@tablecmds.c we ought to put AT_ReAddConstraint,
AT_AddConstraintRecurse and AT_ProcessedConstraint under the same
banner as AT_AddConstraint. Thoughts?Good point. I think moving those would be a good thing even though it is
technically not necessary for AT_AddConstraintRecurse, since that one should
only be related to check constraints.Andreas, are you planning to send an updated patch?
Yes, I will hopefully send it later today or tomorrow.
Andreas
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 01/30/2015 07:48 AM, Michael Paquier wrote:
Looking at the latest patch, it seems that in
AlterTableGetLockLevel@tablecmds.c we ought to put AT_ReAddConstraint,
AT_AddConstraintRecurse and AT_ProcessedConstraint under the same
banner as AT_AddConstraint. Thoughts?
A new version of the patch is attached which treats them as the same for
locking. I think it is correct and improves readability to do so.
--
Andreas Karlsson
Attachments:
add-fk-lock-strength-v7.patchtext/x-patch; name=add-fk-lock-strength-v7.patchDownload
diff --git a/doc/src/sgml/mvcc.sgml b/doc/src/sgml/mvcc.sgml
index a0d6867..fc86224 100644
--- a/doc/src/sgml/mvcc.sgml
+++ b/doc/src/sgml/mvcc.sgml
@@ -908,9 +908,9 @@ ERROR: could not serialize access due to read/write dependencies among transact
</para>
<para>
- This lock mode is not automatically acquired by any
- <productname>PostgreSQL</productname> command.
- </para>
+ Acquired by <command>CREATE TRIGGER</command> and many forms of
+ <command>ALTER TABLE</command> (see <xref linkend="SQL-ALTERTABLE">).
+ </para>>
</listitem>
</varlistentry>
@@ -957,9 +957,9 @@ ERROR: could not serialize access due to read/write dependencies among transact
<command>TRUNCATE</command>, <command>REINDEX</command>,
<command>CLUSTER</command>, and <command>VACUUM FULL</command>
commands. Many forms of <command>ALTER TABLE</> also acquire
- a lock at this level (see <xref linkend="SQL-ALTERTABLE">).
- This is also the default lock mode for <command>LOCK TABLE</command>
- statements that do not specify a mode explicitly.
+ a lock at this level. This is also the default lock mode for
+ <command>LOCK TABLE</command> statements that do not specify
+ a mode explicitly.
</para>
</listitem>
</varlistentry>
diff --git a/doc/src/sgml/ref/alter_table.sgml b/doc/src/sgml/ref/alter_table.sgml
index b3a4970..f5bbfcd 100644
--- a/doc/src/sgml/ref/alter_table.sgml
+++ b/doc/src/sgml/ref/alter_table.sgml
@@ -406,6 +406,9 @@ ALTER TABLE ALL IN TABLESPACE <replaceable class="PARAMETER">name</replaceable>
mode, and triggers configured as <literal>ENABLE ALWAYS</literal> will
fire regardless of the current replication mode.
</para>
+ <para>
+ This command acquires a <literal>SHARE ROW EXCLUSIVE</literal> lock.
+ </para>
</listitem>
</varlistentry>
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 66d5083..7cf0b88 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -2858,13 +2858,8 @@ AlterTableGetLockLevel(List *cmds)
break;
/*
- * These subcommands affect write operations only. XXX
- * Theoretically, these could be ShareRowExclusiveLock.
+ * These subcommands affect write operations only.
*/
- case AT_ColumnDefault:
- case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
- case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
- case AT_ReAddConstraint: /* becomes AT_AddConstraint */
case AT_EnableTrig:
case AT_EnableAlwaysTrig:
case AT_EnableReplicaTrig:
@@ -2873,6 +2868,14 @@ AlterTableGetLockLevel(List *cmds)
case AT_DisableTrig:
case AT_DisableTrigAll:
case AT_DisableTrigUser:
+ cmd_lockmode = ShareRowExclusiveLock;
+ break;
+
+ /*
+ * These subcommands affect write operations only. XXX
+ * Theoretically, these could be ShareRowExclusiveLock.
+ */
+ case AT_ColumnDefault:
case AT_AlterConstraint:
case AT_AddIndex: /* from ADD CONSTRAINT */
case AT_AddIndexConstraint:
@@ -2884,6 +2887,9 @@ AlterTableGetLockLevel(List *cmds)
break;
case AT_AddConstraint:
+ case AT_ProcessedConstraint: /* becomes AT_AddConstraint */
+ case AT_AddConstraintRecurse: /* becomes AT_AddConstraint */
+ case AT_ReAddConstraint: /* becomes AT_AddConstraint */
if (IsA(cmd->def, Constraint))
{
Constraint *con = (Constraint *) cmd->def;
@@ -2909,11 +2915,9 @@ AlterTableGetLockLevel(List *cmds)
/*
* We add triggers to both tables when we add a
* Foreign Key, so the lock level must be at least
- * as strong as CREATE TRIGGER. XXX Might be set
- * down to ShareRowExclusiveLock though trigger
- * info is accessed by pg_get_triggerdef
+ * as strong as CREATE TRIGGER.
*/
- cmd_lockmode = AccessExclusiveLock;
+ cmd_lockmode = ShareRowExclusiveLock;
break;
default:
@@ -6030,16 +6034,13 @@ ATAddForeignKeyConstraint(AlteredTableInfo *tab, Relation rel,
ListCell *old_pfeqop_item = list_head(fkconstraint->old_conpfeqop);
/*
- * Grab an exclusive lock on the pk table, so that someone doesn't delete
- * rows out from under us. (Although a lesser lock would do for that
- * purpose, we'll need exclusive lock anyway to add triggers to the pk
- * table; trying to start with a lesser lock will just create a risk of
- * deadlock.)
+ * Grab ShareRowExclusiveLock on the pk table, so that someone doesn't
+ * delete rows out from under us.
*/
if (OidIsValid(fkconstraint->old_pktable_oid))
- pkrel = heap_open(fkconstraint->old_pktable_oid, AccessExclusiveLock);
+ pkrel = heap_open(fkconstraint->old_pktable_oid, ShareRowExclusiveLock);
else
- pkrel = heap_openrv(fkconstraint->pktable, AccessExclusiveLock);
+ pkrel = heap_openrv(fkconstraint->pktable, ShareRowExclusiveLock);
/*
* Validity checks (permission checks wait till we have the column
diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 5c1c1be..f4e0eb5 100644
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -164,9 +164,9 @@ CreateTrigger(CreateTrigStmt *stmt, const char *queryString,
referenced;
if (OidIsValid(relOid))
- rel = heap_open(relOid, AccessExclusiveLock);
+ rel = heap_open(relOid, ShareRowExclusiveLock);
else
- rel = heap_openrv(stmt->relation, AccessExclusiveLock);
+ rel = heap_openrv(stmt->relation, ShareRowExclusiveLock);
/*
* Triggers must be on tables or views, and there are additional
diff --git a/src/test/isolation/expected/alter-table-1.out b/src/test/isolation/expected/alter-table-1.out
index edf7288..9daa418 100644
--- a/src/test/isolation/expected/alter-table-1.out
+++ b/src/test/isolation/expected/alter-table-1.out
@@ -703,12 +703,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 sc2 wx rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
@@ -724,12 +723,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -745,12 +743,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -766,12 +763,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 at2 wx rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
@@ -787,12 +783,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -808,12 +803,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -829,12 +823,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -850,12 +843,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -871,12 +863,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -892,12 +883,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 s2 wx rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -913,12 +903,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -934,12 +923,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -955,12 +943,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
@@ -976,12 +963,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -997,12 +983,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -1018,12 +1003,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx s2 rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step s2: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
@@ -1039,12 +1023,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1060,12 +1043,11 @@ step c2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1081,12 +1063,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 s2 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1102,12 +1083,11 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 sc1 wx rx1 c2 s2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-step sc1: COMMIT;
-step rx1: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step sc1: COMMIT;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1123,137 +1103,362 @@ step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 sc2 rx1 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx1 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 at2 rx1 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 s2 rx1 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 at1 rx1 wx sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 sc2 c2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 c2 sc2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 at1 rx1 wx rx1 sc1 s2 c2 at2 sc2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
-starting permutation: s1 at1 rx1 wx rx1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
+1
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 at1 rx1 wx rx1 c2 sc1 s2 at2 sc2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 at1 sc1 s2 at2 sc2 wx rx1 c2
-step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx sc2 rx1 c2
+starting permutation: s1 at1 rx1 wx rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 sc2 c2
+starting permutation: s1 at1 rx1 wx rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 c2 sc2
+starting permutation: s1 at1 rx1 wx rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx1 c2
+starting permutation: s1 rx1 at1 sc1 s2 at2 sc2 wx rx1 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 at2 wx rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 s2 wx at2 sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx1 sc2 c2
step s1: BEGIN;
@@ -1261,8 +1466,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx at2 rx1 c2 sc2
step s1: BEGIN;
@@ -1270,8 +1486,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 at2 sc2 c2
step s1: BEGIN;
@@ -1279,8 +1506,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 at2 c2 sc2
step s1: BEGIN;
@@ -1288,8 +1526,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 s2 wx rx1 c2 at2 sc2
step s1: BEGIN;
@@ -1297,8 +1546,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: s1 rx1 at1 sc1 wx s2 at2 sc2 rx1 c2
step s1: BEGIN;
@@ -1306,8 +1566,19 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 sc2 c2
step s1: BEGIN;
@@ -1315,189 +1586,548 @@ step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx s2 rx1 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 s2 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 sc1 wx rx1 c2 s2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx1 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 c2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 s2 rx1 c2 at2 sc2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 sc2 c2
+step s1: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+a_id
+
+1
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 at1 sc1 wx s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 sc2 c2
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 at2 c2 sc2
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
-starting permutation: s1 rx1 at1 sc1 wx s2 rx1 c2 at2 sc2
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 at2 c2 sc2
+starting permutation: s1 rx1 at1 wx rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 at1 wx rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 sc1 wx rx1 c2 s2 at2 sc2
+starting permutation: s1 rx1 at1 wx rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 sc2 rx1 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 sc2 rx1 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 s2 rx1 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 s2 rx1 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx sc1 rx1 c2 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 sc1 rx1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1506,14 +2136,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1522,14 +2152,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1538,14 +2168,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 sc1 c2 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1554,14 +2184,14 @@ a_id
3
invalid permutation detected
-starting permutation: s1 rx1 at1 wx rx1 c2 sc1 s2 at2 sc2
+starting permutation: s1 rx1 wx at1 rx1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1575,197 +2205,181 @@ step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 sc2 rx1 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
-a_id
-
-1
-step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 sc2 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
-a_id
-
-1
-step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 at2 rx1 c2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 sc2 c2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 sc2 c2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 at2 c2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 c2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 s2 rx1 c2 at2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx rx1 at1 sc1 s2 c2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 at2 c2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 sc1 rx1 s2 c2 at2 sc2
+starting permutation: s1 rx1 wx rx1 at1 sc1 c2 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: s1 rx1 wx at1 sc1 rx1 c2 s2 at2 sc2
-step s1: BEGIN;
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step wx: INSERT INTO b VALUES (0);
+3
+3
+3
step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
invalid permutation detected
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 sc2 c2
+starting permutation: s1 rx1 wx rx1 at1 c2 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step c2: COMMIT;
+step at1: <... completed>
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 at2 c2 sc2
+starting permutation: s1 rx1 wx rx1 c2 at1 sc1 s2 at2 sc2
step s1: BEGIN;
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 s2 c2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step sc2: COMMIT;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx at1 rx1 c2 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
-step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 sc2 c2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1773,63 +2387,78 @@ a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 at2 c2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 s2 c2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 sc1 c2 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: s1 rx1 wx rx1 at1 c2 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1837,20 +2466,19 @@ a_id
3
3
3
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: s1 rx1 wx rx1 c2 at1 sc1 s2 at2 sc2
-step s1: BEGIN;
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
step wx: INSERT INTO b VALUES (0);
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
@@ -1858,174 +2486,189 @@ a_id
3
3
3
-step c2: COMMIT;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
-step sc1: COMMIT;
-step s2: BEGIN;
step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 at2 sc2 wx rx1 c2
+starting permutation: rx1 s1 at1 sc1 s2 wx rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx sc2 rx1 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step s2: BEGIN;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 sc2 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 at2 wx rx1 c2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 sc2 rx1 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx at2 rx1 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 at2 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 s2 wx rx1 c2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 sc2 rx1 c2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 at2 rx1 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx s2 rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 sc2 c2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 at2 c2 sc2
+starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx s2 rx1 c2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
-starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 sc2 c2
+starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 sc1 wx rx1 s2 at2 c2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 sc1 wx rx1 s2 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2033,8 +2676,19 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 sc1 wx rx1 c2 s2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2042,8 +2696,19 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step sc1: COMMIT;
+step wx: INSERT INTO b VALUES (0);
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2051,9 +2716,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx1 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2061,9 +2737,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 at2 rx1 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2071,9 +2758,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2081,9 +2779,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2091,9 +2800,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 s2 rx1 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2101,9 +2821,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step s2: BEGIN;
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2111,9 +2842,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
+step c2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 at2 c2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2121,9 +2863,20 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+a_id
+
+3
+3
+3
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step c2: COMMIT;
+step sc2: COMMIT;
starting permutation: rx1 s1 at1 wx sc1 rx1 s2 c2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
@@ -2131,50 +2884,60 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
-
-starting permutation: rx1 s1 at1 wx sc1 rx1 c2 s2 at2 sc2
-step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
+step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
-1
-step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-invalid permutation detected
+3
+3
+3
+step s2: BEGIN;
+step c2: COMMIT;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 sc2 c2
+starting permutation: rx1 s1 at1 wx sc1 rx1 c2 s2 at2 sc2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+step sc1: COMMIT;
+step wx: <... completed>
step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
a_id
3
3
3
-invalid permutation detected
+step c2: COMMIT;
+step s2: BEGIN;
+step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
+step sc2: COMMIT;
-starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 c2 sc2
+starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 sc2 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: rx1 s1 at1 wx rx1 sc1 s2 at2 c2 sc2
+step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
a_id
-3
-3
-3
+1
+step s1: BEGIN;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 sc1 s2 c2 at2 sc2
@@ -2183,14 +2946,8 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 sc1 c2 s2 at2 sc2
@@ -2199,14 +2956,8 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
invalid permutation detected
starting permutation: rx1 s1 at1 wx rx1 c2 sc1 s2 at2 sc2
@@ -2215,20 +2966,9 @@ a_id
1
step s1: BEGIN;
-step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
-step wx: INSERT INTO b VALUES (0);
-step rx1: SELECT * FROM b WHERE a_id = 3 LIMIT 3;
-a_id
-
-3
-3
-3
-step c2: COMMIT;
-step at1: <... completed>
-step sc1: COMMIT;
-step s2: BEGIN;
-step at2: ALTER TABLE b VALIDATE CONSTRAINT bfk;
-step sc2: COMMIT;
+step at1: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step wx: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
starting permutation: rx1 s1 wx at1 sc1 s2 at2 sc2 rx1 c2
step rx1: SELECT * FROM b WHERE a_id = 1 LIMIT 1;
diff --git a/src/test/isolation/expected/alter-table-2.out b/src/test/isolation/expected/alter-table-2.out
new file mode 100644
index 0000000..cef7516
--- /dev/null
+++ b/src/test/isolation/expected/alter-table-2.out
@@ -0,0 +1,1389 @@
+Parsed test spec with 2 sessions
+
+starting permutation: s1a s1b s1c s2a s2b s2c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s1c s2d s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s2d s1c s2e s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s2d s2e s1c s2f
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s2c s2d s2e s2f s1c
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s1c s2b s2c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s1c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s2d s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s2d s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s2c s2d s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s1c s2c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s1c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s2d s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s2d s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s2c s2d s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s1c s2d s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s2d s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s2d s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s2d s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s1b s1c s2e s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s1b s2e s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s1b s2e s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s2e s1b s1c s2f
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s2d s2e s1b s2f s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s2e s2f s1b s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s1c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s2d s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s2d s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s2c s2d s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s1c s2c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s1c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s2d s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s2d s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s2c s2d s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s1c s2d s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s2d s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s2d s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s2d s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s1b s1c s2e s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s1b s2e s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s1b s2e s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s2e s1b s1c s2f
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s2d s2e s1b s2f s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s2e s2f s1b s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s1c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s2d s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s2d s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s1b s2c s2d s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s1c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s2d s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s2d s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s2d s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s1b s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s1b s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s1b s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s2e s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s2d s2e s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s2e s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s2d s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s2d s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+step s1c: COMMIT;
+step s2d: <... completed>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s2d s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s1b s2d s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s2d: INSERT INTO b VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s1b s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s1b s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s1b s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s2e s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s2d s2e s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s2e s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s1a: BEGIN;
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s1b s1c s2e s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s1a s1b s2e s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s1a s1b s2e s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s2e s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s1a s2e s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s2e: INSERT INTO a VALUES (4);
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s2e s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s1a: BEGIN;
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s2e s1a s1b s1c s2f
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s2d s2e s1a s1b s2f s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; <waiting ...>
+step s2f: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s2e s1a s2f s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s1a: BEGIN;
+step s2f: COMMIT;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s2e s2f s1a s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE;
+a_id
+
+3
+step s2d: INSERT INTO b VALUES (0);
+step s2e: INSERT INTO a VALUES (4);
+step s2f: COMMIT;
+step s1a: BEGIN;
+step s1b: ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID;
+step s1c: COMMIT;
diff --git a/src/test/isolation/expected/alter-table-3.out b/src/test/isolation/expected/alter-table-3.out
new file mode 100644
index 0000000..7dc64df
--- /dev/null
+++ b/src/test/isolation/expected/alter-table-3.out
@@ -0,0 +1,947 @@
+Parsed test spec with 2 sessions
+
+starting permutation: s1a s1b s1c s1d s2a s2b s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s1d s2b s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s2b s1d s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s2b s2c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s1c s2a s2b s2c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s1c s1d s2b s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s1d s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s1c s1d s2c s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s2c s1c s1d s2d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s1c s2d s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s1a s1b s2a s2b s2c s2d s1c s1d
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s1c s1d s2b s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s1c s2b s1d s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s1c s2b s2c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s1c s2b s2c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s1c s1d s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s2c s1c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s1c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s2b s2c s2d s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s1c s1d s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s1c s2c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s1c s2c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s2c s1c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s1c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s2c s2d s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s1c s1d s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s1c s2d s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s1b s2d s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s1b s1c s1d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s1d s2b s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s1d s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s1c s1d s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s2c s1c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s1c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s2a s1a s1b s2b s2c s2d s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s1c s1d s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s1c s2c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s1c s2c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s2c s1c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s1c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s2c s2d s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s1c s1d s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s1c s2d s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s1b s2d s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s1b s1c s1d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s1d s2c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s1b s2c s1c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2c: <... completed>
+error in steps s1d s2c: ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s1c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s1b s2c s2d s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2c: INSERT INTO a VALUES (0); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s1c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s1c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s1b s2d s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s1b s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s1d s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s2d s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s2d: COMMIT;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s2d s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s2d: COMMIT;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s1b s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s1a: BEGIN;
+step s2d: COMMIT;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s1b s1c s1d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE;
+i
+
+1
+step s2c: INSERT INTO a VALUES (0);
+ERROR: duplicate key value violates unique constraint "a_pkey"
+step s2d: COMMIT;
+step s1a: BEGIN;
+step s1b: ALTER TABLE a DISABLE TRIGGER t;
+step s1c: ALTER TABLE a ENABLE TRIGGER t;
+step s1d: COMMIT;
diff --git a/src/test/isolation/expected/create-trigger.out b/src/test/isolation/expected/create-trigger.out
new file mode 100644
index 0000000..e8bb740
--- /dev/null
+++ b/src/test/isolation/expected/create-trigger.out
@@ -0,0 +1,421 @@
+Parsed test spec with 2 sessions
+
+starting permutation: s1a s1b s1c s2a s2b s2c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s1c s2b s2c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s1c s2c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s1c s2d
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s1a s1b s2a s2b s2c s2d s1c
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s1b s1c s2b s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s1c s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s1c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s1b s2b s2c s2d s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s1b s1c s2c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s1c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s1a s2a s2b s1b s2c s2d s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s1c s2d
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s1a s2a s2b s2c s1b s2d s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s1a s2a s2b s2c s2d s1b s1c
+step s1a: BEGIN;
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s1b s1c s2b s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s1c s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s1c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s1b s2b s2c s2d s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s1b s1c s2c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s1c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s2a s1a s2b s1b s2c s2d s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s1c s2d
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s1a s2b s2c s1b s2d s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s1a s2b s2c s2d s1b s1c
+step s2a: BEGIN;
+step s1a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s1c s2c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s1c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+step s1c: COMMIT;
+step s2c: <... completed>
+step s2d: COMMIT;
+
+starting permutation: s2a s2b s1a s1b s2c s2d s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s2c: UPDATE a SET i = 4 WHERE i = 3; <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s1c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s1a s2c s1b s2d s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s1a s2c s2d s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s1a: BEGIN;
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s1b s1c s2d
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+invalid permutation detected
+
+starting permutation: s2a s2b s2c s1a s1b s2d s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); <waiting ...>
+step s2d: COMMIT;
+step s1b: <... completed>
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s1a s2d s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s1a: BEGIN;
+step s2d: COMMIT;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
+
+starting permutation: s2a s2b s2c s2d s1a s1b s1c
+step s2a: BEGIN;
+step s2b: SELECT * FROM a WHERE i = 1 FOR UPDATE;
+i
+
+1
+step s2c: UPDATE a SET i = 4 WHERE i = 3;
+step s2d: COMMIT;
+step s1a: BEGIN;
+step s1b: CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+step s1c: COMMIT;
diff --git a/src/test/isolation/isolation_schedule b/src/test/isolation/isolation_schedule
index c055a53..3e2614e 100644
--- a/src/test/isolation/isolation_schedule
+++ b/src/test/isolation/isolation_schedule
@@ -34,4 +34,7 @@ test: skip-locked-3
test: skip-locked-4
test: drop-index-concurrently-1
test: alter-table-1
+test: alter-table-2
+test: alter-table-3
+test: create-trigger
test: timeouts
diff --git a/src/test/isolation/specs/alter-table-2.spec b/src/test/isolation/specs/alter-table-2.spec
new file mode 100644
index 0000000..e6a02e0
--- /dev/null
+++ b/src/test/isolation/specs/alter-table-2.spec
@@ -0,0 +1,30 @@
+# ALTER TABLE - Add foreign keys with concurrent reads
+#
+# ADD CONSTRAINT uses ShareRowExclusiveLock so we mix writes with it
+# to see what works or waits.
+
+setup
+{
+ CREATE TABLE a (i int PRIMARY KEY);
+ CREATE TABLE b (a_id int);
+ INSERT INTO a VALUES (0), (1), (2), (3);
+ INSERT INTO b SELECT generate_series(1,1000) % 4;
+}
+
+teardown
+{
+ DROP TABLE a, b;
+}
+
+session "s1"
+step "s1a" { BEGIN; }
+step "s1b" { ALTER TABLE b ADD CONSTRAINT bfk FOREIGN KEY (a_id) REFERENCES a (i) NOT VALID; }
+step "s1c" { COMMIT; }
+
+session "s2"
+step "s2a" { BEGIN; }
+step "s2b" { SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; }
+step "s2c" { SELECT * FROM b WHERE a_id = 3 LIMIT 1 FOR UPDATE; }
+step "s2d" { INSERT INTO b VALUES (0); }
+step "s2e" { INSERT INTO a VALUES (4); }
+step "s2f" { COMMIT; }
diff --git a/src/test/isolation/specs/alter-table-3.spec b/src/test/isolation/specs/alter-table-3.spec
new file mode 100644
index 0000000..d252620
--- /dev/null
+++ b/src/test/isolation/specs/alter-table-3.spec
@@ -0,0 +1,30 @@
+# ALTER TABLE - Enable and disable triggers with concurrent reads
+#
+# ENABLE/DISABLE TRIGGER uses ShareRowExclusiveLock so we mix writes with
+# it to see what works or waits.
+
+setup
+{
+ CREATE TABLE a (i int PRIMARY KEY);
+ INSERT INTO a VALUES (0), (1), (2), (3);
+ CREATE FUNCTION f() RETURNS TRIGGER LANGUAGE plpgsql AS 'BEGIN RETURN NULL; END;';
+ CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f();
+}
+
+teardown
+{
+ DROP TABLE a;
+ DROP FUNCTION f();
+}
+
+session "s1"
+step "s1a" { BEGIN; }
+step "s1b" { ALTER TABLE a DISABLE TRIGGER t; }
+step "s1c" { ALTER TABLE a ENABLE TRIGGER t; }
+step "s1d" { COMMIT; }
+
+session "s2"
+step "s2a" { BEGIN; }
+step "s2b" { SELECT * FROM a WHERE i = 1 LIMIT 1 FOR UPDATE; }
+step "s2c" { INSERT INTO a VALUES (0); }
+step "s2d" { COMMIT; }
diff --git a/src/test/isolation/specs/create-trigger.spec b/src/test/isolation/specs/create-trigger.spec
new file mode 100644
index 0000000..34fad75
--- /dev/null
+++ b/src/test/isolation/specs/create-trigger.spec
@@ -0,0 +1,28 @@
+# CREATE TRIGGER - Add trigger with concurrent reads
+#
+# CREATE TRIGGER uses ShareRowExclusiveLock so we mix writes with it
+# to see what works or waits.
+
+setup
+{
+ CREATE TABLE a (i int);
+ CREATE FUNCTION f() RETURNS TRIGGER LANGUAGE plpgsql AS 'BEGIN RETURN NULL; END;';
+ INSERT INTO a VALUES (0), (1), (2), (3);
+}
+
+teardown
+{
+ DROP TABLE a;
+ DROP FUNCTION f();
+}
+
+session "s1"
+step "s1a" { BEGIN; }
+step "s1b" { CREATE TRIGGER t AFTER UPDATE ON a EXECUTE PROCEDURE f(); }
+step "s1c" { COMMIT; }
+
+session "s2"
+step "s2a" { BEGIN; }
+step "s2b" { SELECT * FROM a WHERE i = 1 FOR UPDATE; }
+step "s2c" { UPDATE a SET i = 4 WHERE i = 3; }
+step "s2d" { COMMIT; }
diff --git a/src/test/regress/expected/alter_table.out b/src/test/regress/expected/alter_table.out
index d233710..1f7c265 100644
--- a/src/test/regress/expected/alter_table.out
+++ b/src/test/regress/expected/alter_table.out
@@ -1952,9 +1952,9 @@ create trigger ttdummy
execute procedure
ttdummy (1, 1);
select * from my_locks order by 1;
- relname | max_lockmode
------------+---------------------
- alterlock | AccessExclusiveLock
+ relname | max_lockmode
+-----------+-----------------------
+ alterlock | ShareRowExclusiveLock
(1 row)
rollback;
@@ -1966,10 +1966,10 @@ select * from my_locks order by 1;
alter table alterlock2 add foreign key (f1) references alterlock (f1);
select * from my_locks order by 1;
- relname | max_lockmode
------------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+-----------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
alterlock2_pkey | AccessShareLock
alterlock_pkey | AccessShareLock
(4 rows)
@@ -1979,10 +1979,10 @@ begin;
alter table alterlock2
add constraint alterlock2nv foreign key (f1) references alterlock (f1) NOT VALID;
select * from my_locks order by 1;
- relname | max_lockmode
-------------+---------------------
- alterlock | AccessExclusiveLock
- alterlock2 | AccessExclusiveLock
+ relname | max_lockmode
+------------+-----------------------
+ alterlock | ShareRowExclusiveLock
+ alterlock2 | ShareRowExclusiveLock
(2 rows)
commit;
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On Sun, Feb 8, 2015 at 10:05 AM, Andreas Karlsson <andreas@proxel.se> wrote:
On 01/30/2015 07:48 AM, Michael Paquier wrote:
Looking at the latest patch, it seems that in
AlterTableGetLockLevel@tablecmds.c we ought to put AT_ReAddConstraint,
AT_AddConstraintRecurse and AT_ProcessedConstraint under the same
banner as AT_AddConstraint. Thoughts?A new version of the patch is attached which treats them as the same for
locking. I think it is correct and improves readability to do so.
Well then, let's switch it to "Ready for committer". I am moving as
well this entry to the next CF with the same status.
--
Michael
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 7 February 2015 at 20:05, Andreas Karlsson <andreas@proxel.se> wrote:
On 01/30/2015 07:48 AM, Michael Paquier wrote:
Looking at the latest patch, it seems that in
AlterTableGetLockLevel@tablecmds.c we ought to put AT_ReAddConstraint,
AT_AddConstraintRecurse and AT_ProcessedConstraint under the same
banner as AT_AddConstraint. Thoughts?A new version of the patch is attached which treats them as the same for
locking. I think it is correct and improves readability to do so.
Committed. We move forwards, slowly but surely. Thanks for the patch.
--
Simon Riggs http://www.2ndQuadrant.com/
PostgreSQL Development, 24x7 Support, RemoteDBA, Training & Services
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On Mon, Apr 6, 2015 at 12:56 AM, Simon Riggs <simon@2ndquadrant.com> wrote:
On 7 February 2015 at 20:05, Andreas Karlsson <andreas@proxel.se> wrote:
On 01/30/2015 07:48 AM, Michael Paquier wrote:
Looking at the latest patch, it seems that in
AlterTableGetLockLevel@tablecmds.c we ought to put AT_ReAddConstraint,
AT_AddConstraintRecurse and AT_ProcessedConstraint under the same
banner as AT_AddConstraint. Thoughts?A new version of the patch is attached which treats them as the same for
locking. I think it is correct and improves readability to do so.Committed. We move forwards, slowly but surely. Thanks for the patch.
Cool! Thanks for showing up.
--
Michael
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 04/05/2015 05:56 PM, Simon Riggs wrote:
Committed. We move forwards, slowly but surely. Thanks for the patch.
Thanks to you and the reviewers for helping me out with this patch!
--
Andreas Karlsson
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Re: PATCH: Reducing lock strength of trigger and foreign key DDL
On 5 April 2015 at 19:19, Michael Paquier <michael.paquier@gmail.com> wrote:
Cool! Thanks for showing up.
Visibility <> Activity. How is REINDEX CONCURRENTLY doing?
--
Simon Riggs http://www.2ndQuadrant.com/
PostgreSQL Development, 24x7 Support, RemoteDBA, Training & Services
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers