pgsql: Add hash partitioning.

From 224b6825dcef26e0dd86483453b6854e6b888181 Mon Sep 17 00:00:00 2001
From: Amul Sul <sulamul@gmail.com>
Date: Mon, 13 Nov 2017 12:30:28 +0530
Subject: [PATCH] argument validation

---
 src/backend/catalog/partition.c | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index cff59ed055..b170d10d5e 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -3407,6 +3407,17 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 	ColumnsHashData *my_extra;
 	uint64		rowHash = 0;
 
+	/*
+	 * Return false if any of the following violated:
+	 *
+	 * 	1. Parent id must be valid relation id,
+	 * 	2. Modulus must be a positive integer and
+	 * 	3. Remainder must be a non-negative integer less than the modulus.
+	 */
+	if (!OidIsValid(parentId) || modulus <= 0 || remainder < 0 ||
+		modulus <= remainder)
+		PG_RETURN_BOOL(false);
+
 	/*
 	 * Cache hash function information.
 	 */
@@ -3418,6 +3429,19 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 		PartitionKey key;
 		int j;
 
+		/* Open parent relation and fetch partition keyinfo */
+		parent = heap_open(parentId, AccessShareLock);
+
+		/* Return false if given parent is not a partitioned relation */
+		if (parent->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
+		{
+			heap_close(parent, AccessShareLock);
+			PG_RETURN_BOOL(false);
+		}
+
+		key = RelationGetPartitionKey(parent);
+		Assert(key->partnatts == nkeys);
+
 		fcinfo->flinfo->fn_extra =
 			MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
 								   offsetof(ColumnsHashData, partsupfunc) +
@@ -3426,11 +3450,6 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 		my_extra->nkeys = nkeys;
 		my_extra->relid = parentId;
 
-		/* Open parent relation and fetch partition keyinfo */
-		parent = heap_open(parentId, AccessShareLock);
-		key = RelationGetPartitionKey(parent);
-
-		Assert(key->partnatts == nkeys);
 		for (j = 0; j < nkeys; ++j)
 			fmgr_info_copy(&my_extra->partsupfunc[j],
 						   key->partsupfunc,
-- 
2.14.1

From b122296aade635c3e2e8912c20db0260514291e2 Mon Sep 17 00:00:00 2001
From: Amul Sul <sulamul@gmail.com>
Date: Mon, 13 Nov 2017 12:30:28 +0530
Subject: [PATCH] argument validation v2

---
 src/backend/catalog/partition.c | 32 ++++++++++++++++++++++++++------
 1 file changed, 26 insertions(+), 6 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index cff59ed055..bdcd2d447d 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -3407,6 +3407,18 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 	ColumnsHashData *my_extra;
 	uint64		rowHash = 0;
 
+	/*----------
+	 * Return false if any of the following violated:
+	 *
+	 * 	1. Parent id must be valid relation id,
+	 * 	2. Modulus must be a positive integer and
+	 * 	3. Remainder must be a non-negative integer less than the modulus.
+	 *----------
+	 */
+	if (!OidIsValid(parentId) || modulus <= 0 || remainder < 0 ||
+		modulus <= remainder)
+		PG_RETURN_BOOL(false);
+
 	/*
 	 * Cache hash function information.
 	 */
@@ -3416,7 +3428,20 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 	{
 		Relation	parent;
 		PartitionKey key;
-		int j;
+		int			j;
+
+		/* Open parent relation and fetch partition keyinfo */
+		parent = heap_open(parentId, AccessShareLock);
+
+		/* Return false if given parent is not a partitioned relation */
+		if (parent->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
+		{
+			heap_close(parent, AccessShareLock);
+			PG_RETURN_BOOL(false);
+		}
+
+		key = RelationGetPartitionKey(parent);
+		Assert(key->partnatts == nkeys);
 
 		fcinfo->flinfo->fn_extra =
 			MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
@@ -3426,11 +3451,6 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 		my_extra->nkeys = nkeys;
 		my_extra->relid = parentId;
 
-		/* Open parent relation and fetch partition keyinfo */
-		parent = heap_open(parentId, AccessShareLock);
-		key = RelationGetPartitionKey(parent);
-
-		Assert(key->partnatts == nkeys);
 		for (j = 0; j < nkeys; ++j)
 			fmgr_info_copy(&my_extra->partsupfunc[j],
 						   key->partsupfunc,
-- 
2.14.1

From 02f83ec98ae362e006f2f5ae178a445a8c142289 Mon Sep 17 00:00:00 2001
From: Amul Sul <sulamul@gmail.com>
Date: Thu, 16 Nov 2017 16:51:34 +0530
Subject: [PATCH 1/3] argument validation v3

---
 src/backend/catalog/partition.c | 65 +++++++++++++++++++++++++++++++++++------
 1 file changed, 56 insertions(+), 9 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index ce29ba2eda..ea93646509 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -3103,15 +3103,41 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 		int16		nkeys;
 		FmgrInfo	partsupfunc[PARTITION_MAX_KEYS];
 	}			ColumnsHashData;
-	Oid			parentId = PG_GETARG_OID(0);
-	int			modulus = PG_GETARG_INT32(1);
-	int			remainder = PG_GETARG_INT32(2);
+	Oid			parentId;
+	int			modulus;
+	int			remainder;
 	short		nkeys = PG_NARGS() - 3;
 	int			i;
 	Datum		seed = UInt64GetDatum(HASH_PARTITION_SEED);
 	ColumnsHashData *my_extra;
 	uint64		rowHash = 0;
 
+	/*----------
+	 * Error out if any of the following violated:
+	 *
+	 *  1. Parent id, modulus, and the remainder should not be null.
+	 * 	2. Parent id must be valid relation id,
+	 * 	3. Modulus must be a positive integer and
+	 * 	4. Remainder must be a non-negative integer less than the modulus.
+	 *----------
+	 */
+	if (!(PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)))
+	{
+		parentId = PG_GETARG_OID(0);
+		modulus = PG_GETARG_INT32(1);
+		remainder = PG_GETARG_INT32(2);
+
+		if (!OidIsValid(parentId) || modulus <= 0 || remainder < 0 ||
+			modulus <= remainder)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("invalid hash partition bound")));
+	}
+	else
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("parent relation id, modulus and the remainder cannot be null")));
+
 	/*
 	 * Cache hash function information.
 	 */
@@ -3121,7 +3147,33 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 	{
 		Relation	parent;
 		PartitionKey key;
-		int j;
+		int			j;
+
+		/* Open parent relation and fetch partition keyinfo */
+		parent = heap_open(parentId, AccessShareLock);
+		key = RelationGetPartitionKey(parent);
+
+		if (parent->rd_rel->relkind != RELKIND_PARTITIONED_TABLE ||
+			key->strategy != PARTITION_STRATEGY_HASH)
+		{
+			heap_close(parent, AccessShareLock);
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("\"%s\" is not a hash partitioned table",
+							get_rel_name(parentId))));
+		}
+
+		/* complain if too few column values; we ignore extras, however */
+		if (key->partnatts > nkeys)
+		{
+			heap_close(parent, AccessShareLock);
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("value missing for partition column %d",
+							(nkeys + 1))));
+		}
+		else
+			nkeys = key->partnatts;
 
 		fcinfo->flinfo->fn_extra =
 			MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
@@ -3131,11 +3183,6 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 		my_extra->nkeys = nkeys;
 		my_extra->relid = parentId;
 
-		/* Open parent relation and fetch partition keyinfo */
-		parent = heap_open(parentId, AccessShareLock);
-		key = RelationGetPartitionKey(parent);
-
-		Assert(key->partnatts == nkeys);
 		for (j = 0; j < nkeys; ++j)
 			fmgr_info_copy(&my_extra->partsupfunc[j],
 						   key->partsupfunc,
-- 
2.14.1

From 0d107e7efcbe191ce7f16d9f79cb16344566bbb8 Mon Sep 17 00:00:00 2001
From: Amul Sul <sulamul@gmail.com>
Date: Thu, 16 Nov 2017 19:11:18 +0530
Subject: [PATCH 2/3] WIP-regression-tests

---
 src/test/regress/expected/func_sanity.out | 35 +++++++++++++++++++++++++++++++
 src/test/regress/parallel_schedule        |  3 +++
 src/test/regress/sql/func_sanity.sql      | 28 +++++++++++++++++++++++++
 3 files changed, 66 insertions(+)
 create mode 100644 src/test/regress/expected/func_sanity.out
 create mode 100644 src/test/regress/sql/func_sanity.sql

diff --git a/src/test/regress/expected/func_sanity.out b/src/test/regress/expected/func_sanity.out
new file mode 100644
index 0000000000..0f85e4a1a1
--- /dev/null
+++ b/src/test/regress/expected/func_sanity.out
@@ -0,0 +1,35 @@
+--
+-- FUNC_SANITY
+-- Sanity checks for common errors in making error
+-- in function argument handling.
+--
+-- **************** satisfies_hash_partition ****************
+CREATE TABLE hash_parted(a int, b int) PARTITION BY HASH(a, b);
+CREATE TABLE list_parted(a int, b int) PARTITION BY LIST(a);
+-- Parent relation id, modulus and the remainder should not be null
+SELECT satisfies_hash_partition(NULL, NULL, NULL, NULL, NULL);
+ERROR:  parent relation id, modulus and the remainder cannot be null
+SELECT satisfies_hash_partition('hash_parted'::regclass, NULL, NULL, NULL, NULL);
+ERROR:  parent relation id, modulus and the remainder cannot be null
+SELECT satisfies_hash_partition('hash_parted'::regclass, 5, NULL, NULL, NULL);
+ERROR:  parent relation id, modulus and the remainder cannot be null
+-- Remainder is greater than modulus
+SELECT satisfies_hash_partition('hash_parted'::regclass, 5, 6, NULL, NULL);
+ERROR:  invalid hash partition bound
+-- Invalid modulus
+SELECT satisfies_hash_partition('hash_parted'::regclass, 0, 0, NULL, NULL);
+ERROR:  invalid hash partition bound
+-- Invalid parent relation id
+SELECT satisfies_hash_partition(0, 6, 0, NULL, NULL);
+ERROR:  invalid hash partition bound
+-- Parent is not a hash partitioned table.
+SELECT satisfies_hash_partition('pg_class'::regclass, 7, 6, NULL, NULL);
+ERROR:  "pg_class" is not a hash partitioned table
+SELECT satisfies_hash_partition('list_parted'::regclass, 6, 2, NULL, NULL);
+ERROR:  "list_parted" is not a hash partitioned table
+-- Less column values than partition column
+SELECT satisfies_hash_partition('hash_parted'::regclass, 6, 2, NULL);
+ERROR:  value missing for partition column 2
+-- Clean up.
+DROP TABLE hash_parted;
+DROP TABLE list_parted;
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index aa5e6af621..4786bb0895 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -123,3 +123,6 @@ test: event_trigger
 
 # run stats by itself because its delay may be insufficient under heavy load
 test: stats
+
+# sanity check for catalog functions
+test: func_sanity
diff --git a/src/test/regress/sql/func_sanity.sql b/src/test/regress/sql/func_sanity.sql
new file mode 100644
index 0000000000..803dbdd691
--- /dev/null
+++ b/src/test/regress/sql/func_sanity.sql
@@ -0,0 +1,28 @@
+--
+-- FUNC_SANITY
+-- Sanity checks for common errors in making error
+-- in function argument handling.
+--
+
+-- **************** satisfies_hash_partition ****************
+CREATE TABLE hash_parted(a int, b int) PARTITION BY HASH(a, b);
+CREATE TABLE list_parted(a int, b int) PARTITION BY LIST(a);
+-- Parent relation id, modulus and the remainder should not be null
+SELECT satisfies_hash_partition(NULL, NULL, NULL, NULL, NULL);
+SELECT satisfies_hash_partition('hash_parted'::regclass, NULL, NULL, NULL, NULL);
+SELECT satisfies_hash_partition('hash_parted'::regclass, 5, NULL, NULL, NULL);
+-- Remainder is greater than modulus
+SELECT satisfies_hash_partition('hash_parted'::regclass, 5, 6, NULL, NULL);
+-- Invalid modulus
+SELECT satisfies_hash_partition('hash_parted'::regclass, 0, 0, NULL, NULL);
+-- Invalid parent relation id
+SELECT satisfies_hash_partition(0, 6, 0, NULL, NULL);
+-- Parent is not a hash partitioned table.
+SELECT satisfies_hash_partition('pg_class'::regclass, 7, 6, NULL, NULL);
+SELECT satisfies_hash_partition('list_parted'::regclass, 6, 2, NULL, NULL);
+-- Less column values than partition column
+SELECT satisfies_hash_partition('hash_parted'::regclass, 6, 2, NULL);
+
+-- Clean up.
+DROP TABLE hash_parted;
+DROP TABLE list_parted;
-- 
2.14.1

From 559f9882995c32c76423d92e9a602146408f7fe0 Mon Sep 17 00:00:00 2001
From: Amul Sul <sulamul@gmail.com>
Date: Thu, 16 Nov 2017 19:44:52 +0530
Subject: [PATCH 3/3] replace erreport by return false

---
 src/backend/catalog/partition.c           | 48 ++++++++-------------------
 src/test/regress/expected/func_sanity.out | 54 +++++++++++++++++++++++++------
 2 files changed, 59 insertions(+), 43 deletions(-)

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index ea93646509..520c3a05e6 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -3113,7 +3113,7 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 	uint64		rowHash = 0;
 
 	/*----------
-	 * Error out if any of the following violated:
+	 * Return false if any of the following violated:
 	 *
 	 *  1. Parent id, modulus, and the remainder should not be null.
 	 * 	2. Parent id must be valid relation id,
@@ -3121,22 +3121,16 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 	 * 	4. Remainder must be a non-negative integer less than the modulus.
 	 *----------
 	 */
-	if (!(PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2)))
-	{
-		parentId = PG_GETARG_OID(0);
-		modulus = PG_GETARG_INT32(1);
-		remainder = PG_GETARG_INT32(2);
-
-		if (!OidIsValid(parentId) || modulus <= 0 || remainder < 0 ||
-			modulus <= remainder)
-			ereport(ERROR,
-					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-					 errmsg("invalid hash partition bound")));
-	}
-	else
-		ereport(ERROR,
-				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("parent relation id, modulus and the remainder cannot be null")));
+	if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
+		PG_RETURN_BOOL(false);
+
+	parentId = PG_GETARG_OID(0);
+	modulus = PG_GETARG_INT32(1);
+	remainder = PG_GETARG_INT32(2);
+
+	if (!OidIsValid(parentId) || modulus <= 0 || remainder < 0 ||
+		modulus <= remainder)
+		PG_RETURN_BOOL(false);
 
 	/*
 	 * Cache hash function information.
@@ -3154,27 +3148,13 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 		key = RelationGetPartitionKey(parent);
 
 		if (parent->rd_rel->relkind != RELKIND_PARTITIONED_TABLE ||
-			key->strategy != PARTITION_STRATEGY_HASH)
+			key->strategy != PARTITION_STRATEGY_HASH ||
+			key->partnatts != nkeys)
 		{
 			heap_close(parent, AccessShareLock);
-			ereport(ERROR,
-					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-					 errmsg("\"%s\" is not a hash partitioned table",
-							get_rel_name(parentId))));
+			PG_RETURN_BOOL(false);
 		}
 
-		/* complain if too few column values; we ignore extras, however */
-		if (key->partnatts > nkeys)
-		{
-			heap_close(parent, AccessShareLock);
-			ereport(ERROR,
-					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-					 errmsg("value missing for partition column %d",
-							(nkeys + 1))));
-		}
-		else
-			nkeys = key->partnatts;
-
 		fcinfo->flinfo->fn_extra =
 			MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
 								   offsetof(ColumnsHashData, partsupfunc) +
diff --git a/src/test/regress/expected/func_sanity.out b/src/test/regress/expected/func_sanity.out
index 0f85e4a1a1..a3cbc33b39 100644
--- a/src/test/regress/expected/func_sanity.out
+++ b/src/test/regress/expected/func_sanity.out
@@ -8,28 +8,64 @@ CREATE TABLE hash_parted(a int, b int) PARTITION BY HASH(a, b);
 CREATE TABLE list_parted(a int, b int) PARTITION BY LIST(a);
 -- Parent relation id, modulus and the remainder should not be null
 SELECT satisfies_hash_partition(NULL, NULL, NULL, NULL, NULL);
-ERROR:  parent relation id, modulus and the remainder cannot be null
+ satisfies_hash_partition 
+--------------------------
+ f
+(1 row)
+
 SELECT satisfies_hash_partition('hash_parted'::regclass, NULL, NULL, NULL, NULL);
-ERROR:  parent relation id, modulus and the remainder cannot be null
+ satisfies_hash_partition 
+--------------------------
+ f
+(1 row)
+
 SELECT satisfies_hash_partition('hash_parted'::regclass, 5, NULL, NULL, NULL);
-ERROR:  parent relation id, modulus and the remainder cannot be null
+ satisfies_hash_partition 
+--------------------------
+ f
+(1 row)
+
 -- Remainder is greater than modulus
 SELECT satisfies_hash_partition('hash_parted'::regclass, 5, 6, NULL, NULL);
-ERROR:  invalid hash partition bound
+ satisfies_hash_partition 
+--------------------------
+ f
+(1 row)
+
 -- Invalid modulus
 SELECT satisfies_hash_partition('hash_parted'::regclass, 0, 0, NULL, NULL);
-ERROR:  invalid hash partition bound
+ satisfies_hash_partition 
+--------------------------
+ f
+(1 row)
+
 -- Invalid parent relation id
 SELECT satisfies_hash_partition(0, 6, 0, NULL, NULL);
-ERROR:  invalid hash partition bound
+ satisfies_hash_partition 
+--------------------------
+ f
+(1 row)
+
 -- Parent is not a hash partitioned table.
 SELECT satisfies_hash_partition('pg_class'::regclass, 7, 6, NULL, NULL);
-ERROR:  "pg_class" is not a hash partitioned table
+ satisfies_hash_partition 
+--------------------------
+ f
+(1 row)
+
 SELECT satisfies_hash_partition('list_parted'::regclass, 6, 2, NULL, NULL);
-ERROR:  "list_parted" is not a hash partitioned table
+ satisfies_hash_partition 
+--------------------------
+ f
+(1 row)
+
 -- Less column values than partition column
 SELECT satisfies_hash_partition('hash_parted'::regclass, 6, 2, NULL);
-ERROR:  value missing for partition column 2
+ satisfies_hash_partition 
+--------------------------
+ f
+(1 row)
+
 -- Clean up.
 DROP TABLE hash_parted;
 DROP TABLE list_parted;
-- 
2.14.1

From ae39ebe24849c4ebac919840b5456abbcd3c8714 Mon Sep 17 00:00:00 2001
From: Robert Haas <rhaas@postgresql.org>
Date: Fri, 17 Nov 2017 11:21:14 -0500
Subject: [PATCH] Fix multiple problems with satisfies_hash_partition.

Fix the function header comment to describe the actual behavior.
Check that table OID, modulus, and remainder arguments are not NULL
before accessing them.  Check that the modulus and remainder are
sensible.  If the table OID doesn't exist, return NULL instead of
emitting an internal error, similar to what we do elsewhere.  Check
that the actual argument types match, or at least are binary coercible
to, the expected argument types.  Correctly handle invocation of this
function using the VARIADIC syntax.  Add regression tests.

Robert Haas and Amul Sul, per a report by Andreas Seltenreich and
subsequent followup investigation.

Discussion: http://postgr.es/m/871sl4sdrv.fsf@ansel.ydns.eu
---
 src/backend/catalog/partition.c         | 202 +++++++++++++++++++++++++++-----
 src/test/regress/expected/hash_part.out | 113 ++++++++++++++++++
 src/test/regress/parallel_schedule      |   2 +-
 src/test/regress/serial_schedule        |   1 +
 src/test/regress/sql/hash_part.sql      |  90 ++++++++++++++
 5 files changed, 377 insertions(+), 31 deletions(-)
 create mode 100644 src/test/regress/expected/hash_part.out
 create mode 100644 src/test/regress/sql/hash_part.sql

diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 67d4c2a09b..1a53eea6f2 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -40,6 +40,7 @@
 #include "optimizer/planmain.h"
 #include "optimizer/prep.h"
 #include "optimizer/var.h"
+#include "parser/parse_coerce.h"
 #include "rewrite/rewriteManip.h"
 #include "storage/lmgr.h"
 #include "utils/array.h"
@@ -3085,9 +3086,11 @@ compute_hash_value(PartitionKey key, Datum *values, bool *isnull)
 /*
  * satisfies_hash_partition
  *
- * This is a SQL-callable function for use in hash partition constraints takes
- * an already computed hash values of each partition key attribute, and combine
- * them into a single hash value by calling hash_combine64.
+ * This is an SQL-callable function for use in hash partition constraints.
+ * The first three arguments are the parent table OID, modulus, and remainder.
+ * The remaining arguments are the value of the partitioning columns (or
+ * expressions); these are hashed and the results are combined into a single
+ * hash value by calling hash_combine64.
  *
  * Returns true if remainder produced when this computed single hash value is
  * divided by the given modulus is equal to given remainder, otherwise false.
@@ -3100,60 +3103,160 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 	typedef struct ColumnsHashData
 	{
 		Oid			relid;
-		int16		nkeys;
+		int			nkeys;
+		Oid			variadic_type;
+		int16		variadic_typlen;
+		bool		variadic_typbyval;
+		char		variadic_typalign;
 		FmgrInfo	partsupfunc[PARTITION_MAX_KEYS];
 	}			ColumnsHashData;
-	Oid			parentId = PG_GETARG_OID(0);
-	int			modulus = PG_GETARG_INT32(1);
-	int			remainder = PG_GETARG_INT32(2);
-	short		nkeys = PG_NARGS() - 3;
-	int			i;
+	Oid			parentId;
+	int			modulus;
+	int			remainder;
 	Datum		seed = UInt64GetDatum(HASH_PARTITION_SEED);
 	ColumnsHashData *my_extra;
 	uint64		rowHash = 0;
 
+	/* Return null if the parent OID, modulus, or remainder is NULL. */
+	if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
+		PG_RETURN_NULL();
+	parentId = PG_GETARG_OID(0);
+	modulus = PG_GETARG_INT32(1);
+	remainder = PG_GETARG_INT32(2);
+
+	/* Sanity check modulus and remainder. */
+	if (modulus <= 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("modulus for hash partition must be a positive integer")));
+	if (remainder < 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("remainder for hash partition must be a non-negative integer")));
+	if (remainder >= modulus)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("remainder for hash partition must be less than modulus")));
+
 	/*
 	 * Cache hash function information.
 	 */
 	my_extra = (ColumnsHashData *) fcinfo->flinfo->fn_extra;
-	if (my_extra == NULL || my_extra->nkeys != nkeys ||
-		my_extra->relid != parentId)
+	if (my_extra == NULL || my_extra->relid != parentId)
 	{
 		Relation	parent;
 		PartitionKey key;
-		int j;
-
-		fcinfo->flinfo->fn_extra =
-			MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
-								   offsetof(ColumnsHashData, partsupfunc) +
-								   sizeof(FmgrInfo) * nkeys);
-		my_extra = (ColumnsHashData *) fcinfo->flinfo->fn_extra;
-		my_extra->nkeys = nkeys;
-		my_extra->relid = parentId;
+		int			j;
 
 		/* Open parent relation and fetch partition keyinfo */
-		parent = heap_open(parentId, AccessShareLock);
+		parent = try_relation_open(parentId, AccessShareLock);
+		if (parent == NULL)
+			PG_RETURN_NULL();
 		key = RelationGetPartitionKey(parent);
 
-		Assert(key->partnatts == nkeys);
-		for (j = 0; j < nkeys; ++j)
-			fmgr_info_copy(&my_extra->partsupfunc[j],
-						   key->partsupfunc,
+		/* Reject parent table that is not hash-partitioned. */
+		if (parent->rd_rel->relkind != RELKIND_PARTITIONED_TABLE ||
+			key->strategy != PARTITION_STRATEGY_HASH)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("\"%s\" is not a hash partitioned table",
+							get_rel_name(parentId))));
+
+		if (!get_fn_expr_variadic(fcinfo->flinfo))
+		{
+			int			nargs = PG_NARGS() - 3;
+
+			/* complain if wrong number of column values */
+			if (key->partnatts != nargs)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("number of partitioning columns (%d) does not match number of partition keys provided (%d)",
+								key->partnatts, nargs)));
+
+			/* allocate space for our cache */
+			fcinfo->flinfo->fn_extra =
+				MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
+									   offsetof(ColumnsHashData, partsupfunc) +
+									   sizeof(FmgrInfo) * nargs);
+			my_extra = (ColumnsHashData *) fcinfo->flinfo->fn_extra;
+			my_extra->relid = parentId;
+			my_extra->nkeys = key->partnatts;
+
+			/* check argument types and save fmgr_infos */
+			for (j = 0; j < key->partnatts; ++j)
+			{
+				Oid			argtype = get_fn_expr_argtype(fcinfo->flinfo, j + 3);
+
+				if (argtype != key->parttypid[j] && !IsBinaryCoercible(argtype, key->parttypid[j]))
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("column %d of the partition key has type \"%s\", but supplied value is of type \"%s\"",
+									j, format_type_be(key->parttypid[j]), format_type_be(argtype))));
+
+				fmgr_info_copy(&my_extra->partsupfunc[j],
+							   &key->partsupfunc[j],
+							   fcinfo->flinfo->fn_mcxt);
+			}
+
+		}
+		else
+		{
+			ArrayType  *variadic_array = PG_GETARG_ARRAYTYPE_P(3);
+
+			/* allocate space for our cache -- just one FmgrInfo in this case */
+			fcinfo->flinfo->fn_extra =
+				MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
+									   offsetof(ColumnsHashData, partsupfunc) +
+									   sizeof(FmgrInfo));
+			my_extra = (ColumnsHashData *) fcinfo->flinfo->fn_extra;
+			my_extra->relid = parentId;
+			my_extra->nkeys = key->partnatts;
+			my_extra->variadic_type = ARR_ELEMTYPE(variadic_array);
+			get_typlenbyvalalign(my_extra->variadic_type,
+								 &my_extra->variadic_typlen,
+								 &my_extra->variadic_typbyval,
+								 &my_extra->variadic_typalign);
+
+			/* check argument types */
+			for (j = 0; j < key->partnatts; ++j)
+				if (key->parttypid[j] != my_extra->variadic_type)
+					ereport(ERROR,
+							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+							 errmsg("column %d of the partition key has type \"%s\", but supplied value is of type \"%s\"",
+									j,
+									format_type_be(key->parttypid[j]),
+									format_type_be(my_extra->variadic_type))));
+
+			fmgr_info_copy(&my_extra->partsupfunc[0],
+						   &key->partsupfunc[0],
 						   fcinfo->flinfo->fn_mcxt);
+		}
 
 		/* Hold lock until commit */
-		heap_close(parent, NoLock);
+		relation_close(parent, NoLock);
 	}
 
-	for (i = 0; i < nkeys; i++)
+	if (!OidIsValid(my_extra->variadic_type))
 	{
-		/* keys start from fourth argument of function. */
-		int			argno = i + 3;
+		int			nkeys = my_extra->nkeys;
+		int			i;
+
+		/*
+		 * For a non-variadic call, neither the number of arguments nor their
+		 * types can change across calls, so avoid the expense of rechecking
+		 * here.
+		 */
 
-		if (!PG_ARGISNULL(argno))
+		for (i = 0; i < nkeys; i++)
 		{
 			Datum		hash;
 
+			/* keys start from fourth argument of function. */
+			int			argno = i + 3;
+
+			if (PG_ARGISNULL(argno))
+				continue;
+
 			Assert(OidIsValid(my_extra->partsupfunc[i].fn_oid));
 
 			hash = FunctionCall2(&my_extra->partsupfunc[i],
@@ -3164,6 +3267,45 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
 			rowHash = hash_combine64(rowHash, DatumGetUInt64(hash));
 		}
 	}
+	else
+	{
+		ArrayType  *variadic_array = PG_GETARG_ARRAYTYPE_P(3);
+		int			i;
+		int			nelems;
+		Datum	   *datum;
+		bool	   *isnull;
+
+		deconstruct_array(variadic_array,
+						  my_extra->variadic_type,
+						  my_extra->variadic_typlen,
+						  my_extra->variadic_typbyval,
+						  my_extra->variadic_typalign,
+						  &datum, &isnull, &nelems);
+
+		/* complain if wrong number of column values */
+		if (nelems != my_extra->nkeys)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("number of partitioning columns (%d) does not match number of partition keys provided (%d)",
+							my_extra->nkeys, nelems)));
+
+		for (i = 0; i < nelems; i++)
+		{
+			Datum		hash;
+
+			if (isnull[i])
+				continue;
+
+			Assert(OidIsValid(my_extra->partsupfunc[0].fn_oid));
+
+			hash = FunctionCall2(&my_extra->partsupfunc[0],
+								 datum[i],
+								 seed);
+
+			/* Form a single 64-bit hash value */
+			rowHash = hash_combine64(rowHash, DatumGetUInt64(hash));
+		}
+	}
 
 	PG_RETURN_BOOL(rowHash % modulus == remainder);
 }
diff --git a/src/test/regress/expected/hash_part.out b/src/test/regress/expected/hash_part.out
new file mode 100644
index 0000000000..fc2919bcd3
--- /dev/null
+++ b/src/test/regress/expected/hash_part.out
@@ -0,0 +1,113 @@
+--
+-- Hash partitioning.
+--
+CREATE OR REPLACE FUNCTION hashint4_noop(int4, int8) RETURNS int8 AS
+$$SELECT coalesce($1,0)::int8$$ LANGUAGE sql IMMUTABLE;
+CREATE OPERATOR CLASS test_int4_ops FOR TYPE int4 USING HASH AS
+OPERATOR 1 = , FUNCTION 2 hashint4_noop(int4, int8);
+CREATE OR REPLACE FUNCTION hashtext_length(text, int8) RETURNS int8 AS
+$$SELECT length(coalesce($1,''))::int8$$ LANGUAGE sql IMMUTABLE;
+CREATE OPERATOR CLASS test_text_ops FOR TYPE text USING HASH AS
+OPERATOR 1 = , FUNCTION 2 hashtext_length(text, int8);
+CREATE TABLE mchash (a int, b text, c jsonb)
+  PARTITION BY HASH (a test_int4_ops, b test_text_ops);
+CREATE TABLE mchash1
+  PARTITION OF mchash FOR VALUES WITH (MODULUS 4, REMAINDER 0);
+-- invalid OID, no such table
+SELECT satisfies_hash_partition(0, 4, 0, NULL);
+ satisfies_hash_partition 
+--------------------------
+ 
+(1 row)
+
+-- not partitioned
+SELECT satisfies_hash_partition('tenk1'::regclass, 4, 0, NULL);
+ERROR:  "tenk1" is not a hash partitioned table
+-- partition rather than the parent
+SELECT satisfies_hash_partition('mchash1'::regclass, 4, 0, NULL);
+ERROR:  "mchash1" is not a hash partitioned table
+-- invalid modulus
+SELECT satisfies_hash_partition('mchash'::regclass, 0, 0, NULL);
+ERROR:  modulus for hash partition must be a positive integer
+-- remainder too small
+SELECT satisfies_hash_partition('mchash'::regclass, 1, -1, NULL);
+ERROR:  remainder for hash partition must be a non-negative integer
+-- remainder too large
+SELECT satisfies_hash_partition('mchash'::regclass, 1, 1, NULL);
+ERROR:  remainder for hash partition must be less than modulus
+-- modulus is null
+SELECT satisfies_hash_partition('mchash'::regclass, NULL, 0, NULL);
+ satisfies_hash_partition 
+--------------------------
+ 
+(1 row)
+
+-- remainder is null
+SELECT satisfies_hash_partition('mchash'::regclass, 4, NULL, NULL);
+ satisfies_hash_partition 
+--------------------------
+ 
+(1 row)
+
+-- too many arguments
+SELECT satisfies_hash_partition('mchash'::regclass, 4, 0, NULL::int, NULL::text, NULL::json);
+ERROR:  number of partitioning columns (2) does not match number of partition keys provided (3)
+-- too few arguments
+SELECT satisfies_hash_partition('mchash'::regclass, 3, 1, NULL::int);
+ERROR:  number of partitioning columns (2) does not match number of partition keys provided (1)
+-- wrong argument type
+SELECT satisfies_hash_partition('mchash'::regclass, 2, 1, NULL::int, NULL::int);
+ERROR:  column 1 of the partition key has type "text", but supplied value is of type "integer"
+-- ok, should be false
+SELECT satisfies_hash_partition('mchash'::regclass, 4, 0, 0, ''::text);
+ satisfies_hash_partition 
+--------------------------
+ f
+(1 row)
+
+-- ok, should be true
+SELECT satisfies_hash_partition('mchash'::regclass, 4, 0, 1, ''::text);
+ satisfies_hash_partition 
+--------------------------
+ t
+(1 row)
+
+-- argument via variadic syntax, should fail because not all partitioning
+-- columns are of the correct type
+SELECT satisfies_hash_partition('mchash'::regclass, 2, 1,
+								variadic array[1,2]::int[]);
+ERROR:  column 1 of the partition key has type "text", but supplied value is of type "integer"
+-- multiple partitioning columns of the same type
+CREATE TABLE mcinthash (a int, b int, c jsonb)
+  PARTITION BY HASH (a test_int4_ops, b test_int4_ops);
+-- now variadic should work, should be false
+SELECT satisfies_hash_partition('mcinthash'::regclass, 4, 0,
+								variadic array[0, 0]);
+ satisfies_hash_partition 
+--------------------------
+ f
+(1 row)
+
+-- should be true
+SELECT satisfies_hash_partition('mcinthash'::regclass, 4, 0,
+								variadic array[1, 0]);
+ satisfies_hash_partition 
+--------------------------
+ t
+(1 row)
+
+-- wrong length
+SELECT satisfies_hash_partition('mcinthash'::regclass, 4, 0,
+								variadic array[]::int[]);
+ERROR:  number of partitioning columns (2) does not match number of partition keys provided (0)
+-- wrong type
+SELECT satisfies_hash_partition('mcinthash'::regclass, 4, 0,
+								variadic array[now(), now()]);
+ERROR:  column 0 of the partition key has type "integer", but supplied value is of type "timestamp with time zone"
+-- cleanup
+DROP TABLE mchash;
+DROP TABLE mcinthash;
+DROP OPERATOR CLASS test_text_ops USING hash;
+DROP OPERATOR CLASS test_int4_ops USING hash;
+DROP FUNCTION hashint4_noop(int4, int8);
+DROP FUNCTION hashtext_length(text, int8);
diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule
index aa5e6af621..1a3ac4c1f9 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -116,7 +116,7 @@ test: plancache limit plpgsql copy2 temp domain rangefuncs prepare without_oid c
 # ----------
 # Another group of parallel tests
 # ----------
-test: identity partition_join reloptions
+test: identity partition_join reloptions hash_part
 
 # event triggers cannot run concurrently with any test that runs DDL
 test: event_trigger
diff --git a/src/test/regress/serial_schedule b/src/test/regress/serial_schedule
index 3866314a92..a205e5d05c 100644
--- a/src/test/regress/serial_schedule
+++ b/src/test/regress/serial_schedule
@@ -181,5 +181,6 @@ test: xml
 test: identity
 test: partition_join
 test: reloptions
+test: hash_part
 test: event_trigger
 test: stats
diff --git a/src/test/regress/sql/hash_part.sql b/src/test/regress/sql/hash_part.sql
new file mode 100644
index 0000000000..94c5eaab0c
--- /dev/null
+++ b/src/test/regress/sql/hash_part.sql
@@ -0,0 +1,90 @@
+--
+-- Hash partitioning.
+--
+
+CREATE OR REPLACE FUNCTION hashint4_noop(int4, int8) RETURNS int8 AS
+$$SELECT coalesce($1,0)::int8$$ LANGUAGE sql IMMUTABLE;
+CREATE OPERATOR CLASS test_int4_ops FOR TYPE int4 USING HASH AS
+OPERATOR 1 = , FUNCTION 2 hashint4_noop(int4, int8);
+
+CREATE OR REPLACE FUNCTION hashtext_length(text, int8) RETURNS int8 AS
+$$SELECT length(coalesce($1,''))::int8$$ LANGUAGE sql IMMUTABLE;
+CREATE OPERATOR CLASS test_text_ops FOR TYPE text USING HASH AS
+OPERATOR 1 = , FUNCTION 2 hashtext_length(text, int8);
+
+CREATE TABLE mchash (a int, b text, c jsonb)
+  PARTITION BY HASH (a test_int4_ops, b test_text_ops);
+CREATE TABLE mchash1
+  PARTITION OF mchash FOR VALUES WITH (MODULUS 4, REMAINDER 0);
+
+-- invalid OID, no such table
+SELECT satisfies_hash_partition(0, 4, 0, NULL);
+
+-- not partitioned
+SELECT satisfies_hash_partition('tenk1'::regclass, 4, 0, NULL);
+
+-- partition rather than the parent
+SELECT satisfies_hash_partition('mchash1'::regclass, 4, 0, NULL);
+
+-- invalid modulus
+SELECT satisfies_hash_partition('mchash'::regclass, 0, 0, NULL);
+
+-- remainder too small
+SELECT satisfies_hash_partition('mchash'::regclass, 1, -1, NULL);
+
+-- remainder too large
+SELECT satisfies_hash_partition('mchash'::regclass, 1, 1, NULL);
+
+-- modulus is null
+SELECT satisfies_hash_partition('mchash'::regclass, NULL, 0, NULL);
+
+-- remainder is null
+SELECT satisfies_hash_partition('mchash'::regclass, 4, NULL, NULL);
+
+-- too many arguments
+SELECT satisfies_hash_partition('mchash'::regclass, 4, 0, NULL::int, NULL::text, NULL::json);
+
+-- too few arguments
+SELECT satisfies_hash_partition('mchash'::regclass, 3, 1, NULL::int);
+
+-- wrong argument type
+SELECT satisfies_hash_partition('mchash'::regclass, 2, 1, NULL::int, NULL::int);
+
+-- ok, should be false
+SELECT satisfies_hash_partition('mchash'::regclass, 4, 0, 0, ''::text);
+
+-- ok, should be true
+SELECT satisfies_hash_partition('mchash'::regclass, 4, 0, 1, ''::text);
+
+-- argument via variadic syntax, should fail because not all partitioning
+-- columns are of the correct type
+SELECT satisfies_hash_partition('mchash'::regclass, 2, 1,
+								variadic array[1,2]::int[]);
+
+-- multiple partitioning columns of the same type
+CREATE TABLE mcinthash (a int, b int, c jsonb)
+  PARTITION BY HASH (a test_int4_ops, b test_int4_ops);
+
+-- now variadic should work, should be false
+SELECT satisfies_hash_partition('mcinthash'::regclass, 4, 0,
+								variadic array[0, 0]);
+
+-- should be true
+SELECT satisfies_hash_partition('mcinthash'::regclass, 4, 0,
+								variadic array[1, 0]);
+
+-- wrong length
+SELECT satisfies_hash_partition('mcinthash'::regclass, 4, 0,
+								variadic array[]::int[]);
+
+-- wrong type
+SELECT satisfies_hash_partition('mcinthash'::regclass, 4, 0,
+								variadic array[now(), now()]);
+
+-- cleanup
+DROP TABLE mchash;
+DROP TABLE mcinthash;
+DROP OPERATOR CLASS test_text_ops USING hash;
+DROP OPERATOR CLASS test_int4_ops USING hash;
+DROP FUNCTION hashint4_noop(int4, int8);
+DROP FUNCTION hashtext_length(text, int8);
-- 
2.13.5 (Apple Git-94)