pathman_permissions\

pathman_rowmarks\

pathman_utility_stmt_hooking\

pathman_calamity

pathman_calamity\

pathman_interval

EXTRA_REGRESS_OPTS=--temp-config=$(top_srcdir)/$(subdir)/conf.add

EXTRA_CLEAN = pg_pathman--$(EXTVERSION).sql ./isolation_output

p_countINTEGER DEFAULTNULL,

partition_dataBOOLEAN DEFAULT TRUE)

Performs RANGE partitioning for`relation` by partitioning key`attribute`.`start_value` argument specifies initial value,`interval` sets the rangeof values in a singlepartition,`count` is the number of premade partitions (if not set thenpathman tries to determine it based on attribute values). Partition creation callback is invoked for each partition if set beforehand.

Performs RANGE partitioning for`relation` by partitioning key`attribute`,`start_value` argument specifies initial value,`p_interval` sets thedefaultrangefor auto created partitions or partitions created with`append_range_partition()` or`prepend_range_partition()` (if`NULL` then autopartition creation feature won't work),`p_count` is the number of premade partitions (if not set then`pg_pathman` tries to determine it based on attribute values). Partition creation callback is invoked for each partition if set beforehand.

create_partitions_from_range(relation REGCLASS,

Merge two adjacent RANGE partitions. First, data from`partition2` is copied to`partition1`, then`partition2` is removed.

merge_range_partitions(partitions REGCLASS[])

Merge several adjacent RANGE partitions (partitions must be specified in ascending or descending order). All the data will be accumulated in the first partition.

append_range_partition(parent REGCLASS,

partition_nameTEXT DEFAULTNULL,

partition_nameTEXT DEFAULTNULL,

tablespaceTEXT DEFAULTNULL)

Create new RANGE partition for`relation` with specified range bounds.

Create new RANGE partition for`relation` with specified range bounds. If`start_value` or`end_value` are NULL then corresponding range bound will be infinite.

drop_range_partition(partitionTEXT, delete_dataBOOLEAN DEFAULT TRUE)

set_interval(relation REGCLASS, value ANYELEMENT)

Update RANGE partitioned table interval.

set_enable_parent(relation REGCLASS, valueBOOLEAN)

test.num_range_rel_7

(1 row)

SELECT pathman.drop_range_partition_expand_next('test.num_range_rel_4');

drop_range_partition_expand_next

----------------------------------

(1 row)

SELECT * FROM pathman.pathman_partition_list WHERE parent = 'test.num_range_rel'::regclass;

parent | partition | parttype | partattr | range_min | range_max

--------------------+----------------------+----------+----------+-----------+-----------

test.num_range_rel | test.num_range_rel_1 | 2 | id | 0 | 1000

test.num_range_rel | test.num_range_rel_2 | 2 | id | 1000 | 2000

test.num_range_rel | test.num_range_rel_3 | 2 | id | 2000 | 3000

test.num_range_rel | test.num_range_rel_6 | 2 | id | 3000 | 5000

(4 rows)

SELECT pathman.drop_range_partition_expand_next('test.num_range_rel_6');

drop_range_partition_expand_next

----------------------------------

(1 row)

SELECT * FROM pathman.pathman_partition_list WHERE parent = 'test.num_range_rel'::regclass;

parent | partition | parttype | partattr | range_min | range_max

--------------------+----------------------+----------+----------+-----------+-----------

test.num_range_rel | test.num_range_rel_1 | 2 | id | 0 | 1000

test.num_range_rel | test.num_range_rel_2 | 2 | id | 1000 | 2000

test.num_range_rel | test.num_range_rel_3 | 2 | id | 2000 | 3000

(3 rows)

SELECT pathman.append_range_partition('test.range_rel');

append_range_partition

------------------------

dt TIMESTAMP);

SELECT pathman.attach_range_partition('test.range_rel', 'test.range_rel_test2', '2013-01-01'::DATE, '2014-01-01'::DATE);

ERROR: partition must have the exact same structure as parent

/* Half open ranges */

SELECT pathman.add_range_partition('test.range_rel', NULL, '2014-12-01'::DATE, 'test.range_rel_minus_infinity');

add_range_partition

-------------------------------

test.range_rel_minus_infinity

(1 row)

SELECT pathman.add_range_partition('test.range_rel', '2015-06-01'::DATE, NULL, 'test.range_rel_plus_infinity');

add_range_partition

------------------------------

test.range_rel_plus_infinity

(1 row)

SELECT pathman.append_range_partition('test.range_rel');

ERROR: Cannot append partition because last partition's range is half open

SELECT pathman.prepend_range_partition('test.range_rel');

ERROR: Cannot prepend partition because first partition's range is half open

DROP TABLE test.range_rel_minus_infinity;

CREATE TABLE test.range_rel_minus_infinity (LIKE test.range_rel INCLUDING ALL);

SELECT pathman.attach_range_partition('test.range_rel', 'test.range_rel_minus_infinity', NULL, '2014-12-01'::DATE);

attach_range_partition

-------------------------------

test.range_rel_minus_infinity

(1 row)

SELECT * FROM pathman.pathman_partition_list WHERE parent = 'test.range_rel'::REGCLASS;

parent | partition | parttype | partattr | range_min | range_max

----------------+-------------------------------+----------+----------+--------------------------+--------------------------

test.range_rel | test.range_rel_minus_infinity | 2 | dt | NULL | Mon Dec 01 00:00:00 2014

test.range_rel | test.range_rel_8 | 2 | dt | Mon Dec 01 00:00:00 2014 | Thu Jan 01 00:00:00 2015

test.range_rel | test.range_rel_1 | 2 | dt | Thu Jan 01 00:00:00 2015 | Sun Feb 01 00:00:00 2015

test.range_rel | test.range_rel_2 | 2 | dt | Sun Feb 01 00:00:00 2015 | Sun Mar 01 00:00:00 2015

test.range_rel | test.range_rel_3 | 2 | dt | Sun Mar 01 00:00:00 2015 | Wed Apr 01 00:00:00 2015

test.range_rel | test.range_rel_4 | 2 | dt | Wed Apr 01 00:00:00 2015 | Fri May 01 00:00:00 2015

test.range_rel | test.range_rel_6 | 2 | dt | Fri May 01 00:00:00 2015 | Mon Jun 01 00:00:00 2015

test.range_rel | test.range_rel_plus_infinity | 2 | dt | Mon Jun 01 00:00:00 2015 | NULL

(8 rows)

INSERT INTO test.range_rel (dt) VALUES ('2012-06-15');

INSERT INTO test.range_rel (dt) VALUES ('2015-12-15');

EXPLAIN (COSTS OFF) SELECT * FROM test.range_rel WHERE dt < '2015-01-01';

QUERY PLAN

--------------------------------------------

Append

-> Seq Scan on range_rel_minus_infinity

-> Seq Scan on range_rel_8

(3 rows)

EXPLAIN (COSTS OFF) SELECT * FROM test.range_rel WHERE dt >= '2015-05-01';

QUERY PLAN

-------------------------------------------

Append

-> Seq Scan on range_rel_6

-> Seq Scan on range_rel_plus_infinity

(3 rows)

/*

* Zero partitions count and adding partitions with specified name

*/

(1 row)

SELECT pathman.append_range_partition('test.zero', 'test.zero_0');

ERROR:cannot append to empty partitions set

ERROR:relation "zero" has no partitions

SELECT pathman.prepend_range_partition('test.zero', 'test.zero_1');

ERROR:cannot prepend to empty partitions set

ERROR:relation "zero" has no partitions

SELECT pathman.add_range_partition('test.zero', 50, 70, 'test.zero_50');

add_range_partition

---------------------

DROP TABLE test.hash_rel CASCADE;

SELECT pathman.drop_partitions('test.num_range_rel');

NOTICE: drop cascades to4 other objects

NOTICE: drop cascades to3 other objects

NOTICE: 998 rows copied from test.num_range_rel_1

NOTICE: 1000 rows copied from test.num_range_rel_2

NOTICE: 1000 rows copied from test.num_range_rel_3

NOTICE: 2 rows copied from test.num_range_rel_4

NOTICE: 0 rows copied from test.num_range_rel_6

drop_partitions

-----------------

(1 row)

DROP TABLE test.num_range_rel CASCADE;

DROP TABLE test.range_rel CASCADE;

NOTICE: drop cascades to7 other objects

NOTICE: drop cascades to9 other objects

/* Test automatic partition creation */

CREATE TABLE test.range_rel (

idSERIAL PRIMARY KEY,

(1 row)

DELETE FROM calamity.part_test;

/* test function create_hash_partitions() */

SELECT create_hash_partitions('calamity.part_test', 'val', 2,

relnames := ARRAY['calamity.p1']::TEXT[]);

ERROR: size of array 'relnames' must be equal to 'partitions_count'

SELECT create_hash_partitions('calamity.part_test', 'val', 2,

tablespaces := ARRAY['abcd']::TEXT[]);

ERROR: size of array 'tablespaces' must be equal to 'partitions_count'

/* test stub 'enable_parent' value for PATHMAN_CONFIG_PARAMS */

INSERT INTO calamity.part_test SELECT generate_series(1, 30);

SELECT create_range_partitions('calamity.part_test', 'val', 1, 10);

4

(1 row)

DELETE FROM calamity.part_test;

/* check function validate_interval_value() */

SELECT set_interval('pg_catalog.pg_class', 100); /* not ok */

ERROR: table "pg_class" is not partitioned by RANGE

INSERT INTO calamity.part_test SELECT generate_series(1, 30);

SELECT create_range_partitions('calamity.part_test', 'val', 1, 10);

create_range_partitions

-------------------------

3

(1 row)

SELECT set_interval('calamity.part_test', 100);/* ok */

set_interval

--------------

(1 row)

SELECT set_interval('calamity.part_test', 15.6);/* not ok */

ERROR: invalid input syntax for integer: "15.6"

SELECT set_interval('calamity.part_test', 'abc'::text);/* not ok */

ERROR: invalid input syntax for integer: "abc"

SELECT drop_partitions('calamity.part_test', true);

NOTICE: function calamity.part_test_upd_trig_func() does not exist, skipping

drop_partitions

-----------------

3

(1 row)

DELETE FROM calamity.part_test;

/* check function build_hash_condition() */

SELECT build_hash_condition('int4', 'val', 10, 1);

SELECT build_hash_condition('calamity.part_test', 'val', 10, 1);

ERROR: no hash function for type calamity.part_test

/* check function build_range_condition() */

SELECT build_range_condition('val', 10, 20);

build_range_condition

----------------------------

val >='10' AND val <'20'

SELECT build_range_condition('calamity.part_test', 'val', 10, 20);

build_range_condition

------------------------------

((val >=10) AND(val <20))

(1 row)

SELECT build_range_condition('val', 10, NULL) IS NULL;

?column?

----------

t

SELECT build_range_condition('calamity.part_test', 'val', 10, NULL);

build_range_condition

-----------------------

((val >= 10))

(1 row)

SELECT build_range_condition('calamity.part_test', 'val', NULL, 10);

build_range_condition

-----------------------

((val < 10))

(1 row)

/* check function validate_relname() */

t

(1 row)

/* check function get_attribute_type() */

SELECT get_attribute_type('calamity.part_test', 'val');

get_attribute_type

--------------------

integer

(1 row)

SELECT get_attribute_type('calamity.part_test', NULL) IS NULL;

?column?

----------

t

(1 row)

SELECT get_attribute_type(NULL, 'val') IS NULL;

?column?

----------

t

(1 row)

SELECT get_attribute_type(NULL, NULL) IS NULL;

/* check function get_partition_key_type() */

SELECT get_partition_key_type('calamity.part_test');

ERROR: relation "part_test" has no partitions

SELECT get_partition_key_type(0::regclass);

ERROR: relation "0" has no partitions

SELECT get_partition_key_type(NULL) IS NULL;

?column?

----------

t

/* check function stop_concurrent_part_task() */

SELECT stop_concurrent_part_task(1::regclass);

ERROR: cannot find worker for relation "1"

/* check function drop_range_partition_expand_next() */

SELECT drop_range_partition_expand_next('pg_class');

ERROR: relation "pg_class" is not a partition

SELECT drop_range_partition_expand_next(NULL) IS NULL;

?column?

----------

t

(1 row)

/* check invoke_on_partition_created_callback() for RANGE */

SELECT invoke_on_partition_created_callback('calamity.part_test', 'calamity.part_test', 1, NULL, NULL::int);

ERROR: both bounds must be provided for RANGE partition

-> Seq Scan on part_ok_3

(5 rows)

ALTER TABLE calamity.wrong_partition

ADD CONSTRAINT pathman_wrong_partition_1_check

CHECK (val < 10); /* wrong constraint */

SELECT add_to_pathman_config('calamity.part_test', 'val', '10');

ERROR: wrong constraint format for RANGE partition "wrong_partition"

EXPLAIN (COSTS OFF) SELECT * FROM calamity.part_ok; /* check that pathman is enabled */

QUERY PLAN

-----------------------------

Append

-> Seq Scan on part_ok_0

-> Seq Scan on part_ok_1

-> Seq Scan on part_ok_2

-> Seq Scan on part_ok_3

(5 rows)

ALTER TABLE calamity.wrong_partition DROP CONSTRAINT pathman_wrong_partition_1_check;

ALTER TABLE calamity.wrong_partition

ADD CONSTRAINT pathman_wrong_partition_1_check

CHECK (val = 1 OR val = 2); /* wrong constraint */