Add more checks and fixes for subpartitions

Author: ildus

init.sql

@@ -862,6 +862,36 @@ CREATE OR REPLACE FUNCTION @extschema@.invoke_on_partition_created_callback(
 RETURNS VOID AS 'pg_pathman', 'invoke_on_partition_created_callback'
 LANGUAGE C;
 
+/*
+ * Get parent of pg_pathman's partition.
+ */
+CREATE OR REPLACE FUNCTION @extschema@.is_equal_to_partitioning_expression(
+	parent_relid		REGCLASS,
+	expression			TEXT,
+	value_type			OID)
+RETURNS BOOL AS 'pg_pathman', 'is_equal_to_partitioning_expression_pl'
+LANGUAGE C STRICT;
+
+/*
+ * Get lower bound of a partitioned relation
+ * bound_value is used to determine the type of bound
+ */
+CREATE OR REPLACE FUNCTION @extschema@.get_lower_bound(
+	relid				REGCLASS,
+	bound_value			ANYELEMENT
+)
+RETURNS ANYELEMENT AS 'pg_pathman', 'get_lower_bound_pl'
+LANGUAGE C STRICT;
+
+/*
+ * Get upper bound of a partition
+ */
+CREATE OR REPLACE FUNCTION @extschema@.get_upper_bound(
+	relid				REGCLASS,
+	bound_value			ANYELEMENT
+)
+RETURNS ANYELEMENT AS 'pg_pathman', 'get_upper_bound_pl'
+LANGUAGE C STRICT;
 
 /*
  * DEBUG: Place this inside some plpgsql fuction and set breakpoint.

range.sql

@@ -158,24 +158,47 @@ CREATE OR REPLACE FUNCTION @extschema@.create_range_partitions(
 	partition_data	BOOLEAN DEFAULT TRUE)
 RETURNS INTEGER AS $$
 DECLARE
+	relid			REGCLASS;
 	rows_count		BIGINT;
 	max_value		start_value%TYPE;
 	cur_value		start_value%TYPE := start_value;
 	end_value		start_value%TYPE;
+	lower_bound		start_value%TYPE = NULL;
+	upper_bound		start_value%TYPE = NULL;
 	part_count		INTEGER := 0;
 	i				INTEGER;
-
+	part_type		INT4;
 BEGIN
 	PERFORM @extschema@.prepare_for_partitioning(parent_relid,
 												 expression,
 												 partition_data);
 
+	/*
+	 * Check that we're trying to make subpartitions.
+	 * If expressions are same then we set and use upper bound.
+	 * We change start_value if it's greater than lower bound.
+	 */
+	relid := @extschema@.get_parent_of_partition(parent_relid, false);
+	IF relid IS NOT NULL THEN
+		part_type := get_partition_type(relid);
+		IF (part_type = 2) AND @extschema@.is_equal_to_partitioning_expression(
+				relid, expression, pg_typeof(start_value))
+		THEN
+			lower_bound := @extschema@.get_lower_bound(parent_relid, start_value);
+			upper_bound	:= @extschema@.get_upper_bound(parent_relid, start_value);
+			IF lower_bound != start_value THEN
+				start_value := lower_bound;
+				RAISE NOTICE '"start_value" was set to %', start_value;
+			END IF;
+		END IF;
+	END IF;
+
 	IF p_count < 0 THEN
 		RAISE EXCEPTION 'partitions count must not be less than zero';
 	END IF;
 
 	/* Try to determine partitions count if not set */
-	IF p_count IS NULL THEN
+	IF p_count IS NULL OR (relid IS NOT NULL AND p_count = 0) THEN
 		EXECUTE format('SELECT count(*), max(%s) FROM %s', expression, parent_relid)
 		INTO rows_count, max_value;
 
@@ -189,6 +212,7 @@ BEGIN
 
 		p_count := 0;
 		WHILE cur_value <= max_value
+			OR (upper_bound IS NOT NULL AND cur_value < upper_bound)
 		LOOP
 			cur_value := cur_value + p_interval;
 			p_count := p_count + 1;
@@ -205,6 +229,20 @@ BEGIN
 		FOR i IN 1..p_count
 		LOOP
 			end_value := end_value + p_interval;
+			IF upper_bound IS NOT NULL AND end_value >= upper_bound THEN
+				part_count := i;
+				IF end_value > upper_bound THEN
+					RAISE WARNING '"p_interval" is not multiple of range (%, %)',
+						start_value, end_value;
+				END IF;
+				IF p_count != part_count THEN
+					p_count := part_count;
+					RAISE NOTICE '"p_count" was set %', p_count;
+				END IF;
+
+				/* we got our partitions count */
+				EXIT;
+			END IF;
 		END LOOP;
 
 		/* check boundaries */
@@ -460,6 +498,26 @@ BEGIN
 END
 $$ LANGUAGE plpgsql;
 
+
+/*
+ * NOTE: we need this function just to determine the type
+ * of "upper_bound" var
+ */
+CREATE OR REPLACE FUNCTION @extschema@.check_against_upper_bound_internal(
+	relid			REGCLASS,
+	bound_value		ANYELEMENT,
+	error_message	TEXT)
+RETURNS VOID AS $$
+DECLARE
+	upper_bound		bound_value%TYPE;
+BEGIN
+	upper_bound := get_upper_bound(relid, bound_value);
+	IF bound_value > upper_bound THEN
+		RAISE EXCEPTION '%', error_message;
+	END IF;
+END
+$$ LANGUAGE plpgsql;
+
 /*
  * Spawn logic for append_partition(). We have to
  * separate this in order to pass the 'p_range'.
@@ -475,10 +533,12 @@ CREATE OR REPLACE FUNCTION @extschema@.append_partition_internal(
 	tablespace		TEXT DEFAULT NULL)
 RETURNS TEXT AS $$
 DECLARE
+	relid			REGCLASS;
 	part_expr_type	REGTYPE;
 	part_name		TEXT;
 	v_args_format	TEXT;
-
+	part_expr		TEXT;
+	part_type		INTEGER;
 BEGIN
 	IF @extschema@.get_number_of_partitions(parent_relid) = 0 THEN
 		RAISE EXCEPTION 'cannot append to empty partitions set';
@@ -496,6 +556,24 @@ BEGIN
 		RAISE EXCEPTION 'Cannot append partition because last partition''s range is half open';
 	END IF;
 
+	/*
+	 * In case a user has used same expression on two levels, we need to check
+	 * that we've not reached upper bound of higher partitioned table
+	 */
+	relid := @extschema@.get_parent_of_partition(parent_relid, false);
+	IF relid IS NOT NULL THEN
+		SELECT expr FROM @extschema@.pathman_config WHERE partrel = parent_relid
+		INTO part_expr;
+
+		part_type := get_partition_type(relid);
+		IF (part_type = 2) AND @extschema@.is_equal_to_partitioning_expression(
+				relid, part_expr, part_expr_type)
+		THEN
+			PERFORM @extschema@.check_against_upper_bound_internal(parent_relid,
+				p_range[2], 'reached upper bound in the current level of subpartitions');
+		END IF;
+	END IF;
+
 	IF @extschema@.is_date_type(p_atttype) THEN
 		v_args_format := format('$1, $2, ($2 + $3::interval)::%s, $4, $5', part_expr_type::TEXT);
 	ELSE

sql/pathman_subpartitions.sql

@@ -82,8 +82,8 @@ SET pg_pathman.enable_partitionrouter = ON;
 
 CREATE TABLE subpartitions.abc(a INTEGER NOT NULL, b INTEGER NOT NULL);
 SELECT create_range_partitions('subpartitions.abc', 'a', 0, 100, 2);
-SELECT create_range_partitions('subpartitions.abc_1', 'b', 0, 50, 2);
-SELECT create_range_partitions('subpartitions.abc_2', 'b', 0, 50, 2);
+SELECT create_range_partitions('subpartitions.abc_1', 'b', 0, 50, 2); /* 0 - 100 */
+SELECT create_range_partitions('subpartitions.abc_2', 'b', 0, 50, 2); /* 100 - 200 */
 
 INSERT INTO subpartitions.abc SELECT 25, 25 FROM generate_series(1, 10);
 SELECT tableoid::regclass, * FROM subpartitions.abc;	/* Should be in subpartitions.abc_1_1 */
@@ -103,10 +103,13 @@ SELECT split_range_partition('subpartitions.abc_2_2', 75);
 SELECT subpartitions.partitions_tree('subpartitions.abc');
 
 /* merge_range_partitions */
-SELECT append_range_partition('subpartitions.abc', 'subpartitions.abc_3');
+SELECT append_range_partition('subpartitions.abc', 'subpartitions.abc_3'); /* 200 - 300 */
 select merge_range_partitions('subpartitions.abc_2', 'subpartitions.abc_3');
 select merge_range_partitions('subpartitions.abc_2_1', 'subpartitions.abc_2_2');
 
+/* create subpartitions but use same expression */
+SELECT create_range_partitions('subpartitions.abc_3', 'a', 150, 50, 2);
+
 DROP TABLE subpartitions.abc CASCADE;
 DROP SCHEMA subpartitions CASCADE;
 DROP EXTENSION pg_pathman;

src/include/relation_info.h

@@ -296,6 +296,8 @@ Datum cook_partitioning_expression(const Oid relid,
 
 char *canonicalize_partitioning_expression(const Oid relid,
 										   const char *expr_cstr);
+bool is_equal_to_partitioning_expression(Oid relid, char *expression,
+										 Oid value_type);
 
 /* Global invalidation routines */
 void delay_pathman_shutdown(void);
@@ -312,6 +314,8 @@ Oid get_parent_of_partition(Oid partition, PartParentSearch *status);
 void forget_bounds_of_partition(Oid partition);
 PartBoundInfo *get_bounds_of_partition(Oid partition,
 									   const PartRelationInfo *prel);
+Datum get_lower_bound(Oid parent_relid, Oid value_type);
+Datum get_upper_bound(Oid relid, Oid value_type);
 
 /* PartType wrappers */
 

src/pl_funcs.c

@@ -72,6 +72,10 @@ PG_FUNCTION_INFO_V1( check_security_policy );
 PG_FUNCTION_INFO_V1( debug_capture );
 PG_FUNCTION_INFO_V1( pathman_version );
 
+PG_FUNCTION_INFO_V1( get_lower_bound_pl );
+PG_FUNCTION_INFO_V1( get_upper_bound_pl );
+PG_FUNCTION_INFO_V1( is_equal_to_partitioning_expression_pl );
+
 
 /* User context for function show_partition_list_internal() */
 typedef struct
@@ -145,6 +149,46 @@ get_parent_of_partition_pl(PG_FUNCTION_ARGS)
 	PG_RETURN_NULL();
 }
 
+/*
+ * Get parent of a specified partition.
+ */
+Datum
+is_equal_to_partitioning_expression_pl(PG_FUNCTION_ARGS)
+{
+	bool	result;
+	Oid		parent_relid	= PG_GETARG_OID(0);
+	char   *expr			= TextDatumGetCString(PG_GETARG_TEXT_P(1));
+	Oid		value_type		= PG_GETARG_OID(2);
+
+	result = is_equal_to_partitioning_expression(parent_relid, expr,
+												 value_type);
+	PG_RETURN_BOOL(result);
+}
+
+/*
+ * Get min bound value for parent relation
+ */
+Datum
+get_lower_bound_pl(PG_FUNCTION_ARGS)
+{
+	Oid		relid = PG_GETARG_OID(0);
+	Oid		value_type = get_fn_expr_argtype(fcinfo->flinfo, 1);
+
+	PG_RETURN_POINTER(get_lower_bound(relid, value_type));
+}
+
+/*
+ * Get min bound value for parent relation
+ */
+Datum
+get_upper_bound_pl(PG_FUNCTION_ARGS)
+{
+	Oid		relid = PG_GETARG_OID(0);
+	Oid		value_type = get_fn_expr_argtype(fcinfo->flinfo, 1);
+
+	PG_RETURN_POINTER(get_upper_bound(relid, value_type));
+}
+
 /*
  * Extract basic type of a domain.
  */

src/relation_info.c

@@ -1040,6 +1040,91 @@ get_parent_of_partition(Oid partition, PartParentSearch *status)
 	return get_parent_of_partition_internal(partition, status, HASH_FIND);
 }
 
+/* Check that expression is equal to expression of some partitioned table */
+bool
+is_equal_to_partitioning_expression(Oid relid, char *expression,
+									Oid value_type)
+{
+	const PartRelationInfo *prel;
+	char				   *cexpr;
+	Oid						expr_type;
+
+	/*
+	 * Cook and get a canonicalized expression,
+	 * we don't need a result of the cooking
+	 */
+	cook_partitioning_expression(relid, expression, &expr_type);
+	cexpr = canonicalize_partitioning_expression(relid, expression);
+
+	prel = get_pathman_relation_info(relid);
+
+	/* caller should have been check it already */
+	Assert(prel != NULL);
+
+	return (expr_type == value_type) &&
+		   (strcmp(cexpr, prel->expr_cstr) == 0);
+}
+
+/* Get lower bound of a partition */
+Datum
+get_lower_bound(Oid relid, Oid value_type)
+{
+	Oid						parent_relid;
+	Datum					result;
+	const PartRelationInfo *prel;
+	PartBoundInfo		   *pbin;
+	PartParentSearch		parent_search;
+
+	parent_relid = get_parent_of_partition(relid, &parent_search);
+	if (parent_search != PPS_ENTRY_PART_PARENT)
+		elog(ERROR, "relation \"%s\" is not a partition",
+			 get_rel_name_or_relid(relid));
+
+	prel = get_pathman_relation_info(parent_relid);
+	Assert(prel && prel->parttype == PT_RANGE);
+	pbin = get_bounds_of_partition(relid, prel);
+	Assert(prel != NULL);
+
+	if (IsInfinite(&pbin->range_min))
+		return PointerGetDatum(NULL);
+
+	result = BoundGetValue(&pbin->range_min);
+	if (value_type != prel->ev_type)
+		result = perform_type_cast(result, prel->ev_type, value_type, NULL);
+
+	return result;
+}
+
+/* Get upper bound of a partition */
+Datum
+get_upper_bound(Oid relid, Oid value_type)
+{
+	Oid						parent_relid;
+	Datum					result;
+	const PartRelationInfo *prel;
+	PartBoundInfo		   *pbin;
+	PartParentSearch		parent_search;
+
+	parent_relid = get_parent_of_partition(relid, &parent_search);
+	if (parent_search != PPS_ENTRY_PART_PARENT)
+		elog(ERROR, "relation \"%s\" is not a partition",
+			 get_rel_name_or_relid(relid));
+
+	prel = get_pathman_relation_info(parent_relid);
+	Assert(prel && prel->parttype == PT_RANGE);
+	pbin = get_bounds_of_partition(relid, prel);
+	Assert(prel != NULL);
+
+	if (IsInfinite(&pbin->range_max))
+		return PointerGetDatum(NULL);
+
+	result = BoundGetValue(&pbin->range_max);
+	if (value_type != prel->ev_type)
+		result = perform_type_cast(result, prel->ev_type, value_type, NULL);
+
+	return result;
+}
+
 /*
  * Get [and remove] "partition+parent" pair from cache,
  * also check syscache if 'status' is provided.