# Test for page level predicate locking in gin index
#
# Test to verify serialization failures and to check reduced false positives
#
# To verify serialization failures, queries and permutations are written in such
# a way that an index scan  (from one transaction) and an index insert (from
# another transaction) will try to access the same part (sub-tree) of the index
# whereas to check reduced false positives, they will try to access different
# parts (sub-tree) of the index.


setup
{
  create table gin_tbl(p int4[]);
  insert into gin_tbl select array[1] from generate_series(1, 8192) g;
  insert into gin_tbl select array[g] from generate_series(2, 800) g;
  create index ginidx on gin_tbl using gin(p) with (fastupdate = off);
  create table other_tbl(v int4);
}

teardown
{
  drop table gin_tbl;
  drop table other_tbl;
}

session s1
setup
{
  begin isolation level serializable;
  set enable_seqscan=off;
}

step ra1	{ select * from gin_tbl where p @> array[1] limit 1; }
step rb1  { select count(*) from gin_tbl where p @> array[2]; }
step rc1  { select count(*) from gin_tbl where p @> array[800]; }
step rd1  { select count(*) from gin_tbl where p @> array[2000]; }

step wo1	{ insert into other_tbl values (1); }

step c1  { commit; }

session s2
setup
{
  begin isolation level serializable;
  set enable_seqscan=off;
}

step ro2	{ select count(*) from other_tbl; }

step wa2  { insert into gin_tbl values (array[1]); }
step wb2  { insert into gin_tbl values (array[2]); }
step wc2  { insert into gin_tbl values (array[800]); }
step wd2  { insert into gin_tbl values (array[2000]); }

step c2  { commit; }

session s3
step fu { alter index ginidx set (fastupdate = on); }

# An index scan (from one transaction) and an index insert (from another
# transaction) try to access the same part of the index. So, there is a
# r-w conflict.

permutation ra1 ro2 wo1 c1 wa2 c2
permutation ro2 ra1 wo1 c1 wa2 c2
permutation ro2 ra1 wo1 wa2 c1 c2
permutation ra1 ro2 wa2 wo1 c1 c2

permutation rb1 ro2 wo1 c1 wb2 c2
permutation ro2 rb1 wo1 c1 wb2 c2
permutation ro2 rb1 wo1 wb2 c1 c2
permutation rb1 ro2 wb2 wo1 c1 c2

permutation rc1 ro2 wo1 c1 wc2 c2
permutation ro2 rc1 wo1 c1 wc2 c2
permutation ro2 rc1 wo1 wc2 c1 c2
permutation rc1 ro2 wc2 wo1 c1 c2

# An index scan (from one transaction) and an index insert (from another
# transaction) try to access different parts of the index.  So, there is no
# r-w conflict.

permutation ra1 ro2 wo1 c1 wb2 c2
permutation ro2 ra1 wo1 c1 wc2 c2
permutation ro2 rb1 wo1 wa2 c1 c2
permutation rc1 ro2 wa2 wo1 c1 c2

permutation rb1 ro2 wo1 c1 wa2 c2
permutation ro2 rb1 wo1 c1 wc2 c2
permutation ro2 ra1 wo1 wb2 c1 c2
permutation rc1 ro2 wb2 wo1 c1 c2

permutation rc1 ro2 wo1 c1 wa2 c2
permutation ro2 rc1 wo1 c1 wb2 c2
permutation ro2 ra1 wo1 wc2 c1 c2
permutation rb1 ro2 wc2 wo1 c1 c2

# With fastupdate = on all index is under predicate lock.  So we can't
# distinguish particular keys.

permutation fu ra1 ro2 wo1 c1 wa2 c2
permutation fu ra1 ro2 wo1 c1 wb2 c2

# Check fastupdate turned on concurrently.

permutation ra1 ro2 wo1 c1 fu wa2 c2

# Tests for conflicts with previously non-existing key

permutation rd1 ro2 wo1 c1 wd2 c2
permutation ro2 rd1 wo1 c1 wd2 c2
permutation ro2 rd1 wo1 wd2 c1 c2
permutation rd1 ro2 wd2 wo1 c1 c2