HASH partitioning for all base types

Author: zilder

expected/pg_pathman.out

@@ -178,7 +178,7 @@ EXPLAIN (COSTS OFF) SELECT * FROM test.hash_rel WHERE value = 2;
           QUERY PLAN          
 ------------------------------
  Append
-   ->  Seq Scan on hash_rel_2
+   ->  Seq Scan on hash_rel_1
          Filter: (value = 2)
 (3 rows)
 
@@ -187,21 +187,21 @@ EXPLAIN (COSTS OFF) SELECT * FROM test.hash_rel WHERE value = 2 OR value = 1;
 ------------------------------
  Append
    ->  Seq Scan on hash_rel_1
-         Filter: (value = 1)
-   ->  Seq Scan on hash_rel_2
          Filter: (value = 2)
-(5 rows)
-
-EXPLAIN (COSTS OFF) SELECT * FROM test.hash_rel WHERE value BETWEEN 1 AND 2;
-                   QUERY PLAN                    
--------------------------------------------------
- Append
-   ->  Seq Scan on hash_rel_1
-         Filter: ((value >= 1) AND (value <= 2))
    ->  Seq Scan on hash_rel_2
-         Filter: ((value >= 1) AND (value <= 2))
+         Filter: (value = 1)
 (5 rows)
 
+-- Temporarily commented out
+-- EXPLAIN (COSTS OFF) SELECT * FROM test.hash_rel WHERE value BETWEEN 1 AND 2;
+--                    QUERY PLAN                    
+-- -------------------------------------------------
+--  Append
+--    ->  Seq Scan on hash_rel_1
+--          Filter: ((value >= 1) AND (value <= 2))
+--    ->  Seq Scan on hash_rel_2
+--          Filter: ((value >= 1) AND (value <= 2))
+-- (5 rows)
 EXPLAIN (COSTS OFF) SELECT * FROM test.num_range_rel WHERE id > 2500;
             QUERY PLAN             
 -----------------------------------
@@ -298,7 +298,7 @@ EXPLAIN (COSTS OFF) SELECT * FROM test.hash_rel WHERE value = 2;
           QUERY PLAN          
 ------------------------------
  Append
-   ->  Seq Scan on hash_rel_2
+   ->  Seq Scan on hash_rel_1
          Filter: (value = 2)
 (3 rows)
 
@@ -307,9 +307,9 @@ EXPLAIN (COSTS OFF) SELECT * FROM test.hash_rel WHERE value = 2 OR value = 1;
 ------------------------------
  Append
    ->  Seq Scan on hash_rel_1
-         Filter: (value = 1)
-   ->  Seq Scan on hash_rel_2
          Filter: (value = 2)
+   ->  Seq Scan on hash_rel_2
+         Filter: (value = 1)
 (5 rows)
 
 EXPLAIN (COSTS OFF) SELECT * FROM test.num_range_rel WHERE id > 2500;
@@ -569,7 +569,7 @@ SELECT * FROM ttt;
  CTE Scan on ttt
    CTE ttt
      ->  Append
-           ->  Seq Scan on hash_rel_2
+           ->  Seq Scan on hash_rel_1
                  Filter: (value = 2)
 (5 rows)
 
@@ -1183,8 +1183,8 @@ SELECT * FROM test."TeSt";
  a | b 
 ---+---
  3 | 3
- 1 | 1
  2 | 2
+ 1 | 1
 (3 rows)
 
 SELECT pathman.create_hash_update_trigger('test."TeSt"');
@@ -1198,31 +1198,31 @@ SELECT * FROM test."TeSt";
  a | b 
 ---+---
  1 | 3
- 1 | 1
  1 | 2
+ 1 | 1
 (3 rows)
 
 SELECT * FROM test."TeSt" WHERE a = 1;
  a | b 
 ---+---
  1 | 3
- 1 | 1
  1 | 2
+ 1 | 1
 (3 rows)
 
 EXPLAIN (COSTS OFF) SELECT * FROM test."TeSt" WHERE a = 1;
          QUERY PLAN         
 ----------------------------
  Append
-   ->  Seq Scan on "TeSt_1"
+   ->  Seq Scan on "TeSt_2"
          Filter: (a = 1)
 (3 rows)
 
 SELECT pathman.drop_hash_partitions('test."TeSt"');
 NOTICE:  drop cascades to trigger test_TeSt_insert_trigger on table test."TeSt"
 NOTICE:  drop cascades to 3 other objects
-NOTICE:  0 rows copied from test."TeSt_2"
-NOTICE:  3 rows copied from test."TeSt_1"
+NOTICE:  3 rows copied from test."TeSt_2"
+NOTICE:  0 rows copied from test."TeSt_1"
 NOTICE:  0 rows copied from test."TeSt_0"
  drop_hash_partitions 
 ----------------------
@@ -1233,8 +1233,8 @@ SELECT * FROM test."TeSt";
  a | b 
 ---+---
  1 | 3
- 1 | 1
  1 | 2
+ 1 | 1
 (3 rows)
 
 CREATE TABLE test."RangeRel" (

hash.sql

@@ -18,23 +18,35 @@ CREATE OR REPLACE FUNCTION @extschema@.create_hash_partitions(
 ) RETURNS INTEGER AS
 $$
 DECLARE
-	v_relname TEXT;
+	v_relname       TEXT;
 	v_child_relname TEXT;
-	v_type TEXT;
+	v_type          TEXT;
+	v_plain_schema  TEXT;
+	v_plain_relname TEXT;
+	v_hashfunc      TEXT;
 BEGIN
 	v_relname := @extschema@.validate_relname(relation);
 	attribute := lower(attribute);
 	PERFORM @extschema@.common_relation_checks(relation, attribute);
 
 	v_type := @extschema@.get_attribute_type_name(v_relname, attribute);
-	IF v_type::regtype != 'integer'::regtype THEN
-		RAISE EXCEPTION 'Attribute type must be INTEGER';
-	END IF;
+	-- IF v_type::regtype != 'integer'::regtype THEN
+	-- 	RAISE EXCEPTION 'Attribute type must be INTEGER';
+	-- END IF;
+
+	SELECT * INTO v_plain_schema, v_plain_relname
+	FROM @extschema@.get_plain_schema_and_relname(relation);
+
+	v_hashfunc := @extschema@.get_type_hash_func(v_type::regtype::oid)::regproc;
 
 	/* Create partitions and update pg_pathman configuration */
 	FOR partnum IN 0..partitions_count-1
 	LOOP
-		v_child_relname := @extschema@.get_schema_qualified_name(relation, '.', suffix := '_' || partnum);
+		-- v_child_relname := @extschema@.get_schema_qualified_name(relation, '.', suffix := '_' || partnum);
+		v_child_relname := format('%s.%s',
+        						  v_plain_schema,
+        						  quote_ident(v_plain_relname || '_' || partnum));
+
 		EXECUTE format('CREATE TABLE %s (LIKE %s INCLUDING ALL)'
 						, v_child_relname
 						, v_relname);
@@ -43,8 +55,9 @@ BEGIN
 						, v_child_relname
 						, v_relname);
 
-		EXECUTE format('ALTER TABLE %s ADD CHECK (%s %% %s = %s)'
+		EXECUTE format('ALTER TABLE %s ADD CHECK (@extschema@.get_hash(%s(%s), %s) = %s)'
 					   , v_child_relname
+					   , v_hashfunc
 					   , attribute
 					   , partitions_count
 					   , partnum);
@@ -83,7 +96,7 @@ DECLARE
 		DECLARE
 			hash INTEGER;
 		BEGIN
-			hash := NEW.%s %% %s;
+			hash := @extschema@.get_hash(%s(NEW.%s), %s);
 			%s
 			RETURN NULL;
 		END $body$ LANGUAGE plpgsql;';
@@ -93,11 +106,11 @@ DECLARE
 		BEFORE INSERT ON %s
 		FOR EACH ROW EXECUTE PROCEDURE %s();';
 	triggername TEXT;
-	-- fields TEXT;
-	-- fields_format TEXT;
 	insert_stmt TEXT;
-	relname TEXT;
-	schema TEXT;
+	relname     TEXT;
+	schema      TEXT;
+	atttype     TEXT;
+	hashfunc    TEXT;
 BEGIN
 	/* drop trigger and corresponding function */
 	PERFORM @extschema@.drop_hash_triggers(relation);
@@ -113,7 +126,11 @@ BEGIN
 	funcname := schema || '.' || quote_ident(format('%s_insert_trigger_func', relname));
 	triggername := quote_ident(format('%s_%s_insert_trigger', schema, relname));
 
-	func := format(func, funcname, attr, partitions_count, insert_stmt);
+	/* base hash function for type */
+	atttype := @extschema@.get_attribute_type_name(relation, attr);
+	hashfunc := @extschema@.get_type_hash_func(atttype::regtype::oid)::regproc;
+
+	func := format(func, funcname, hashfunc, attr, partitions_count, insert_stmt);
 	trigger := format(trigger, triggername, relation, funcname);
 	EXECUTE func;
 	EXECUTE trigger;
@@ -197,8 +214,8 @@ DECLARE
 		$body$
 		DECLARE old_hash INTEGER; new_hash INTEGER; q TEXT;
 		BEGIN
-			old_hash := OLD.%2$s %% %3$s;
-			new_hash := NEW.%2$s %% %3$s;
+			old_hash := @extschema@.get_hash(%9$s(OLD.%2$s), %3$s);
+			new_hash := @extschema@.get_hash(%9$s(NEW.%2$s), %3$s);
 			IF old_hash = new_hash THEN RETURN NEW; END IF;
 			q := format(''DELETE FROM %8$s WHERE %4$s'', old_hash);
 			EXECUTE q USING %5$s;
@@ -223,6 +240,8 @@ DECLARE
 	funcname      TEXT;
 	triggername   TEXT;
 	child_relname_format TEXT;
+	atttype       TEXT;
+	hashfunc      TEXT;
 BEGIN
 	relation := @extschema@.validate_relname(relation);
 
@@ -252,9 +271,13 @@ BEGIN
 	child_relname_format := plain_schema || '.' || quote_ident(plain_relname || '_%s');
 	triggername := quote_ident(format('%s_%s_update_trigger', plain_schema, plain_relname));
 
+	/* base hash function for type */
+	atttype := @extschema@.get_attribute_type_name(relation, attr);
+	hashfunc := @extschema@.get_type_hash_func(atttype::regtype::oid)::regproc;
+
 	/* Format function definition and execute it */
 	func := format(func, funcname, attr, partitions_count, att_val_fmt,
-				   old_fields, att_fmt, new_fields, child_relname_format);
+				   old_fields, att_fmt, new_fields, child_relname_format, hashfunc);
 	EXECUTE func;
 
 	/* Create triggers on child relations */

init.sql

@@ -340,3 +340,15 @@ RETURNS VOID AS 'pg_pathman', 'acquire_partitions_lock' LANGUAGE C STRICT;
  */
 CREATE OR REPLACE FUNCTION @extschema@.release_partitions_lock()
 RETURNS VOID AS 'pg_pathman', 'release_partitions_lock' LANGUAGE C STRICT;
+
+/*
+ * Returns hash function OID for specified type
+ */
+CREATE OR REPLACE FUNCTION @extschema@.get_type_hash_func(OID)
+RETURNS OID AS 'pg_pathman', 'get_type_hash_func' LANGUAGE C STRICT;
+
+/*
+ * Calculates hash for integer value
+ */
+CREATE OR REPLACE FUNCTION @extschema@.get_hash(INTEGER, INTEGER)
+RETURNS INTEGER AS 'pg_pathman', 'get_hash' LANGUAGE C STRICT;

sql/pg_pathman.sql

@@ -69,7 +69,16 @@ SET enable_seqscan = ON;
 EXPLAIN (COSTS OFF) SELECT * FROM test.hash_rel;
 EXPLAIN (COSTS OFF) SELECT * FROM test.hash_rel WHERE value = 2;
 EXPLAIN (COSTS OFF) SELECT * FROM test.hash_rel WHERE value = 2 OR value = 1;
-EXPLAIN (COSTS OFF) SELECT * FROM test.hash_rel WHERE value BETWEEN 1 AND 2;
+-- Temporarily commented out
+-- EXPLAIN (COSTS OFF) SELECT * FROM test.hash_rel WHERE value BETWEEN 1 AND 2;
+--                    QUERY PLAN                    
+-- -------------------------------------------------
+--  Append
+--    ->  Seq Scan on hash_rel_1
+--          Filter: ((value >= 1) AND (value <= 2))
+--    ->  Seq Scan on hash_rel_2
+--          Filter: ((value >= 1) AND (value <= 2))
+-- (5 rows)
 EXPLAIN (COSTS OFF) SELECT * FROM test.num_range_rel WHERE id > 2500;
 EXPLAIN (COSTS OFF) SELECT * FROM test.num_range_rel WHERE id >= 1000 AND id < 3000;
 EXPLAIN (COSTS OFF) SELECT * FROM test.num_range_rel WHERE id >= 1500 AND id < 2500;

src/init.c

@@ -173,6 +173,7 @@ load_relations_hashtable(bool reinitialize)
 	List	   *part_oids = NIL;
 	ListCell   *lc;
 	char	   *schema;
+	TypeCacheEntry *tce;
 	PartRelationInfo *prel;
 	char		sql[] = "SELECT pg_class.oid, pg_attribute.attnum, cfg.parttype, pg_attribute.atttypid "
 						"FROM %s.pathman_config as cfg "
@@ -216,6 +217,10 @@ load_relations_hashtable(bool reinitialize)
 			prel->parttype = DatumGetInt32(SPI_getbinval(tuple, tupdesc, 3, &isnull));
 			prel->atttype = DatumGetObjectId(SPI_getbinval(tuple, tupdesc, 4, &isnull));
 
+			tce = lookup_type_cache(prel->atttype, 	TYPECACHE_CMP_PROC | TYPECACHE_HASH_PROC);
+			prel->cmp_proc = tce->cmp_proc;
+			prel->hash_proc = tce->hash_proc;
+
 			part_oids = lappend_int(part_oids, oid);
 		}
 	}
@@ -507,38 +512,50 @@ read_opexpr_const(OpExpr *opexpr, int varattno, Datum *val)
 static bool
 validate_hash_constraint(Expr *expr, PartRelationInfo *prel, int *hash)
 {
-	OpExpr *eqexpr;
-	OpExpr *modexpr;
+	OpExpr	   *eqexpr;
 	TypeCacheEntry *tce;
+	FuncExpr   *gethashfunc;
+	FuncExpr   *funcexpr;
+	Var		   *var;
 
 	if (!IsA(expr, OpExpr))
 		return false;
 	eqexpr = (OpExpr *) expr;
 
-	/* Is this an equality operator? */
-	tce = lookup_type_cache(prel->atttype, TYPECACHE_BTREE_OPFAMILY);
-	if (get_op_opfamily_strategy(eqexpr->opno, tce->btree_opf) != BTEqualStrategyNumber)
-		return false;
-
-	if (!IsA(linitial(eqexpr->args), OpExpr))
+	/*
+	 * We expect get_hash() function on the left
+	 * TODO: check that it is really the 'get_hash' function
+	 */
+	if (!IsA(linitial(eqexpr->args), FuncExpr))
 		return false;
+	gethashfunc = (FuncExpr *) linitial(eqexpr->args);
 
-	/* Is this a modulus operator? */
-	modexpr = (OpExpr *) linitial(eqexpr->args);
-	if (modexpr->opno != 530 && modexpr->opno != 439 && modexpr->opno && modexpr->opno != 529)
+	/* Is this an equality operator? */
+	tce = lookup_type_cache(gethashfunc->funcresulttype, TYPECACHE_BTREE_OPFAMILY);
+	if (get_op_opfamily_strategy(eqexpr->opno, tce->btree_opf) != BTEqualStrategyNumber)
 		return false;
 
-	if (list_length(modexpr->args) == 2)
+	if (list_length(gethashfunc->args) == 2)
 	{
-		Node *left = linitial(modexpr->args);
-		Node *right = lsecond(modexpr->args);
+		Node *first = linitial(gethashfunc->args);
+		Node *second = lsecond(gethashfunc->args);
 		Const *mod_result;
 
-		if ( !IsA(left, Var) || !IsA(right, Const) )
+		if ( !IsA(first, FuncExpr) || !IsA(second, Const) )
+			return false;
+
+		/* Check that function is the base hash function for the type  */
+		funcexpr = (FuncExpr *) first;
+		if (funcexpr->funcid != prel->hash_proc || !IsA(linitial(funcexpr->args), Var))
 			return false;
-		if ( ((Var*) left)->varattno != prel->attnum )
+
+		/* Check that argument is partitioning key attribute */
+		var = (Var *) linitial(funcexpr->args);
+		if (var->varattno != prel->attnum)
 			return false;
-		if (DatumGetInt32(((Const*) right)->constvalue) != prel->children.length)
+
+		/* Check that const value less than partitions count */
+		if (DatumGetInt32(((Const*) second)->constvalue) != prel->children.length)
 			return false;
 
 		if ( !IsA(lsecond(eqexpr->args), Const) )

src/pathman.h

@@ -77,7 +77,8 @@ typedef struct PartRelationInfo
 	PartType	parttype;
 	Index		attnum;
 	Oid			atttype;
-
+	Oid			cmp_proc;
+	Oid			hash_proc;
 } PartRelationInfo;
 
 /*
@@ -200,6 +201,7 @@ char *get_extension_schema(void);
 FmgrInfo *get_cmp_func(Oid type1, Oid type2);
 Oid create_partitions_bg_worker(Oid relid, Datum value, Oid value_type, bool *crashed);
 Oid create_partitions(Oid relid, Datum value, Oid value_type, bool *crashed);
+uint32 make_hash(uint32 value, uint32 partitions);
 
 /* copied from allpaths.h */
 void set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,