GSoC 2017: weekly progress reports (week 4) and patch for hash index

From 8ccfad5af8291d5279bf0dffe240856143d5993c Mon Sep 17 00:00:00 2001
From: shubhambaraiss <you@example.com>
Date: Mon, 25 Sep 2017 17:31:52 +0530
Subject: [PATCH] Predicate locking in hash index

---
 src/backend/access/hash/hash.c                   |   2 +-
 src/backend/access/hash/hashinsert.c             |   3 +
 src/backend/access/hash/hashpage.c               |   9 +
 src/backend/access/hash/hashsearch.c             |   2 +
 src/backend/storage/lmgr/README-SSI              |   4 +
 src/test/isolation/expected/predicate-hash-2.out | 321 +++++++++++++++++++++
 src/test/isolation/expected/predicate-hash.out   | 339 +++++++++++++++++++++++
 src/test/isolation/isolation_schedule            |   2 +
 src/test/isolation/specs/predicate-hash-2.spec   |  51 ++++
 src/test/isolation/specs/predicate-hash.spec     |  51 ++++
 10 files changed, 783 insertions(+), 1 deletion(-)
 create mode 100644 src/test/isolation/expected/predicate-hash-2.out
 create mode 100644 src/test/isolation/expected/predicate-hash.out
 create mode 100644 src/test/isolation/specs/predicate-hash-2.spec
 create mode 100644 src/test/isolation/specs/predicate-hash.spec

diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c
index d89c192..fa4d4d6 100644
--- a/src/backend/access/hash/hash.c
+++ b/src/backend/access/hash/hash.c
@@ -68,7 +68,7 @@ hashhandler(PG_FUNCTION_ARGS)
 	amroutine->amsearchnulls = false;
 	amroutine->amstorage = false;
 	amroutine->amclusterable = false;
-	amroutine->ampredlocks = false;
+	amroutine->ampredlocks = true;
 	amroutine->amcanparallel = false;
 	amroutine->amkeytype = INT4OID;
 
diff --git a/src/backend/access/hash/hashinsert.c b/src/backend/access/hash/hashinsert.c
index dc08db9..c8005eb 100644
--- a/src/backend/access/hash/hashinsert.c
+++ b/src/backend/access/hash/hashinsert.c
@@ -22,6 +22,7 @@
 #include "utils/rel.h"
 #include "storage/lwlock.h"
 #include "storage/buf_internals.h"
+#include "storage/predicate.h"
 
 static void _hash_vacuum_one_page(Relation rel, Buffer metabuf, Buffer buf,
 					  RelFileNode hnode);
@@ -88,6 +89,8 @@ restart_insert:
 										  &usedmetap);
 	Assert(usedmetap != NULL);
 
+	CheckForSerializableConflictIn(rel, NULL, buf);
+
 	/* remember the primary bucket buffer to release the pin on it at end. */
 	bucket_buf = buf;
 
diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c
index 1cb18a7..2a950e1 100644
--- a/src/backend/access/hash/hashpage.c
+++ b/src/backend/access/hash/hashpage.c
@@ -33,6 +33,7 @@
 #include "miscadmin.h"
 #include "storage/lmgr.h"
 #include "storage/smgr.h"
+#include "storage/predicate.h"
 
 
 static bool _hash_alloc_buckets(Relation rel, BlockNumber firstblock,
@@ -947,6 +948,10 @@ restart_expand:
 					  buf_oblkno, buf_nblkno, NULL,
 					  maxbucket, highmask, lowmask);
 
+	PredicateLockPageSplit(rel,
+				BufferGetBlockNumber(buf_oblkno),
+				BufferGetBlockNumber(buf_nblkno));
+
 	/* all done, now release the locks and pins on primary buckets. */
 	_hash_relbuf(rel, buf_oblkno);
 	_hash_relbuf(rel, buf_nblkno);
@@ -1425,6 +1430,10 @@ _hash_finish_split(Relation rel, Buffer metabuf, Buffer obuf, Bucket obucket,
 					  nbucket, obuf, bucket_nbuf, tidhtab,
 					  maxbucket, highmask, lowmask);
 
+	PredicateLockPageSplit(rel,
+				BufferGetBlockNumber(obuf),
+				BufferGetBlockNumber(bucket_nbuf));
+
 	_hash_relbuf(rel, bucket_nbuf);
 	LockBuffer(obuf, BUFFER_LOCK_UNLOCK);
 	hash_destroy(tidhtab);
diff --git a/src/backend/access/hash/hashsearch.c b/src/backend/access/hash/hashsearch.c
index 3e461ad..dfde237 100644
--- a/src/backend/access/hash/hashsearch.c
+++ b/src/backend/access/hash/hashsearch.c
@@ -19,6 +19,7 @@
 #include "miscadmin.h"
 #include "pgstat.h"
 #include "utils/rel.h"
+#include "storage/predicate.h"
 
 
 /*
@@ -284,6 +285,7 @@ _hash_first(IndexScanDesc scan, ScanDirection dir)
 	so->hashso_sk_hash = hashkey;
 
 	buf = _hash_getbucketbuf_from_hashkey(rel, hashkey, HASH_READ, NULL);
+	PredicateLockPage(rel, BufferGetBlockNumber(buf), scan->xs_snapshot);
 	page = BufferGetPage(buf);
 	TestForOldSnapshot(scan->xs_snapshot, rel, page);
 	opaque = (HashPageOpaque) PageGetSpecialPointer(page);
diff --git a/src/backend/storage/lmgr/README-SSI b/src/backend/storage/lmgr/README-SSI
index a9dc01f..6e9cbba 100644
--- a/src/backend/storage/lmgr/README-SSI
+++ b/src/backend/storage/lmgr/README-SSI
@@ -379,6 +379,10 @@ level during a GiST search. An index insert at the leaf level can
 then be trusted to ripple up to all levels and locations where
 conflicting predicate locks may exist.
 
+    * Hash index searches acquire predicate locks on the primary
+page of a bucket. During a bucket split, a predicate lock is copied from
+the primary page of an old bucket to the primary page of a new bucket.
+
     * The effects of page splits, overflows, consolidations, and
 removals must be carefully reviewed to ensure that predicate locks
 aren't "lost" during those operations, or kept with pages which could
diff --git a/src/test/isolation/expected/predicate-hash-2.out b/src/test/isolation/expected/predicate-hash-2.out
new file mode 100644
index 0000000..78312d0
--- /dev/null
+++ b/src/test/isolation/expected/predicate-hash-2.out
@@ -0,0 +1,321 @@
+Parsed test spec with 2 sessions
+
+starting permutation: rxy1 wx1 c1 rxy2 wy2 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy1 wx1 rxy2 c1 wy2 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step c1: commit;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy1 wx1 rxy2 wy2 c1 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy1 wx1 rxy2 wy2 c2 c1
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy1 rxy2 wx1 c1 wy2 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy1 rxy2 wx1 wy2 c1 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy1 rxy2 wx1 wy2 c2 c1
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy1 rxy2 wy2 wx1 c1 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy1 rxy2 wy2 wx1 c2 c1
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy1 rxy2 wy2 c2 wx1 c1
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy2 rxy1 wx1 c1 wy2 c2
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy2 rxy1 wx1 wy2 c1 c2
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy2 rxy1 wx1 wy2 c2 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy2 rxy1 wy2 wx1 c1 c2
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy2 rxy1 wy2 wx1 c2 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy2 rxy1 wy2 c2 wx1 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy2 wy2 rxy1 wx1 c1 c2
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy2 wy2 rxy1 wx1 c2 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy2 wy2 rxy1 c2 wx1 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step c2: commit;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy2 wy2 c2 rxy1 wx1 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
diff --git a/src/test/isolation/expected/predicate-hash.out b/src/test/isolation/expected/predicate-hash.out
new file mode 100644
index 0000000..272cb2e
--- /dev/null
+++ b/src/test/isolation/expected/predicate-hash.out
@@ -0,0 +1,339 @@
+Parsed test spec with 2 sessions
+
+starting permutation: rxy1 wx1 c1 rxy2 wy2 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+600            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy1 wx1 rxy2 c1 wy2 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step c1: commit;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy1 wx1 rxy2 wy2 c1 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 wx1 rxy2 wy2 c2 c1
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wx1 c1 wy2 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy1 rxy2 wx1 wy2 c1 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wx1 wy2 c2 c1
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 wx1 c1 c2
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 wx1 c2 c1
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 c2 wx1 c1
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy2 rxy1 wx1 c1 wy2 c2
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy2 rxy1 wx1 wy2 c1 c2
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wx1 wy2 c2 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 wx1 c1 c2
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 wx1 c2 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 c2 wx1 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy2 wy2 rxy1 wx1 c1 c2
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 wy2 rxy1 wx1 c2 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 wy2 rxy1 c2 wx1 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+200            
+step c2: commit;
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy2 wy2 c2 rxy1 wx1 c1
+step rxy2: select sum(p) from hash_point_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step rxy1: select sum(p) from hash_point_tbl where p=20;
+sum            
+
+400            
+step wx1: insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
diff --git a/src/test/isolation/isolation_schedule b/src/test/isolation/isolation_schedule
index 32c965b..284b87a 100644
--- a/src/test/isolation/isolation_schedule
+++ b/src/test/isolation/isolation_schedule
@@ -62,3 +62,5 @@ test: sequence-ddl
 test: async-notify
 test: vacuum-reltuples
 test: timeouts
+test: predicate-hash
+test: predicate-hash-2
diff --git a/src/test/isolation/specs/predicate-hash-2.spec b/src/test/isolation/specs/predicate-hash-2.spec
new file mode 100644
index 0000000..09d424d
--- /dev/null
+++ b/src/test/isolation/specs/predicate-hash-2.spec
@@ -0,0 +1,51 @@
+# Test for predicate locking in hash index
+#
+# Test to check false positives
+#
+# Queries are written in such a way that an index scan(from one transaction) and an index insert(from another transaction) will try to access different buckets of the index.
+
+
+setup
+{
+ create table hash_point_tbl(id int4, p integer);
+ create index hash_pointidx on hash_point_tbl using hash(p);
+ insert into hash_point_tbl (id, p)
+ select g, 10 from generate_series(1, 10) g;
+ insert into hash_point_tbl (id, p)
+ select g, 20 from generate_series(11, 20) g;
+ insert into hash_point_tbl (id, p)
+ select g, 30 from generate_series(21, 30) g;
+ insert into hash_point_tbl (id, p)
+ select g, 40 from generate_series(31, 40) g;
+}
+
+teardown
+{
+ DROP TABLE hash_point_tbl;
+}
+
+
+session "s1"
+setup		{
+		  BEGIN ISOLATION LEVEL SERIALIZABLE;
+		  set enable_seqscan=off;
+		  set enable_bitmapscan=off;
+		  set enable_indexonlyscan=on;
+		}
+step "rxy1"	{ select sum(p) from hash_point_tbl where p=20; }
+step "wx1"	{ insert into hash_point_tbl (id, p)
+                  select g, 50 from generate_series(41, 50) g; }
+step "c1"	{ commit; }
+
+
+session "s2"
+setup		{
+		  BEGIN ISOLATION LEVEL SERIALIZABLE;
+		  set enable_seqscan=off;
+		  set enable_bitmapscan=off;
+		  set enable_indexonlyscan=on;
+		}
+step "rxy2"	{ select sum(p) from hash_point_tbl where p=30; }
+step "wy2"	{ insert into hash_point_tbl (id, p)
+                  select g, 60 from generate_series(51, 60) g; }
+step "c2"	{ commit; }
diff --git a/src/test/isolation/specs/predicate-hash.spec b/src/test/isolation/specs/predicate-hash.spec
new file mode 100644
index 0000000..5bb2e52
--- /dev/null
+++ b/src/test/isolation/specs/predicate-hash.spec
@@ -0,0 +1,51 @@
+# Test for predicate locking in hash index
+#
+# Test to verify serialization failures
+#
+# Queries 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 bucket of the index.
+
+
+setup
+{
+ create table hash_point_tbl(id int4, p integer);
+ create index hash_pointidx on hash_point_tbl using hash(p);
+ insert into hash_point_tbl (id, p)
+ select g, 10 from generate_series(1, 10) g;
+ insert into hash_point_tbl (id, p)
+ select g, 20 from generate_series(11, 20) g;
+ insert into hash_point_tbl (id, p)
+ select g, 30 from generate_series(21, 30) g;
+ insert into hash_point_tbl (id, p)
+ select g, 40 from generate_series(31, 40) g;
+}
+
+teardown
+{
+ DROP TABLE hash_point_tbl;
+}
+
+
+session "s1"
+setup		{
+		  BEGIN ISOLATION LEVEL SERIALIZABLE;
+		  set enable_seqscan=off;
+		  set enable_bitmapscan=off;
+		  set enable_indexonlyscan=on;
+		}
+step "rxy1"	{ select sum(p) from hash_point_tbl where p=20; }
+step "wx1"	{ insert into hash_point_tbl (id, p)
+                  select g, 30 from generate_series(41, 50) g; }
+step "c1"	{ commit; }
+
+
+session "s2"
+setup		{
+		  BEGIN ISOLATION LEVEL SERIALIZABLE;
+		  set enable_seqscan=off;
+		  set enable_bitmapscan=off;
+		  set enable_indexonlyscan=on;
+		}
+step "rxy2"	{ select sum(p) from hash_point_tbl where p=30; }
+step "wy2"	{ insert into hash_point_tbl (id, p)
+                  select g, 20 from generate_series(51, 60) g; }
+step "c2"	{ commit; }
-- 
1.9.1

From 8c869531aff0175be95cca205db032a6e72b7f13 Mon Sep 17 00:00:00 2001
From: shubhambaraiss <you@example.com>
Date: Mon, 15 Jan 2018 19:36:25 +0530
Subject: [PATCH] Predicate Locking in hash index

---
 src/backend/access/hash/hash.c                 |   2 +-
 src/backend/access/hash/hashinsert.c           |   3 +
 src/backend/access/hash/hashpage.c             |  10 +
 src/backend/access/hash/hashsearch.c           |   2 +
 src/backend/storage/lmgr/README-SSI            |   5 +
 src/test/isolation/expected/predicate-hash.out | 659 +++++++++++++++++++++++++
 src/test/isolation/isolation_schedule          |   1 +
 src/test/isolation/specs/predicate-hash.spec   | 122 +++++
 8 files changed, 803 insertions(+), 1 deletion(-)
 create mode 100644 src/test/isolation/expected/predicate-hash.out
 create mode 100644 src/test/isolation/specs/predicate-hash.spec

diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c
index 718e2be..2932649 100644
--- a/src/backend/access/hash/hash.c
+++ b/src/backend/access/hash/hash.c
@@ -68,7 +68,7 @@ hashhandler(PG_FUNCTION_ARGS)
 	amroutine->amsearchnulls = false;
 	amroutine->amstorage = false;
 	amroutine->amclusterable = false;
-	amroutine->ampredlocks = false;
+	amroutine->ampredlocks = true;
 	amroutine->amcanparallel = false;
 	amroutine->amkeytype = INT4OID;
 
diff --git a/src/backend/access/hash/hashinsert.c b/src/backend/access/hash/hashinsert.c
index f668dcf..ade49d8 100644
--- a/src/backend/access/hash/hashinsert.c
+++ b/src/backend/access/hash/hashinsert.c
@@ -22,6 +22,7 @@
 #include "utils/rel.h"
 #include "storage/lwlock.h"
 #include "storage/buf_internals.h"
+#include "storage/predicate.h"
 
 static void _hash_vacuum_one_page(Relation rel, Buffer metabuf, Buffer buf,
 					  RelFileNode hnode);
@@ -88,6 +89,8 @@ restart_insert:
 										  &usedmetap);
 	Assert(usedmetap != NULL);
 
+	CheckForSerializableConflictIn(rel, NULL, buf);
+
 	/* remember the primary bucket buffer to release the pin on it at end. */
 	bucket_buf = buf;
 
diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c
index e3c8721..fe2b22d 100644
--- a/src/backend/access/hash/hashpage.c
+++ b/src/backend/access/hash/hashpage.c
@@ -33,6 +33,7 @@
 #include "miscadmin.h"
 #include "storage/lmgr.h"
 #include "storage/smgr.h"
+#include "storage/predicate.h"
 
 
 static bool _hash_alloc_buckets(Relation rel, BlockNumber firstblock,
@@ -957,6 +958,10 @@ restart_expand:
 					  buf_oblkno, buf_nblkno, NULL,
 					  maxbucket, highmask, lowmask);
 
+	PredicateLockPageSplit(rel,
+						   BufferGetBlockNumber(buf_oblkno),
+						   BufferGetBlockNumber(buf_nblkno));
+
 	/* all done, now release the pins on primary buckets. */
 	_hash_dropbuf(rel, buf_oblkno);
 	_hash_dropbuf(rel, buf_nblkno);
@@ -1459,6 +1464,11 @@ _hash_finish_split(Relation rel, Buffer metabuf, Buffer obuf, Bucket obucket,
 					  nbucket, obuf, bucket_nbuf, tidhtab,
 					  maxbucket, highmask, lowmask);
 
+	PredicateLockPageSplit(rel,
+						   BufferGetBlockNumber(obuf),
+						   BufferGetBlockNumber(bucket_nbuf));
+
+
 	_hash_dropbuf(rel, bucket_nbuf);
 	hash_destroy(tidhtab);
 }
diff --git a/src/backend/access/hash/hashsearch.c b/src/backend/access/hash/hashsearch.c
index c692c5b..da95fd8 100644
--- a/src/backend/access/hash/hashsearch.c
+++ b/src/backend/access/hash/hashsearch.c
@@ -19,6 +19,7 @@
 #include "miscadmin.h"
 #include "pgstat.h"
 #include "utils/rel.h"
+#include "storage/predicate.h"
 
 static bool _hash_readpage(IndexScanDesc scan, Buffer *bufP,
 			   ScanDirection dir);
@@ -347,6 +348,7 @@ _hash_first(IndexScanDesc scan, ScanDirection dir)
 	so->hashso_sk_hash = hashkey;
 
 	buf = _hash_getbucketbuf_from_hashkey(rel, hashkey, HASH_READ, NULL);
+	PredicateLockPage(rel, BufferGetBlockNumber(buf), scan->xs_snapshot);
 	page = BufferGetPage(buf);
 	TestForOldSnapshot(scan->xs_snapshot, rel, page);
 	opaque = (HashPageOpaque) PageGetSpecialPointer(page);
diff --git a/src/backend/storage/lmgr/README-SSI b/src/backend/storage/lmgr/README-SSI
index a9dc01f..739efec 100644
--- a/src/backend/storage/lmgr/README-SSI
+++ b/src/backend/storage/lmgr/README-SSI
@@ -379,6 +379,11 @@ level during a GiST search. An index insert at the leaf level can
 then be trusted to ripple up to all levels and locations where
 conflicting predicate locks may exist.
 
+    * Hash index searches acquire predicate locks on the primary
+page of a bucket. During a bucket split, a predicate lock is copied from
+the primary page of an old bucket to the primary page of a new bucket.
+
+
     * The effects of page splits, overflows, consolidations, and
 removals must be carefully reviewed to ensure that predicate locks
 aren't "lost" during those operations, or kept with pages which could
diff --git a/src/test/isolation/expected/predicate-hash.out b/src/test/isolation/expected/predicate-hash.out
new file mode 100644
index 0000000..53e500f
--- /dev/null
+++ b/src/test/isolation/expected/predicate-hash.out
@@ -0,0 +1,659 @@
+Parsed test spec with 2 sessions
+
+starting permutation: rxy1 wx1 c1 rxy2 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+600            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy2 wy2 c2 rxy1 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+400            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy3 wx3 c1 rxy4 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy4 wy4 c2 rxy3 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy1 wx1 rxy2 c1 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy1 wx1 rxy2 wy2 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 wx1 rxy2 wy2 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wx1 c1 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy1 rxy2 wx1 wy2 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wx1 wy2 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 wx1 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 wx1 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 c2 wx1 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy2 rxy1 wx1 c1 wy2 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy2 rxy1 wx1 wy2 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wx1 wy2 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 wx1 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 wx1 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 c2 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy2 wy2 rxy1 wx1 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 wy2 rxy1 wx1 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 wy2 rxy1 c2 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy3 wx3 rxy4 c1 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy3 wx3 rxy4 wy4 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 wx3 rxy4 wy4 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wx3 c1 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wx3 wy4 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wx3 wy4 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wy4 wx3 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wy4 wx3 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wy4 c2 wx3 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wx3 c1 wy4 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wx3 wy4 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wx3 wy4 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wy4 wx3 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wy4 wx3 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wy4 c2 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy4 wy4 rxy3 wx3 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 wy4 rxy3 wx3 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 wy4 rxy3 c2 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
diff --git a/src/test/isolation/isolation_schedule b/src/test/isolation/isolation_schedule
index befe676..d1adaa1 100644
--- a/src/test/isolation/isolation_schedule
+++ b/src/test/isolation/isolation_schedule
@@ -65,3 +65,4 @@ test: async-notify
 test: vacuum-reltuples
 test: timeouts
 test: vacuum-concurrent-drop
+test: predicate-hash
diff --git a/src/test/isolation/specs/predicate-hash.spec b/src/test/isolation/specs/predicate-hash.spec
new file mode 100644
index 0000000..8c83cb3
--- /dev/null
+++ b/src/test/isolation/specs/predicate-hash.spec
@@ -0,0 +1,122 @@
+# Test for page level predicate locking in hash 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 bucket of the index
+# whereas to check reduced false positives, they will try to access different
+# buckets of the index.
+
+setup
+{
+ create table hash_tbl(id int4, p integer);
+ create index hash_idx on hash_tbl using hash(p);
+ insert into hash_tbl (id, p)
+ select g, 10 from generate_series(1, 10) g;
+ insert into hash_tbl (id, p)
+ select g, 20 from generate_series(11, 20) g;
+ insert into hash_tbl (id, p)
+ select g, 30 from generate_series(21, 30) g;
+ insert into hash_tbl (id, p)
+ select g, 40 from generate_series(31, 40) g;
+}
+
+teardown
+{
+ drop table hash_tbl;
+}
+
+session "s1"
+setup		
+{
+ begin isolation level serializable;
+ set enable_seqscan=off;
+ set enable_bitmapscan=off;
+ set enable_indexonlyscan=on;
+}
+step "rxy1"	{ select sum(p) from hash_tbl where p=20; }
+step "wx1"	{ insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g; }
+step "rxy3"	{ select sum(p) from hash_tbl where p=20; }
+step "wx3"	{ insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g; }
+step "c1"	{ commit; }
+
+
+session "s2"
+setup		
+{
+ begin isolation level serializable;
+ set enable_seqscan=off;
+ set enable_bitmapscan=off;
+ set enable_indexonlyscan=on;
+}
+step "rxy2"	{ select sum(p) from hash_tbl where p=30; }
+step "wy2"	{ insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g; }
+step "rxy4"	{ select sum(p) from hash_tbl where p=30; }
+step "wy4"	{ insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g; }
+step "c2"	{ commit; }
+
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access the same bucket of the index but one transaction
+# commits before other transaction begins so no r-w conflict.
+
+permutation "rxy1" "wx1" "c1" "rxy2" "wy2" "c2"
+permutation "rxy2" "wy2" "c2" "rxy1" "wx1" "c1"
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access different buckets of the index and also one
+# transaction commits before other transaction begins, so no r-w conflict.
+
+permutation "rxy3" "wx3" "c1" "rxy4" "wy4" "c2"
+permutation "rxy4" "wy4" "c2" "rxy3" "wx3" "c1"
+
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access the same bucket of the index and one transaction
+# begins before other transaction commits so there is a r-w conflict.
+
+permutation "rxy1" "wx1" "rxy2" "c1" "wy2" "c2"
+permutation "rxy1" "wx1" "rxy2" "wy2" "c1" "c2"
+permutation "rxy1" "wx1" "rxy2" "wy2" "c2" "c1"
+permutation "rxy1" "rxy2" "wx1" "c1" "wy2" "c2"
+permutation "rxy1" "rxy2" "wx1" "wy2" "c1" "c2"
+permutation "rxy1" "rxy2" "wx1" "wy2" "c2" "c1"
+permutation "rxy1" "rxy2" "wy2" "wx1" "c1" "c2"
+permutation "rxy1" "rxy2" "wy2" "wx1" "c2" "c1"
+permutation "rxy1" "rxy2" "wy2" "c2" "wx1" "c1"
+permutation "rxy2" "rxy1" "wx1" "c1" "wy2" "c2"
+permutation "rxy2" "rxy1" "wx1" "wy2" "c1" "c2"
+permutation "rxy2" "rxy1" "wx1" "wy2" "c2" "c1"
+permutation "rxy2" "rxy1" "wy2" "wx1" "c1" "c2"
+permutation "rxy2" "rxy1" "wy2" "wx1" "c2" "c1"
+permutation "rxy2" "rxy1" "wy2" "c2" "wx1" "c1"
+permutation "rxy2" "wy2" "rxy1" "wx1" "c1" "c2"
+permutation "rxy2" "wy2" "rxy1" "wx1" "c2" "c1"
+permutation "rxy2" "wy2" "rxy1" "c2" "wx1" "c1"
+
+# An index scan (from one transaction) and an index insert (from another 
+# transaction) try to access different buckets of the index so no r-w conflict.
+
+permutation "rxy3" "wx3" "rxy4" "c1" "wy4" "c2"
+permutation "rxy3" "wx3" "rxy4" "wy4" "c1" "c2"
+permutation "rxy3" "wx3" "rxy4" "wy4" "c2" "c1"
+permutation "rxy3" "rxy4" "wx3" "c1" "wy4" "c2"
+permutation "rxy3" "rxy4" "wx3" "wy4" "c1" "c2"
+permutation "rxy3" "rxy4" "wx3" "wy4" "c2" "c1"
+permutation "rxy3" "rxy4" "wy4" "wx3" "c1" "c2"
+permutation "rxy3" "rxy4" "wy4" "wx3" "c2" "c1"
+permutation "rxy3" "rxy4" "wy4" "c2" "wx3" "c1"
+permutation "rxy4" "rxy3" "wx3" "c1" "wy4" "c2"
+permutation "rxy4" "rxy3" "wx3" "wy4" "c1" "c2"
+permutation "rxy4" "rxy3" "wx3" "wy4" "c2" "c1"
+permutation "rxy4" "rxy3" "wy4" "wx3" "c1" "c2"
+permutation "rxy4" "rxy3" "wy4" "wx3" "c2" "c1"
+permutation "rxy4" "rxy3" "wy4" "c2" "wx3" "c1"
+permutation "rxy4" "wy4" "rxy3" "wx3" "c1" "c2"
+permutation "rxy4" "wy4" "rxy3" "wx3" "c2" "c1"
+permutation "rxy4" "wy4" "rxy3" "c2" "wx3" "c1"
-- 
1.9.1

diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c
index e337439adad..4f2ea7955f9 100644
--- a/src/backend/access/hash/hash.c
+++ b/src/backend/access/hash/hash.c
@@ -68,7 +68,7 @@ hashhandler(PG_FUNCTION_ARGS)
 	amroutine->amsearchnulls = false;
 	amroutine->amstorage = false;
 	amroutine->amclusterable = false;
-	amroutine->ampredlocks = false;
+	amroutine->ampredlocks = true;
 	amroutine->amcanparallel = false;
 	amroutine->amkeytype = INT4OID;
 
diff --git a/src/backend/access/hash/hashinsert.c b/src/backend/access/hash/hashinsert.c
index f121286b8ca..3eb722ce266 100644
--- a/src/backend/access/hash/hashinsert.c
+++ b/src/backend/access/hash/hashinsert.c
@@ -22,6 +22,7 @@
 #include "utils/rel.h"
 #include "storage/lwlock.h"
 #include "storage/buf_internals.h"
+#include "storage/predicate.h"
 
 static void _hash_vacuum_one_page(Relation rel, Buffer metabuf, Buffer buf,
 					  RelFileNode hnode);
@@ -88,6 +89,8 @@ restart_insert:
 										  &usedmetap);
 	Assert(usedmetap != NULL);
 
+	CheckForSerializableConflictIn(rel, NULL, buf);
+
 	/* remember the primary bucket buffer to release the pin on it at end. */
 	bucket_buf = buf;
 
diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c
index 3859e3bd838..c26cf76285d 100644
--- a/src/backend/access/hash/hashpage.c
+++ b/src/backend/access/hash/hashpage.c
@@ -33,6 +33,7 @@
 #include "miscadmin.h"
 #include "storage/lmgr.h"
 #include "storage/smgr.h"
+#include "storage/predicate.h"
 
 
 static bool _hash_alloc_buckets(Relation rel, BlockNumber firstblock,
@@ -1098,6 +1099,7 @@ _hash_splitbucket(Relation rel,
 	Size		all_tups_size = 0;
 	int			i;
 	uint16		nitups = 0;
+	bool		copied_first_tuple = false;
 
 	bucket_obuf = obuf;
 	opage = BufferGetPage(obuf);
@@ -1157,6 +1159,17 @@ _hash_splitbucket(Relation rel,
 			{
 				IndexTuple	new_itup;
 
+				if (!copied_first_tuple)
+				{
+					/*
+					 * Copy the predicate locks from old bucket to new bucket
+					 * only if we relocate any tuple to the new bucket.
+					 */
+					PredicateLockPageSplit(rel,
+										   BufferGetBlockNumber(bucket_obuf),
+										   BufferGetBlockNumber(bucket_nbuf));
+					copied_first_tuple = true;
+				}
 				/*
 				 * make a copy of index tuple as we have to scribble on it.
 				 */
diff --git a/src/backend/access/hash/hashsearch.c b/src/backend/access/hash/hashsearch.c
index c692c5b32d1..650041db0a5 100644
--- a/src/backend/access/hash/hashsearch.c
+++ b/src/backend/access/hash/hashsearch.c
@@ -19,6 +19,7 @@
 #include "miscadmin.h"
 #include "pgstat.h"
 #include "utils/rel.h"
+#include "storage/predicate.h"
 
 static bool _hash_readpage(IndexScanDesc scan, Buffer *bufP,
 			   ScanDirection dir);
@@ -171,6 +172,7 @@ _hash_readnext(IndexScanDesc scan,
 		Assert(BufferIsValid(*bufp));
 
 		LockBuffer(*bufp, BUFFER_LOCK_SHARE);
+		PredicateLockPage(rel, BufferGetBlockNumber(*bufp), scan->xs_snapshot);
 
 		/*
 		 * setting hashso_buc_split to true indicates that we are scanning
@@ -347,6 +349,7 @@ _hash_first(IndexScanDesc scan, ScanDirection dir)
 	so->hashso_sk_hash = hashkey;
 
 	buf = _hash_getbucketbuf_from_hashkey(rel, hashkey, HASH_READ, NULL);
+	PredicateLockPage(rel, BufferGetBlockNumber(buf), scan->xs_snapshot);
 	page = BufferGetPage(buf);
 	TestForOldSnapshot(scan->xs_snapshot, rel, page);
 	opaque = (HashPageOpaque) PageGetSpecialPointer(page);
diff --git a/src/backend/storage/lmgr/README-SSI b/src/backend/storage/lmgr/README-SSI
index a9dc01f237b..739efec81eb 100644
--- a/src/backend/storage/lmgr/README-SSI
+++ b/src/backend/storage/lmgr/README-SSI
@@ -379,6 +379,11 @@ level during a GiST search. An index insert at the leaf level can
 then be trusted to ripple up to all levels and locations where
 conflicting predicate locks may exist.
 
+    * Hash index searches acquire predicate locks on the primary
+page of a bucket. During a bucket split, a predicate lock is copied from
+the primary page of an old bucket to the primary page of a new bucket.
+
+
     * The effects of page splits, overflows, consolidations, and
 removals must be carefully reviewed to ensure that predicate locks
 aren't "lost" during those operations, or kept with pages which could
diff --git a/src/test/isolation/expected/predicate-hash.out b/src/test/isolation/expected/predicate-hash.out
new file mode 100644
index 00000000000..53e500fd26f
--- /dev/null
+++ b/src/test/isolation/expected/predicate-hash.out
@@ -0,0 +1,659 @@
+Parsed test spec with 2 sessions
+
+starting permutation: rxy1 wx1 c1 rxy2 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+600            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy2 wy2 c2 rxy1 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+400            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy3 wx3 c1 rxy4 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy4 wy4 c2 rxy3 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy1 wx1 rxy2 c1 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy1 wx1 rxy2 wy2 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 wx1 rxy2 wy2 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wx1 c1 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy1 rxy2 wx1 wy2 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wx1 wy2 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 wx1 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 wx1 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 c2 wx1 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy2 rxy1 wx1 c1 wy2 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy2 rxy1 wx1 wy2 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wx1 wy2 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 wx1 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 wx1 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 c2 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy2 wy2 rxy1 wx1 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 wy2 rxy1 wx1 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 wy2 rxy1 c2 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy3 wx3 rxy4 c1 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy3 wx3 rxy4 wy4 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 wx3 rxy4 wy4 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wx3 c1 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wx3 wy4 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wx3 wy4 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wy4 wx3 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wy4 wx3 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wy4 c2 wx3 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wx3 c1 wy4 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wx3 wy4 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wx3 wy4 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wy4 wx3 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wy4 wx3 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wy4 c2 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy4 wy4 rxy3 wx3 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 wy4 rxy3 wx3 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 wy4 rxy3 c2 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
diff --git a/src/test/isolation/isolation_schedule b/src/test/isolation/isolation_schedule
index 74d7d59546a..cb3b0d8cb22 100644
--- a/src/test/isolation/isolation_schedule
+++ b/src/test/isolation/isolation_schedule
@@ -66,3 +66,4 @@ test: async-notify
 test: vacuum-reltuples
 test: timeouts
 test: vacuum-concurrent-drop
+test: predicate-hash
diff --git a/src/test/isolation/specs/predicate-hash.spec b/src/test/isolation/specs/predicate-hash.spec
new file mode 100644
index 00000000000..8c83cb33e19
--- /dev/null
+++ b/src/test/isolation/specs/predicate-hash.spec
@@ -0,0 +1,122 @@
+# Test for page level predicate locking in hash 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 bucket of the index
+# whereas to check reduced false positives, they will try to access different
+# buckets of the index.
+
+setup
+{
+ create table hash_tbl(id int4, p integer);
+ create index hash_idx on hash_tbl using hash(p);
+ insert into hash_tbl (id, p)
+ select g, 10 from generate_series(1, 10) g;
+ insert into hash_tbl (id, p)
+ select g, 20 from generate_series(11, 20) g;
+ insert into hash_tbl (id, p)
+ select g, 30 from generate_series(21, 30) g;
+ insert into hash_tbl (id, p)
+ select g, 40 from generate_series(31, 40) g;
+}
+
+teardown
+{
+ drop table hash_tbl;
+}
+
+session "s1"
+setup		
+{
+ begin isolation level serializable;
+ set enable_seqscan=off;
+ set enable_bitmapscan=off;
+ set enable_indexonlyscan=on;
+}
+step "rxy1"	{ select sum(p) from hash_tbl where p=20; }
+step "wx1"	{ insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g; }
+step "rxy3"	{ select sum(p) from hash_tbl where p=20; }
+step "wx3"	{ insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g; }
+step "c1"	{ commit; }
+
+
+session "s2"
+setup		
+{
+ begin isolation level serializable;
+ set enable_seqscan=off;
+ set enable_bitmapscan=off;
+ set enable_indexonlyscan=on;
+}
+step "rxy2"	{ select sum(p) from hash_tbl where p=30; }
+step "wy2"	{ insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g; }
+step "rxy4"	{ select sum(p) from hash_tbl where p=30; }
+step "wy4"	{ insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g; }
+step "c2"	{ commit; }
+
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access the same bucket of the index but one transaction
+# commits before other transaction begins so no r-w conflict.
+
+permutation "rxy1" "wx1" "c1" "rxy2" "wy2" "c2"
+permutation "rxy2" "wy2" "c2" "rxy1" "wx1" "c1"
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access different buckets of the index and also one
+# transaction commits before other transaction begins, so no r-w conflict.
+
+permutation "rxy3" "wx3" "c1" "rxy4" "wy4" "c2"
+permutation "rxy4" "wy4" "c2" "rxy3" "wx3" "c1"
+
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access the same bucket of the index and one transaction
+# begins before other transaction commits so there is a r-w conflict.
+
+permutation "rxy1" "wx1" "rxy2" "c1" "wy2" "c2"
+permutation "rxy1" "wx1" "rxy2" "wy2" "c1" "c2"
+permutation "rxy1" "wx1" "rxy2" "wy2" "c2" "c1"
+permutation "rxy1" "rxy2" "wx1" "c1" "wy2" "c2"
+permutation "rxy1" "rxy2" "wx1" "wy2" "c1" "c2"
+permutation "rxy1" "rxy2" "wx1" "wy2" "c2" "c1"
+permutation "rxy1" "rxy2" "wy2" "wx1" "c1" "c2"
+permutation "rxy1" "rxy2" "wy2" "wx1" "c2" "c1"
+permutation "rxy1" "rxy2" "wy2" "c2" "wx1" "c1"
+permutation "rxy2" "rxy1" "wx1" "c1" "wy2" "c2"
+permutation "rxy2" "rxy1" "wx1" "wy2" "c1" "c2"
+permutation "rxy2" "rxy1" "wx1" "wy2" "c2" "c1"
+permutation "rxy2" "rxy1" "wy2" "wx1" "c1" "c2"
+permutation "rxy2" "rxy1" "wy2" "wx1" "c2" "c1"
+permutation "rxy2" "rxy1" "wy2" "c2" "wx1" "c1"
+permutation "rxy2" "wy2" "rxy1" "wx1" "c1" "c2"
+permutation "rxy2" "wy2" "rxy1" "wx1" "c2" "c1"
+permutation "rxy2" "wy2" "rxy1" "c2" "wx1" "c1"
+
+# An index scan (from one transaction) and an index insert (from another 
+# transaction) try to access different buckets of the index so no r-w conflict.
+
+permutation "rxy3" "wx3" "rxy4" "c1" "wy4" "c2"
+permutation "rxy3" "wx3" "rxy4" "wy4" "c1" "c2"
+permutation "rxy3" "wx3" "rxy4" "wy4" "c2" "c1"
+permutation "rxy3" "rxy4" "wx3" "c1" "wy4" "c2"
+permutation "rxy3" "rxy4" "wx3" "wy4" "c1" "c2"
+permutation "rxy3" "rxy4" "wx3" "wy4" "c2" "c1"
+permutation "rxy3" "rxy4" "wy4" "wx3" "c1" "c2"
+permutation "rxy3" "rxy4" "wy4" "wx3" "c2" "c1"
+permutation "rxy3" "rxy4" "wy4" "c2" "wx3" "c1"
+permutation "rxy4" "rxy3" "wx3" "c1" "wy4" "c2"
+permutation "rxy4" "rxy3" "wx3" "wy4" "c1" "c2"
+permutation "rxy4" "rxy3" "wx3" "wy4" "c2" "c1"
+permutation "rxy4" "rxy3" "wy4" "wx3" "c1" "c2"
+permutation "rxy4" "rxy3" "wy4" "wx3" "c2" "c1"
+permutation "rxy4" "rxy3" "wy4" "c2" "wx3" "c1"
+permutation "rxy4" "wy4" "rxy3" "wx3" "c1" "c2"
+permutation "rxy4" "wy4" "rxy3" "wx3" "c2" "c1"
+permutation "rxy4" "wy4" "rxy3" "c2" "wx3" "c1"

diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c
index e337439..4f2ea79 100644
--- a/src/backend/access/hash/hash.c
+++ b/src/backend/access/hash/hash.c
@@ -68,7 +68,7 @@ hashhandler(PG_FUNCTION_ARGS)
 	amroutine->amsearchnulls = false;
 	amroutine->amstorage = false;
 	amroutine->amclusterable = false;
-	amroutine->ampredlocks = false;
+	amroutine->ampredlocks = true;
 	amroutine->amcanparallel = false;
 	amroutine->amkeytype = INT4OID;
 
diff --git a/src/backend/access/hash/hashinsert.c b/src/backend/access/hash/hashinsert.c
index f121286..3eb722c 100644
--- a/src/backend/access/hash/hashinsert.c
+++ b/src/backend/access/hash/hashinsert.c
@@ -22,6 +22,7 @@
 #include "utils/rel.h"
 #include "storage/lwlock.h"
 #include "storage/buf_internals.h"
+#include "storage/predicate.h"
 
 static void _hash_vacuum_one_page(Relation rel, Buffer metabuf, Buffer buf,
 					  RelFileNode hnode);
@@ -88,6 +89,8 @@ restart_insert:
 										  &usedmetap);
 	Assert(usedmetap != NULL);
 
+	CheckForSerializableConflictIn(rel, NULL, buf);
+
 	/* remember the primary bucket buffer to release the pin on it at end. */
 	bucket_buf = buf;
 
diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c
index 3859e3b..c26cf76 100644
--- a/src/backend/access/hash/hashpage.c
+++ b/src/backend/access/hash/hashpage.c
@@ -33,6 +33,7 @@
 #include "miscadmin.h"
 #include "storage/lmgr.h"
 #include "storage/smgr.h"
+#include "storage/predicate.h"
 
 
 static bool _hash_alloc_buckets(Relation rel, BlockNumber firstblock,
@@ -1098,6 +1099,7 @@ _hash_splitbucket(Relation rel,
 	Size		all_tups_size = 0;
 	int			i;
 	uint16		nitups = 0;
+	bool		copied_first_tuple = false;
 
 	bucket_obuf = obuf;
 	opage = BufferGetPage(obuf);
@@ -1157,6 +1159,17 @@ _hash_splitbucket(Relation rel,
 			{
 				IndexTuple	new_itup;
 
+				if (!copied_first_tuple)
+				{
+					/*
+					 * Copy the predicate locks from old bucket to new bucket
+					 * only if we relocate any tuple to the new bucket.
+					 */
+					PredicateLockPageSplit(rel,
+										   BufferGetBlockNumber(bucket_obuf),
+										   BufferGetBlockNumber(bucket_nbuf));
+					copied_first_tuple = true;
+				}
 				/*
 				 * make a copy of index tuple as we have to scribble on it.
 				 */
diff --git a/src/backend/access/hash/hashsearch.c b/src/backend/access/hash/hashsearch.c
index c692c5b..650041d 100644
--- a/src/backend/access/hash/hashsearch.c
+++ b/src/backend/access/hash/hashsearch.c
@@ -19,6 +19,7 @@
 #include "miscadmin.h"
 #include "pgstat.h"
 #include "utils/rel.h"
+#include "storage/predicate.h"
 
 static bool _hash_readpage(IndexScanDesc scan, Buffer *bufP,
 			   ScanDirection dir);
@@ -171,6 +172,7 @@ _hash_readnext(IndexScanDesc scan,
 		Assert(BufferIsValid(*bufp));
 
 		LockBuffer(*bufp, BUFFER_LOCK_SHARE);
+		PredicateLockPage(rel, BufferGetBlockNumber(*bufp), scan->xs_snapshot);
 
 		/*
 		 * setting hashso_buc_split to true indicates that we are scanning
@@ -347,6 +349,7 @@ _hash_first(IndexScanDesc scan, ScanDirection dir)
 	so->hashso_sk_hash = hashkey;
 
 	buf = _hash_getbucketbuf_from_hashkey(rel, hashkey, HASH_READ, NULL);
+	PredicateLockPage(rel, BufferGetBlockNumber(buf), scan->xs_snapshot);
 	page = BufferGetPage(buf);
 	TestForOldSnapshot(scan->xs_snapshot, rel, page);
 	opaque = (HashPageOpaque) PageGetSpecialPointer(page);
diff --git a/src/backend/storage/lmgr/README-SSI b/src/backend/storage/lmgr/README-SSI
index a9dc01f..a730506 100644
--- a/src/backend/storage/lmgr/README-SSI
+++ b/src/backend/storage/lmgr/README-SSI
@@ -379,6 +379,13 @@ level during a GiST search. An index insert at the leaf level can
 then be trusted to ripple up to all levels and locations where
 conflicting predicate locks may exist.
 
+    * Hash index searches acquire predicate locks on the primary
+page of a bucket. It acquires a lock on both the old and new buckets
+for scans that happen concurrently with page splits. During a bucket
+split, a predicate lock is copied from the primary page of an old
+bucket to the primary page of a new bucket.
+
+
     * The effects of page splits, overflows, consolidations, and
 removals must be carefully reviewed to ensure that predicate locks
 aren't "lost" during those operations, or kept with pages which could
diff --git a/src/test/isolation/expected/predicate-hash.out b/src/test/isolation/expected/predicate-hash.out
new file mode 100644
index 0000000..53e500f
--- /dev/null
+++ b/src/test/isolation/expected/predicate-hash.out
@@ -0,0 +1,659 @@
+Parsed test spec with 2 sessions
+
+starting permutation: rxy1 wx1 c1 rxy2 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+600            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy2 wy2 c2 rxy1 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+400            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy3 wx3 c1 rxy4 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy4 wy4 c2 rxy3 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy1 wx1 rxy2 c1 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy1 wx1 rxy2 wy2 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 wx1 rxy2 wy2 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wx1 c1 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy1 rxy2 wx1 wy2 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wx1 wy2 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 wx1 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 wx1 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 c2 wx1 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy2 rxy1 wx1 c1 wy2 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy2 rxy1 wx1 wy2 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wx1 wy2 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 wx1 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 wx1 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 c2 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy2 wy2 rxy1 wx1 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 wy2 rxy1 wx1 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 wy2 rxy1 c2 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy3 wx3 rxy4 c1 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy3 wx3 rxy4 wy4 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 wx3 rxy4 wy4 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wx3 c1 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wx3 wy4 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wx3 wy4 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wy4 wx3 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wy4 wx3 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wy4 c2 wx3 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wx3 c1 wy4 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wx3 wy4 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wx3 wy4 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wy4 wx3 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wy4 wx3 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wy4 c2 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy4 wy4 rxy3 wx3 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 wy4 rxy3 wx3 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 wy4 rxy3 c2 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
diff --git a/src/test/isolation/isolation_schedule b/src/test/isolation/isolation_schedule
index 74d7d59..cb3b0d8 100644
--- a/src/test/isolation/isolation_schedule
+++ b/src/test/isolation/isolation_schedule
@@ -66,3 +66,4 @@ test: async-notify
 test: vacuum-reltuples
 test: timeouts
 test: vacuum-concurrent-drop
+test: predicate-hash
diff --git a/src/test/isolation/specs/predicate-hash.spec b/src/test/isolation/specs/predicate-hash.spec
new file mode 100644
index 0000000..8c83cb3
--- /dev/null
+++ b/src/test/isolation/specs/predicate-hash.spec
@@ -0,0 +1,122 @@
+# Test for page level predicate locking in hash 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 bucket of the index
+# whereas to check reduced false positives, they will try to access different
+# buckets of the index.
+
+setup
+{
+ create table hash_tbl(id int4, p integer);
+ create index hash_idx on hash_tbl using hash(p);
+ insert into hash_tbl (id, p)
+ select g, 10 from generate_series(1, 10) g;
+ insert into hash_tbl (id, p)
+ select g, 20 from generate_series(11, 20) g;
+ insert into hash_tbl (id, p)
+ select g, 30 from generate_series(21, 30) g;
+ insert into hash_tbl (id, p)
+ select g, 40 from generate_series(31, 40) g;
+}
+
+teardown
+{
+ drop table hash_tbl;
+}
+
+session "s1"
+setup		
+{
+ begin isolation level serializable;
+ set enable_seqscan=off;
+ set enable_bitmapscan=off;
+ set enable_indexonlyscan=on;
+}
+step "rxy1"	{ select sum(p) from hash_tbl where p=20; }
+step "wx1"	{ insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g; }
+step "rxy3"	{ select sum(p) from hash_tbl where p=20; }
+step "wx3"	{ insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g; }
+step "c1"	{ commit; }
+
+
+session "s2"
+setup		
+{
+ begin isolation level serializable;
+ set enable_seqscan=off;
+ set enable_bitmapscan=off;
+ set enable_indexonlyscan=on;
+}
+step "rxy2"	{ select sum(p) from hash_tbl where p=30; }
+step "wy2"	{ insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g; }
+step "rxy4"	{ select sum(p) from hash_tbl where p=30; }
+step "wy4"	{ insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g; }
+step "c2"	{ commit; }
+
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access the same bucket of the index but one transaction
+# commits before other transaction begins so no r-w conflict.
+
+permutation "rxy1" "wx1" "c1" "rxy2" "wy2" "c2"
+permutation "rxy2" "wy2" "c2" "rxy1" "wx1" "c1"
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access different buckets of the index and also one
+# transaction commits before other transaction begins, so no r-w conflict.
+
+permutation "rxy3" "wx3" "c1" "rxy4" "wy4" "c2"
+permutation "rxy4" "wy4" "c2" "rxy3" "wx3" "c1"
+
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access the same bucket of the index and one transaction
+# begins before other transaction commits so there is a r-w conflict.
+
+permutation "rxy1" "wx1" "rxy2" "c1" "wy2" "c2"
+permutation "rxy1" "wx1" "rxy2" "wy2" "c1" "c2"
+permutation "rxy1" "wx1" "rxy2" "wy2" "c2" "c1"
+permutation "rxy1" "rxy2" "wx1" "c1" "wy2" "c2"
+permutation "rxy1" "rxy2" "wx1" "wy2" "c1" "c2"
+permutation "rxy1" "rxy2" "wx1" "wy2" "c2" "c1"
+permutation "rxy1" "rxy2" "wy2" "wx1" "c1" "c2"
+permutation "rxy1" "rxy2" "wy2" "wx1" "c2" "c1"
+permutation "rxy1" "rxy2" "wy2" "c2" "wx1" "c1"
+permutation "rxy2" "rxy1" "wx1" "c1" "wy2" "c2"
+permutation "rxy2" "rxy1" "wx1" "wy2" "c1" "c2"
+permutation "rxy2" "rxy1" "wx1" "wy2" "c2" "c1"
+permutation "rxy2" "rxy1" "wy2" "wx1" "c1" "c2"
+permutation "rxy2" "rxy1" "wy2" "wx1" "c2" "c1"
+permutation "rxy2" "rxy1" "wy2" "c2" "wx1" "c1"
+permutation "rxy2" "wy2" "rxy1" "wx1" "c1" "c2"
+permutation "rxy2" "wy2" "rxy1" "wx1" "c2" "c1"
+permutation "rxy2" "wy2" "rxy1" "c2" "wx1" "c1"
+
+# An index scan (from one transaction) and an index insert (from another 
+# transaction) try to access different buckets of the index so no r-w conflict.
+
+permutation "rxy3" "wx3" "rxy4" "c1" "wy4" "c2"
+permutation "rxy3" "wx3" "rxy4" "wy4" "c1" "c2"
+permutation "rxy3" "wx3" "rxy4" "wy4" "c2" "c1"
+permutation "rxy3" "rxy4" "wx3" "c1" "wy4" "c2"
+permutation "rxy3" "rxy4" "wx3" "wy4" "c1" "c2"
+permutation "rxy3" "rxy4" "wx3" "wy4" "c2" "c1"
+permutation "rxy3" "rxy4" "wy4" "wx3" "c1" "c2"
+permutation "rxy3" "rxy4" "wy4" "wx3" "c2" "c1"
+permutation "rxy3" "rxy4" "wy4" "c2" "wx3" "c1"
+permutation "rxy4" "rxy3" "wx3" "c1" "wy4" "c2"
+permutation "rxy4" "rxy3" "wx3" "wy4" "c1" "c2"
+permutation "rxy4" "rxy3" "wx3" "wy4" "c2" "c1"
+permutation "rxy4" "rxy3" "wy4" "wx3" "c1" "c2"
+permutation "rxy4" "rxy3" "wy4" "wx3" "c2" "c1"
+permutation "rxy4" "rxy3" "wy4" "c2" "wx3" "c1"
+permutation "rxy4" "wy4" "rxy3" "wx3" "c1" "c2"
+permutation "rxy4" "wy4" "rxy3" "wx3" "c2" "c1"
+permutation "rxy4" "wy4" "rxy3" "c2" "wx3" "c1"

diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c
index e337439..4f2ea79 100644
--- a/src/backend/access/hash/hash.c
+++ b/src/backend/access/hash/hash.c
@@ -68,7 +68,7 @@ hashhandler(PG_FUNCTION_ARGS)
 	amroutine->amsearchnulls = false;
 	amroutine->amstorage = false;
 	amroutine->amclusterable = false;
-	amroutine->ampredlocks = false;
+	amroutine->ampredlocks = true;
 	amroutine->amcanparallel = false;
 	amroutine->amkeytype = INT4OID;
 
diff --git a/src/backend/access/hash/hashinsert.c b/src/backend/access/hash/hashinsert.c
index f121286..3eb722c 100644
--- a/src/backend/access/hash/hashinsert.c
+++ b/src/backend/access/hash/hashinsert.c
@@ -22,6 +22,7 @@
 #include "utils/rel.h"
 #include "storage/lwlock.h"
 #include "storage/buf_internals.h"
+#include "storage/predicate.h"
 
 static void _hash_vacuum_one_page(Relation rel, Buffer metabuf, Buffer buf,
 					  RelFileNode hnode);
@@ -88,6 +89,8 @@ restart_insert:
 										  &usedmetap);
 	Assert(usedmetap != NULL);
 
+	CheckForSerializableConflictIn(rel, NULL, buf);
+
 	/* remember the primary bucket buffer to release the pin on it at end. */
 	bucket_buf = buf;
 
diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c
index 3859e3b..3ec29a5 100644
--- a/src/backend/access/hash/hashpage.c
+++ b/src/backend/access/hash/hashpage.c
@@ -33,6 +33,7 @@
 #include "miscadmin.h"
 #include "storage/lmgr.h"
 #include "storage/smgr.h"
+#include "storage/predicate.h"
 
 
 static bool _hash_alloc_buckets(Relation rel, BlockNumber firstblock,
@@ -1107,6 +1108,11 @@ _hash_splitbucket(Relation rel,
 	npage = BufferGetPage(nbuf);
 	nopaque = (HashPageOpaque) PageGetSpecialPointer(npage);
 
+	/* Copy the predicate locks from old bucket to new bucket. */
+	PredicateLockPageSplit(rel,
+						   BufferGetBlockNumber(bucket_obuf),
+						   BufferGetBlockNumber(bucket_nbuf));
+
 	/*
 	 * Partition the tuples in the old bucket between the old bucket and the
 	 * new bucket, advancing along the old bucket's overflow bucket chain and
diff --git a/src/backend/access/hash/hashsearch.c b/src/backend/access/hash/hashsearch.c
index c692c5b..650041d 100644
--- a/src/backend/access/hash/hashsearch.c
+++ b/src/backend/access/hash/hashsearch.c
@@ -19,6 +19,7 @@
 #include "miscadmin.h"
 #include "pgstat.h"
 #include "utils/rel.h"
+#include "storage/predicate.h"
 
 static bool _hash_readpage(IndexScanDesc scan, Buffer *bufP,
 			   ScanDirection dir);
@@ -171,6 +172,7 @@ _hash_readnext(IndexScanDesc scan,
 		Assert(BufferIsValid(*bufp));
 
 		LockBuffer(*bufp, BUFFER_LOCK_SHARE);
+		PredicateLockPage(rel, BufferGetBlockNumber(*bufp), scan->xs_snapshot);
 
 		/*
 		 * setting hashso_buc_split to true indicates that we are scanning
@@ -347,6 +349,7 @@ _hash_first(IndexScanDesc scan, ScanDirection dir)
 	so->hashso_sk_hash = hashkey;
 
 	buf = _hash_getbucketbuf_from_hashkey(rel, hashkey, HASH_READ, NULL);
+	PredicateLockPage(rel, BufferGetBlockNumber(buf), scan->xs_snapshot);
 	page = BufferGetPage(buf);
 	TestForOldSnapshot(scan->xs_snapshot, rel, page);
 	opaque = (HashPageOpaque) PageGetSpecialPointer(page);
diff --git a/src/backend/storage/lmgr/README-SSI b/src/backend/storage/lmgr/README-SSI
index a9dc01f..a730506 100644
--- a/src/backend/storage/lmgr/README-SSI
+++ b/src/backend/storage/lmgr/README-SSI
@@ -379,6 +379,13 @@ level during a GiST search. An index insert at the leaf level can
 then be trusted to ripple up to all levels and locations where
 conflicting predicate locks may exist.
 
+    * Hash index searches acquire predicate locks on the primary
+page of a bucket. It acquires a lock on both the old and new buckets
+for scans that happen concurrently with page splits. During a bucket
+split, a predicate lock is copied from the primary page of an old
+bucket to the primary page of a new bucket.
+
+
     * The effects of page splits, overflows, consolidations, and
 removals must be carefully reviewed to ensure that predicate locks
 aren't "lost" during those operations, or kept with pages which could
diff --git a/src/test/isolation/expected/predicate-hash.out b/src/test/isolation/expected/predicate-hash.out
new file mode 100644
index 0000000..53e500f
--- /dev/null
+++ b/src/test/isolation/expected/predicate-hash.out
@@ -0,0 +1,659 @@
+Parsed test spec with 2 sessions
+
+starting permutation: rxy1 wx1 c1 rxy2 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+600            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy2 wy2 c2 rxy1 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+400            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy3 wx3 c1 rxy4 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy4 wy4 c2 rxy3 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy1 wx1 rxy2 c1 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy1 wx1 rxy2 wy2 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 wx1 rxy2 wy2 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wx1 c1 wy2 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy1 rxy2 wx1 wy2 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wx1 wy2 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 wx1 c1 c2
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 wx1 c2 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy1 rxy2 wy2 c2 wx1 c1
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy2 rxy1 wx1 c1 wy2 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c2: commit;
+
+starting permutation: rxy2 rxy1 wx1 wy2 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wx1 wy2 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 wx1 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 wx1 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 rxy1 wy2 c2 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy2 wy2 rxy1 wx1 c1 c2
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 wy2 rxy1 wx1 c2 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+
+starting permutation: rxy2 wy2 rxy1 c2 wx1 c1
+step rxy2: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy2: insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g;
+step rxy1: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step c2: commit;
+step wx1: insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g;
+ERROR:  could not serialize access due to read/write dependencies among transactions
+step c1: commit;
+
+starting permutation: rxy3 wx3 rxy4 c1 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy3 wx3 rxy4 wy4 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 wx3 rxy4 wy4 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wx3 c1 wy4 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wx3 wy4 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wx3 wy4 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wy4 wx3 c1 c2
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy3 rxy4 wy4 wx3 c2 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy3 rxy4 wy4 c2 wx3 c1
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wx3 c1 wy4 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wx3 wy4 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wx3 wy4 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wy4 wx3 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 rxy3 wy4 wx3 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 rxy3 wy4 c2 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+
+starting permutation: rxy4 wy4 rxy3 wx3 c1 c2
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
+step c2: commit;
+
+starting permutation: rxy4 wy4 rxy3 wx3 c2 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c2: commit;
+step c1: commit;
+
+starting permutation: rxy4 wy4 rxy3 c2 wx3 c1
+step rxy4: select sum(p) from hash_tbl where p=30;
+sum            
+
+300            
+step wy4: insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g;
+step rxy3: select sum(p) from hash_tbl where p=20;
+sum            
+
+200            
+step c2: commit;
+step wx3: insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g;
+step c1: commit;
diff --git a/src/test/isolation/isolation_schedule b/src/test/isolation/isolation_schedule
index 74d7d59..cb3b0d8 100644
--- a/src/test/isolation/isolation_schedule
+++ b/src/test/isolation/isolation_schedule
@@ -66,3 +66,4 @@ test: async-notify
 test: vacuum-reltuples
 test: timeouts
 test: vacuum-concurrent-drop
+test: predicate-hash
diff --git a/src/test/isolation/specs/predicate-hash.spec b/src/test/isolation/specs/predicate-hash.spec
new file mode 100644
index 0000000..8c83cb3
--- /dev/null
+++ b/src/test/isolation/specs/predicate-hash.spec
@@ -0,0 +1,122 @@
+# Test for page level predicate locking in hash 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 bucket of the index
+# whereas to check reduced false positives, they will try to access different
+# buckets of the index.
+
+setup
+{
+ create table hash_tbl(id int4, p integer);
+ create index hash_idx on hash_tbl using hash(p);
+ insert into hash_tbl (id, p)
+ select g, 10 from generate_series(1, 10) g;
+ insert into hash_tbl (id, p)
+ select g, 20 from generate_series(11, 20) g;
+ insert into hash_tbl (id, p)
+ select g, 30 from generate_series(21, 30) g;
+ insert into hash_tbl (id, p)
+ select g, 40 from generate_series(31, 40) g;
+}
+
+teardown
+{
+ drop table hash_tbl;
+}
+
+session "s1"
+setup		
+{
+ begin isolation level serializable;
+ set enable_seqscan=off;
+ set enable_bitmapscan=off;
+ set enable_indexonlyscan=on;
+}
+step "rxy1"	{ select sum(p) from hash_tbl where p=20; }
+step "wx1"	{ insert into hash_tbl (id, p)
+			  select g, 30 from generate_series(41, 50) g; }
+step "rxy3"	{ select sum(p) from hash_tbl where p=20; }
+step "wx3"	{ insert into hash_tbl (id, p)
+			  select g, 50 from generate_series(41, 50) g; }
+step "c1"	{ commit; }
+
+
+session "s2"
+setup		
+{
+ begin isolation level serializable;
+ set enable_seqscan=off;
+ set enable_bitmapscan=off;
+ set enable_indexonlyscan=on;
+}
+step "rxy2"	{ select sum(p) from hash_tbl where p=30; }
+step "wy2"	{ insert into hash_tbl (id, p)
+			  select g, 20 from generate_series(51, 60) g; }
+step "rxy4"	{ select sum(p) from hash_tbl where p=30; }
+step "wy4"	{ insert into hash_tbl (id, p)
+			  select g, 60 from generate_series(51, 60) g; }
+step "c2"	{ commit; }
+
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access the same bucket of the index but one transaction
+# commits before other transaction begins so no r-w conflict.
+
+permutation "rxy1" "wx1" "c1" "rxy2" "wy2" "c2"
+permutation "rxy2" "wy2" "c2" "rxy1" "wx1" "c1"
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access different buckets of the index and also one
+# transaction commits before other transaction begins, so no r-w conflict.
+
+permutation "rxy3" "wx3" "c1" "rxy4" "wy4" "c2"
+permutation "rxy4" "wy4" "c2" "rxy3" "wx3" "c1"
+
+
+# An index scan (from one transaction) and an index insert (from another
+# transaction) try to access the same bucket of the index and one transaction
+# begins before other transaction commits so there is a r-w conflict.
+
+permutation "rxy1" "wx1" "rxy2" "c1" "wy2" "c2"
+permutation "rxy1" "wx1" "rxy2" "wy2" "c1" "c2"
+permutation "rxy1" "wx1" "rxy2" "wy2" "c2" "c1"
+permutation "rxy1" "rxy2" "wx1" "c1" "wy2" "c2"
+permutation "rxy1" "rxy2" "wx1" "wy2" "c1" "c2"
+permutation "rxy1" "rxy2" "wx1" "wy2" "c2" "c1"
+permutation "rxy1" "rxy2" "wy2" "wx1" "c1" "c2"
+permutation "rxy1" "rxy2" "wy2" "wx1" "c2" "c1"
+permutation "rxy1" "rxy2" "wy2" "c2" "wx1" "c1"
+permutation "rxy2" "rxy1" "wx1" "c1" "wy2" "c2"
+permutation "rxy2" "rxy1" "wx1" "wy2" "c1" "c2"
+permutation "rxy2" "rxy1" "wx1" "wy2" "c2" "c1"
+permutation "rxy2" "rxy1" "wy2" "wx1" "c1" "c2"
+permutation "rxy2" "rxy1" "wy2" "wx1" "c2" "c1"
+permutation "rxy2" "rxy1" "wy2" "c2" "wx1" "c1"
+permutation "rxy2" "wy2" "rxy1" "wx1" "c1" "c2"
+permutation "rxy2" "wy2" "rxy1" "wx1" "c2" "c1"
+permutation "rxy2" "wy2" "rxy1" "c2" "wx1" "c1"
+
+# An index scan (from one transaction) and an index insert (from another 
+# transaction) try to access different buckets of the index so no r-w conflict.
+
+permutation "rxy3" "wx3" "rxy4" "c1" "wy4" "c2"
+permutation "rxy3" "wx3" "rxy4" "wy4" "c1" "c2"
+permutation "rxy3" "wx3" "rxy4" "wy4" "c2" "c1"
+permutation "rxy3" "rxy4" "wx3" "c1" "wy4" "c2"
+permutation "rxy3" "rxy4" "wx3" "wy4" "c1" "c2"
+permutation "rxy3" "rxy4" "wx3" "wy4" "c2" "c1"
+permutation "rxy3" "rxy4" "wy4" "wx3" "c1" "c2"
+permutation "rxy3" "rxy4" "wy4" "wx3" "c2" "c1"
+permutation "rxy3" "rxy4" "wy4" "c2" "wx3" "c1"
+permutation "rxy4" "rxy3" "wx3" "c1" "wy4" "c2"
+permutation "rxy4" "rxy3" "wx3" "wy4" "c1" "c2"
+permutation "rxy4" "rxy3" "wx3" "wy4" "c2" "c1"
+permutation "rxy4" "rxy3" "wy4" "wx3" "c1" "c2"
+permutation "rxy4" "rxy3" "wy4" "wx3" "c2" "c1"
+permutation "rxy4" "rxy3" "wy4" "c2" "wx3" "c1"
+permutation "rxy4" "wy4" "rxy3" "wx3" "c1" "c2"
+permutation "rxy4" "wy4" "rxy3" "wx3" "c2" "c1"
+permutation "rxy4" "wy4" "rxy3" "c2" "wx3" "c1"