ERROR: partitioning key "dt" must be marked NOT NULL

ALTER TABLE test.range_rel ALTER COLUMN dt SET NOT NULL;

SELECT pathman.create_range_partitions('test.range_rel', 'DT', '2015-01-01'::DATE, '1 month'::INTERVAL);

NOTICE: sequence "range_rel_seq" does not exist, skipping

create_range_partitions

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

4

idSERIAL PRIMARY KEY,

txtTEXT);

SELECT pathman.create_range_partitions('test.num_range_rel', 'id', 0, 1000, 4);

NOTICE: sequence "num_range_rel_seq" does not exist, skipping

create_range_partitions

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

4

CREATE TABLE test.improved_dummy (id BIGSERIAL, name TEXT NOT NULL);

INSERT INTO test.improved_dummy (name) SELECT md5(g::TEXT) FROM generate_series(1, 100) as g;

SELECT pathman.create_range_partitions('test.improved_dummy', 'id', 1, 10);

NOTICE: sequence "improved_dummy_seq" does not exist, skipping

create_range_partitions

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

10

CREATE TABLE test.insert_into_select(val int NOT NULL);

INSERT INTO test.insert_into_select SELECT generate_series(1, 100);

SELECT pathman.create_range_partitions('test.insert_into_select', 'val', 1, 20);

NOTICE: sequence "insert_into_select_seq" does not exist, skipping

create_range_partitions

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

5

CREATE TABLE test.insert_date_test(val DATE NOT NULL);

SELECT pathman.create_partitions_from_range('test.insert_date_test', 'val',

date '20161001', date '20170101', interval '1 month');

NOTICE: sequence "insert_date_test_seq" does not exist, skipping

create_partitions_from_range

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

4

valueINT NOT NULL);

INSERT INTO test.zero SELECT g, g FROM generate_series(1, 100) as g;

SELECT pathman.create_range_partitions('test.zero', 'value', 50, 10, 0);

NOTICE: sequence "zero_seq" does not exist, skipping

create_range_partitions

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

0

INSERT INTO test."RangeRel" (dt, txt)

SELECT g, md5(g::TEXT) FROM generate_series('2015-01-01', '2015-01-03', '1 day'::interval) as g;

SELECT pathman.create_range_partitions('test."RangeRel"', 'dt', '2015-01-01'::DATE, '1 day'::INTERVAL);

NOTICE: sequence "RangeRel_seq" does not exist, skipping

create_range_partitions

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

3

CREATE TABLE test.special_case_1_ind_o_s(val serial, comment text);

INSERT INTO test.special_case_1_ind_o_s SELECT generate_series(1, 200), NULL;

SELECT create_range_partitions('test.special_case_1_ind_o_s', 'val', 1, 50);

NOTICE: sequence "special_case_1_ind_o_s_seq" does not exist, skipping

create_range_partitions

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

4

CREATE INDEX ON test.index_on_childs(c2);

INSERT INTO test.index_on_childs SELECT i, (random()*10000)::integer FROM generate_series(1, 10000) i;

SELECT create_range_partitions('test.index_on_childs', 'c1', 1, 1000, 0, false);

NOTICE: sequence "index_on_childs_seq" does not exist, skipping

create_range_partitions

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

0

DROP TABLE test.provided_part_names CASCADE;

NOTICE: drop cascades to 2 other objects

DROP SCHEMA test CASCADE;

NOTICE: drop cascades to47 other objects

NOTICE: drop cascades to38 other objects

DROP EXTENSION pg_pathman CASCADE;

DROP SCHEMA pathman CASCADE;

/* int4, size of Datum == 4 */

CREATE TABLE test_bgw.test_1(val INT4 NOT NULL);

SELECT create_range_partitions('test_bgw.test_1', 'val', 1, 5, 2);

NOTICE: sequence "test_1_seq" does not exist, skipping

create_range_partitions

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

2

/* int8, size of Datum == 8 */

CREATE TABLE test_bgw.test_2(val INT8 NOT NULL);

SELECT create_range_partitions('test_bgw.test_2', 'val', 1, 5, 2);

NOTICE: sequence "test_2_seq" does not exist, skipping

create_range_partitions

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

2

/* numeric, size of Datum == var */

CREATE TABLE test_bgw.test_3(val NUMERIC NOT NULL);

SELECT create_range_partitions('test_bgw.test_3', 'val', 1, 5, 2);

NOTICE: sequence "test_3_seq" does not exist, skipping

create_range_partitions

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

2

/* date, size of Datum == var */

CREATE TABLE test_bgw.test_4(val DATE NOT NULL);

SELECT create_range_partitions('test_bgw.test_4', 'val', '20170213'::date, '1 day'::interval, 2);

NOTICE: sequence "test_4_seq" does not exist, skipping

create_range_partitions

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

2

DROP TABLE test_bgw.test_4 CASCADE;

NOTICE: drop cascades to 3 other objects

DROP SCHEMA test_bgw CASCADE;

NOTICE: drop cascades to 4 other objects

DROP EXTENSION pg_pathman;

/* test pg_pathman's cache */

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

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

NOTICE: sequence "part_test_seq" does not exist, skipping

create_range_partitions

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

3

/* check function get_part_range_by_idx() */

CREATE TABLE calamity.test_range_idx(val INT4 NOT NULL);

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

NOTICE: sequence "test_range_idx_seq" does not exist, skipping

create_range_partitions

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

1

/* check function get_part_range_by_oid() */

CREATE TABLE calamity.test_range_oid(val INT4 NOT NULL);

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

NOTICE: sequence "test_range_oid_seq" does not exist, skipping

create_range_partitions

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

1

CREATE TABLE calamity.merge_test_a(val INT4 NOT NULL);

CREATE TABLE calamity.merge_test_b(val INT4 NOT NULL);

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

NOTICE: sequence "merge_test_a_seq" does not exist, skipping

create_range_partitions

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

2

(1 row)

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

NOTICE: sequence "merge_test_b_seq" does not exist, skipping

create_range_partitions

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

2

DROP TABLE calamity.trig_test_tbl CASCADE;

NOTICE: drop cascades to 2 other objects

DROP SCHEMA calamity CASCADE;

NOTICE: drop cascades to20 other objects

NOTICE: drop cascades to15 other objects

DROP EXTENSION pg_pathman;

/*

* -------------------------------------

/* check view pathman_cache_stats */

CREATE TABLE calamity.test_pathman_cache_stats(val NUMERIC NOT NULL);

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

NOTICE: sequence "test_pathman_cache_stats_seq" does not exist, skipping

create_range_partitions

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

10

DROP TABLE calamity.test_pathman_cache_stats;

DROP SCHEMA calamity CASCADE;

NOTICE: drop cascades to sequence calamity.test_pathman_cache_stats_seq

DROP EXTENSION pg_pathman;

/*

* ------------------------------------------

/* check function pathman_cache_search_relid() */

CREATE TABLE calamity.survivor(val INT NOT NULL);

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

NOTICE: sequence "survivor_seq" does not exist, skipping

create_range_partitions

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

2

DROP TABLE calamity.survivor CASCADE;

NOTICE: drop cascades to 2 other objects

DROP SCHEMA calamity CASCADE;

NOTICE: drop cascades to sequence calamity.survivor_seq

DROP EXTENSION pg_pathman;

$$ language plpgsql;

CREATE TABLE callbacks.abc(a serial, b int);

SELECT create_range_partitions('callbacks.abc', 'a', 1, 100, 2);

NOTICE: sequence "abc_seq" does not exist, skipping

create_range_partitions

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

2

DROP TABLE callbacks.abc CASCADE;

NOTICE: drop cascades to 4 other objects

DROP SCHEMA callbacks CASCADE;

NOTICE: drop cascades to3 other objects

NOTICE: drop cascades to2 other objects

DROP EXTENSION pg_pathman CASCADE;

/* create new table (val int) */

CREATE TABLE test_column_type.test(val INT4 NOT NULL);

SELECT create_range_partitions('test_column_type.test', 'val', 1, 10, 10);

NOTICE: sequence "test_seq" does not exist, skipping

create_range_partitions

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

10

DROP TABLE test_column_type.test CASCADE;

DROP SCHEMA test_column_type CASCADE;

NOTICE: drop cascades to sequence test_column_type.test_seq

DROP EXTENSION pg_pathman;

SELECT g, md5(g::TEXT)

FROM generate_series('2015-01-01', '2015-04-30', '1 day'::interval) AS g;

SELECT create_range_partitions('test_cte.range_rel', 'DT', '2015-01-01'::DATE, '1 month'::INTERVAL);

NOTICE: sequence "range_rel_seq" does not exist, skipping

create_range_partitions

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

4

/* create 2 partitions */

SELECT create_range_partitions('test_cte.cte_del_xacts'::regclass, 'pdate',

'2016-01-01'::date, '50 days'::interval);

NOTICE: sequence "cte_del_xacts_seq" does not exist, skipping

create_range_partitions

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

2

(4 rows)

DROP SCHEMA test_cte CASCADE;

NOTICE: drop cascades to5 other objects

NOTICE: drop cascades to3 other objects

DROP EXTENSION pg_pathman;

CREATE TABLE domains.dom_table(val domains.dom_test NOT NULL);

INSERT INTO domains.dom_table SELECT generate_series(1, 999);

SELECT create_range_partitions('domains.dom_table', 'val', 1, 100);

NOTICE: sequence "dom_table_seq" does not exist, skipping

create_range_partitions

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

10

(5 rows)

DROP SCHEMA domains CASCADE;

NOTICE: drop cascades to8 other objects

NOTICE: drop cascades to7 other objects

DROP EXTENSION pg_pathman CASCADE;

ERROR: start value is less than min value of "random()"

SELECT create_range_partitions('test_exprs.range_rel', 'AGE(dt, ''2000-01-01''::DATE)',

'15 years'::INTERVAL, '1 year'::INTERVAL, 10);

NOTICE: sequence "range_rel_seq" does not exist, skipping

create_range_partitions

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

10

(1 row)

DROP SCHEMA test_exprs CASCADE;

NOTICE: drop cascades to17 other objects

NOTICE: drop cascades to16 other objects

DROP EXTENSION pg_pathman;

FOREIGN KEY (comment) REFERENCES fkeys.test_ref(comment));

INSERT INTO fkeys.test_fkey SELECT generate_series(1, 1000), 'test';

SELECT create_range_partitions('fkeys.test_fkey', 'id', 1, 100);

NOTICE: sequence "test_fkey_seq" does not exist, skipping

create_range_partitions

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

10

ERROR: table "fkeys.messages" is referenced from other tables

ALTER TABLE fkeys.replies DROP CONSTRAINT replies_message_id_fkey;

SELECT create_range_partitions('fkeys.messages', 'id', 1, 100, 2); /* ok */

NOTICE: sequence "messages_seq" does not exist, skipping

create_range_partitions

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

2

DROP TABLE fkeys.messages, fkeys.replies CASCADE;

NOTICE: drop cascades to 2 other objects

DROP SCHEMA fkeys CASCADE;

NOTICE: drop cascades to4 other objects

NOTICE: drop cascades to2 other objects

DROP EXTENSION pg_pathman CASCADE;

INSERT INTO test_inserts.storage SELECT i * 2, i, i, i::text FROM generate_series(1, 100) i;

CREATE UNIQUE INDEX ON test_inserts.storage(a);

SELECT create_range_partitions('test_inserts.storage', 'b', 1, 10);

NOTICE: sequence "storage_seq" does not exist, skipping

create_range_partitions

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

10

CREATE TABLE test_inserts.test_gap(val INT NOT NULL);

INSERT INTO test_inserts.test_gap SELECT generate_series(1, 30);

SELECT create_range_partitions('test_inserts.test_gap', 'val', 1, 10);

NOTICE: sequence "test_gap_seq" does not exist, skipping

create_range_partitions

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

3

DROP TABLE test_inserts.test_gap CASCADE;

NOTICE: drop cascades to 2 other objects

DROP SCHEMA test_inserts CASCADE;

NOTICE: drop cascades to20 other objects

NOTICE: drop cascades to18 other objects

DROP EXTENSION pg_pathman CASCADE;

/* Range partitions for INT2 type */

CREATE TABLE test_interval.abc (id INT2 NOT NULL);

SELECT create_range_partitions('test_interval.abc', 'id', 0, 100, 2);

NOTICE: sequence "abc_seq" does not exist, skipping

create_range_partitions

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

2

DROP TABLE test_interval.abc CASCADE;

NOTICE: drop cascades to 3 other objects

DROP SCHEMA test_interval CASCADE;

NOTICE: drop cascades to sequence test_interval.abc_seq

DROP EXTENSION pg_pathman;

CREATE TABLE test_only.from_only_test(val INT NOT NULL);

INSERT INTO test_only.from_only_test SELECT generate_series(1, 20);

SELECT create_range_partitions('test_only.from_only_test', 'val', 1, 2);

NOTICE: sequence "from_only_test_seq" does not exist, skipping

create_range_partitions

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

10

(27 rows)

DROP SCHEMA test_only CASCADE;

NOTICE: drop cascades to12 other objects

NOTICE: drop cascades to11 other objects

DROP EXTENSION pg_pathman;

/* Should be ok */

SET ROLE user1;

SELECT create_range_partitions('permissions.user1_table', 'id', 1, 10, 2);

NOTICE: sequence "user1_table_seq" does not exist, skipping

create_range_partitions

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

2

INSERT INTO permissions.dropped_column SELECT i,i,i,i FROM generate_series(1, 30) i;

GRANT SELECT(val), INSERT(val) ON permissions.dropped_column TO user2;

SELECT create_range_partitions('permissions.dropped_column', 'val', 1, 10);

NOTICE: sequence "dropped_column_seq" does not exist, skipping

create_range_partitions

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

3

create table test.runtime_test_4(val text, id int not null);

insert into test.runtime_test_4(id, val) select * from generate_series(1, 10000) k, md5(k::text);

select pathman.create_range_partitions('test.runtime_test_4', 'id', 1, 2000);

NOTICE: sequence "runtime_test_4_seq" does not exist, skipping

create_range_partitions

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

5

set enable_hashjoin = on;

set enable_mergejoin = on;

DROP SCHEMA test CASCADE;

NOTICE: drop cascades to37 other objects

NOTICE: drop cascades to36 other objects

DROP EXTENSION pg_pathman CASCADE;

DROP SCHEMA pathman CASCADE;

CREATE TABLE test_update_trigger.test_range(val NUMERIC NOT NULL, comment TEXT);

INSERT INTO test_update_trigger.test_range SELECT i, i FROM generate_series(1, 100) i;

SELECT create_range_partitions('test_update_trigger.test_range', 'val', 1, 10);

NOTICE: sequence "test_range_seq" does not exist, skipping

create_range_partitions

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

10

(1 row)

DROP SCHEMA test_update_trigger CASCADE;

NOTICE: drop cascades to18 other objects

NOTICE: drop cascades to17 other objects

DROP EXTENSION pg_pathman;