# Test race conditions involving:
# - s1: VACUUM inplace-updating a pg_class row
# - s2: GRANT/REVOKE making pg_class rows dead
# - s3: "VACUUM pg_class" making dead rows LP_UNUSED; DDL reusing them

# Need GRANT to make a non-HOT update.  Otherwise, "VACUUM pg_class" would
# leave an LP_REDIRECT that persists.  To get non-HOT, make rels so the
# pg_class row for vactest.orig50 is on a filled page (assuming BLCKSZ=8192).
# Just to save on filesystem syscalls, use relkind=c for every other rel.
setup
{
 CREATE EXTENSION injection_points;
 CREATE SCHEMA vactest;
 CREATE FUNCTION vactest.mkrels(text, int, int) RETURNS void
  LANGUAGE plpgsql SET search_path = vactest AS $$
 DECLARE
  tname text;
 BEGIN
  FOR i in $2 .. $3 LOOP
   tname := $1 || i;
   EXECUTE FORMAT('CREATE TYPE ' || tname || ' AS ()');
   RAISE DEBUG '% at %', tname, ctid
    FROM pg_class WHERE oid = tname::regclass;
  END LOOP;
 END
 $$;
}
setup { VACUUM FULL pg_class;  -- reduce free space }
setup
{
 SELECT vactest.mkrels('orig', 1, 49);
 CREATE TABLE vactest.orig50 ();
 SELECT vactest.mkrels('orig', 51, 100);
}
teardown
{
 DROP SCHEMA vactest CASCADE;
 DROP EXTENSION injection_points;
}

# Wait during inplace update, in a VACUUM of vactest.orig50.
session s1
setup {
 SELECT injection_points_set_local();
 SELECT injection_points_attach('inplace-before-pin', 'wait');
}
step vac1 { VACUUM vactest.orig50;  -- wait during inplace update }
# One bug scenario leaves two live pg_class tuples for vactest.orig50 and zero
# live tuples for one of the "intruder" rels.  REINDEX observes the duplicate.
step read1 {
 REINDEX TABLE pg_class;  -- look for duplicates
 SELECT reltuples = -1 AS reltuples_unknown
 FROM pg_class WHERE oid = 'vactest.orig50'::regclass;
}

# Transactional updates of the tuple vac1 is waiting to inplace-update.
session s2
step grant2  { GRANT SELECT ON TABLE vactest.orig50 TO PUBLIC; }
step revoke2 { REVOKE SELECT ON TABLE vactest.orig50 FROM PUBLIC; }
step begin2  { BEGIN; }
step c2   { COMMIT; }
step r2   { ROLLBACK; }

# Non-blocking actions.
session s3
step vac3  { VACUUM pg_class; }
# Reuse the lp that vac1 is waiting to change.  I've observed reuse at the 1st
# or 18th CREATE, so create excess.
step mkrels3 {
 SELECT vactest.mkrels('intruder', 1, 100);  -- repopulate LP_UNUSED
 SELECT injection_points_detach('inplace-before-pin');
 SELECT injection_points_wakeup('inplace-before-pin');
}


# target gains a successor at the last moment
permutation
 vac1(mkrels3) # reads pg_class tuple T0 for vactest.orig50, xmax invalid
 grant2   # T0 becomes eligible for pruning, T1 is successor
 vac3   # T0 becomes LP_UNUSED
 mkrels3   # vac1 wakes, scans to T1
 read1

# target already has a successor, which commits
permutation
 begin2
 grant2   # T0.t_ctid = T1
 vac1(mkrels3) # reads T0 for vactest.orig50
 c2    # T0 becomes eligible for pruning
 vac3   # T0 becomes LP_UNUSED
 mkrels3   # vac1 wakes, scans to T1
 read1

# target already has a successor, which becomes LP_UNUSED at the last moment
permutation
 begin2
 grant2   # T0.t_ctid = T1
 vac1(mkrels3) # reads T0 for vactest.orig50
 r2    # T1 becomes eligible for pruning
 vac3   # T1 becomes LP_UNUSED
 mkrels3   # reuse T1; vac1 scans to T0
 read1

# target already has a successor, which becomes LP_REDIRECT at the last moment
permutation
 begin2
 grant2   # T0.t_ctid = T1, non-HOT due to filled page
 vac1(mkrels3) # reads T0
 c2
 revoke2   # HOT update to T2
 grant2   # HOT update to T3
 vac3   # T1 becomes LP_REDIRECT
 mkrels3   # reuse T2; vac1 scans to T3
 read1

# waiting for updater to end
permutation
 vac1(c2)  # reads pg_class tuple T0 for vactest.orig50, xmax invalid
 begin2
 grant2   # T0.t_ctid = T1, non-HOT due to filled page
 revoke2   # HOT update to T2
 mkrels3   # vac1 awakes briefly, then waits for s2
 c2
 read1

# Another LP_UNUSED.  This time, do change the live tuple.  Final live tuple
# body is identical to original, at a different TID.
permutation
 begin2
 grant2   # T0.t_ctid = T1, non-HOT due to filled page
 vac1(mkrels3) # reads T0
 r2    # T1 becomes eligible for pruning
 grant2   # T0.t_ctid = T2; T0 becomes eligible for pruning
 revoke2   # T2.t_ctid = T3; T2 becomes eligible for pruning
 vac3   # T0, T1 & T2 become LP_UNUSED
 mkrels3   # reuse T0, T1 & T2; vac1 scans to T3
 read1

# Another LP_REDIRECT.  Compared to the earlier test, omit the last grant2.
# Hence, final live tuple body is identical to original, at a different TID.
permutation begin2 grant2 vac1(mkrels3) c2 revoke2 vac3 mkrels3 read1