SELECT pathman.create_hash_partitions('test.hash_rel', 'value', 3);

ERROR: Partitioning key 'value' must be NOT NULL

ALTER TABLE test.hash_rel ALTER COLUMN value SET NOT NULL;

SELECT pathman.create_hash_partitions('test.hash_rel', 'value', 3);

NOTICE: function test.hash_rel_hash_insert_trigger_func() does not exist, skipping

NOTICE: function test.hash_rel_hash_update_trigger_func() does not exist, skipping

SELECT pathman.create_hash_partitions('test.hash_rel', 'Value', 3);

NOTICE: function test.hash_rel_insert_trigger_func() does not exist, skipping

NOTICE: function test.hash_rel_update_trigger_func() does not exist, skipping

NOTICE: Copying data to partitions...

create_hash_partitions

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

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, 2);

ERROR: Not enough partitions to fit all the values of 'dt' P0001

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

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

NOTICE: Copying data to partitions...

create_range_partitions

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 P0001

/*

* Check that altering table columns doesn't break trigger

*/

ALTER TABLE test.hash_rel ADD COLUMN abc int;

INSERT INTO test.hash_rel (id, value, abc) VALUES (123, 456, 789);

SELECT * FROM test.hash_rel WHERE id = 123;

id | value | abc

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

123 | 456 | 789

(1 row)

/*

* Clean up

*/

SELECT pathman.drop_hash_partitions('test.hash_rel');

NOTICE: drop cascades to trigger test_hash_rel_insert_trigger on table test.hash_rel

NOTICE:function test.hash_rel_hash_update_trigger_func() does not exist, skipping

NOTICE:drop cascades to 3 other objects

NOTICE: 2 rows copied from test.hash_rel_2

NOTICE: 3 rows copied from test.hash_rel_1

NOTICE:1 rows copied from test.hash_rel_0

NOTICE:2 rows copied from test.hash_rel_0

drop_hash_partitions

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

3

SELECT COUNT(*) FROM ONLY test.hash_rel;

count

-------

(1 row)

SELECT pathman.create_hash_partitions('test.hash_rel', 'value', 3);

NOTICE: function test.hash_rel_hash_insert_trigger_func() does not exist, skipping

NOTICE: function test.hash_rel_hash_update_trigger_func() does not exist, skipping

NOTICE: function test.hash_rel_insert_trigger_func() does not exist, skipping

NOTICE: function test.hash_rel_update_trigger_func() does not exist, skipping

NOTICE: Copying data to partitions...

create_hash_partitions

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

SELECT pathman.drop_hash_partitions('test.hash_rel', TRUE);

NOTICE: drop cascades to trigger test_hash_rel_insert_trigger on table test.hash_rel

NOTICE: function test.hash_rel_hash_update_trigger_func() does not exist, skipping

NOTICE: function test.hash_rel_update_trigger_func() does not exist, skipping

drop_hash_partitions

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

3

valueINTEGER NOT NULL);

INSERT INTO hash_rel (value) SELECT g FROM generate_series(1, 10000) as g;

SELECT create_hash_partitions('hash_rel', 'value', 3);

NOTICE: functionhash_rel_hash_insert_trigger_func() does not exist, skipping

NOTICE: functionhash_rel_hash_update_trigger_func() does not exist, skipping

NOTICE: functionhash_rel_insert_trigger_func() does not exist, skipping

NOTICE: functionhash_rel_update_trigger_func() does not exist, skipping

NOTICE: Copying data to partitions...

create_hash_partitions

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

v_typeTEXT;

relation := @extschema@.validate_relname(relation);

attribute :=lower(attribute);

PERFORM @extschema@.common_relation_checks(relation, attribute);

v_type := @extschema@.get_attribute_type_name(relation, attribute);

$$

DECLARE

funcTEXT :='

triggerTEXT :='

FOR EACH ROW EXECUTE PROCEDURE %2$s_hash_insert_trigger_func();';

FOR EACH ROW EXECUTE PROCEDURE %2$s_insert_trigger_func();';

fieldsTEXT;

fields_formatTEXT;

insert_stmtTEXT;

INTO fields, fields_format;

insert_stmt= format('EXECUTE format(''INSERT INTO %s_%%s VALUES (%s)'', hash) USING %s;'

, relation

, fields_format

, fields);

insert_stmt= format('EXECUTE format(''INSERT INTO %s_%%s SELECT $1.*'', hash) USING NEW;'

, relation);

func := format(func, relation, attr, partitions_count, insert_stmt);

RETURNS VOIDAS

$$

EXECUTE format('DROP FUNCTION IF EXISTS %s_hash_insert_trigger_func() CASCADE'

EXECUTE format('DROP FUNCTION IF EXISTS %s_insert_trigger_func() CASCADE'

, relation::regclass::text);

EXECUTE format('DROP FUNCTION IF EXISTS %s_hash_update_trigger_func() CASCADE'

EXECUTE format('DROP FUNCTION IF EXISTS %s_update_trigger_func() CASCADE'

, relation::regclass::text);

END

$$ LANGUAGE plpgsql;

charsql[]="SELECT pg_class.relfilenode, pg_attribute.attnum, cfg.parttype, pg_attribute.atttypid "

"AND attrelid = pg_class.relfilenode";

char*query;

if (relations!=NULL)

hash_destroy(relations);

#ifPG_VERSION_NUM >=90600

relations=ShmemInitHash("Partitioning relation info",1024,&ctl,HASH_ELEM |HASH_BLOBS);

relations=ShmemInitHash("Partitioning relation info",1024,1024,&ctl,HASH_ELEM |HASH_BLOBS);

}

memset(&ctl,0,sizeof(ctl));

ctl.keysize=sizeof(RelationKey);

ctl.entrysize=sizeof(RangeRelation);

#ifPG_VERSION_NUM >=90600

range_restrictions=ShmemInitHash("pg_pathman range restrictions",

1024,&ctl,HASH_ELEM |HASH_BLOBS);

range_restrictions=ShmemInitHash("pg_pathman range restrictions",

1024,1024,&ctl,HASH_ELEM |HASH_BLOBS);

}

CREATEOR REPLACE FUNCTION @extschema@.disable_partitioning(IN relationTEXT)

RETURNS VOIDAS

$$

DECLARE

parttypeINTEGER;

relation := @extschema@.validate_relname(relation);

parttype := parttypeFROM pathman_configWHERE relname= relation;

DELETEFROM @extschema@.pathman_configWHERE relname= relation;

EXECUTE format('DROP FUNCTION IF EXISTS %s_insert_trigger_func() CASCADE', relation);

IF parttype=1 THEN

PERFORM @extschema@.drop_hash_triggers(relation);

ELSIF parttype=2 THEN

PERFORM @extschema@.drop_range_triggers(relation);

END IF;

PERFORM on_remove_partitions(relation::regclass::integer);

pathman_shmem_startup(void)

{

LWLockAcquire(AddinShmemInitLock,LW_EXCLUSIVE);

init_dsm_config();

iINTEGER;

p_relation := @extschema@.validate_relname(p_relation);

p_attribute :=lower(p_attribute);

PERFORM @extschema@.common_relation_checks(p_relation, p_attribute);

iINTEGER;

p_relation := @extschema@.validate_relname(p_relation);

p_attribute :=lower(p_attribute);

PERFORM @extschema@.common_relation_checks(p_relation, p_attribute);

IF p_count<=0 THEN

iINTEGER :=0;

p_relation := @extschema@.validate_relname(p_relation);

p_attribute :=lower(p_attribute);

PERFORM @extschema@.common_relation_checks(p_relation, p_attribute);

IF p_interval<=0 THEN

iINTEGER :=0;

p_relation := @extschema@.validate_relname(p_relation);

p_attribute :=lower(p_attribute);

PERFORM @extschema@.common_relation_checks(p_relation, p_attribute);

EXECUTE format('DROP SEQUENCE IF EXISTS %s_seq', p_relation);

LIMIT1;

EXIT WHEN v_child_relname_exists=0;

END LOOP;

IF EXISTS (SELECT*FROM pg_tablesWHERE tablename= v_child_relname) THEN

, v_cond);

EXECUTE v_sql;

RETURN v_child_relname;

END

$$ LANGUAGE plpgsql;

p_range := @extschema@.get_range_by_idx(p_relation::regclass::oid,0,0);

RAISE NOTICE'Prepending new partition...';

IF @extschema@.is_date(p_atttype::regtype) THEN

v_part_name := @extschema@.create_single_range_partition(p_relation

END LOOP;

DELETEFROM @extschema@.pathman_configWHERE relname= relation;

PERFORM @extschema@.on_remove_partitions(relation::regclass::oid);

INSERT INTOtest.hash_relVALUES (3,3);

SELECTpathman.create_hash_partitions('test.hash_rel','value',3);

ALTERTABLEtest.hash_rel ALTER COLUMN valueSETNOT NULL;

SELECTpathman.create_hash_partitions('test.hash_rel','value',3);

SELECTpathman.create_hash_partitions('test.hash_rel','Value',3);

SELECTCOUNT(*)FROMtest.hash_rel;

SELECTCOUNT(*)FROM ONLYtest.hash_rel;

INSERT INTOtest.hash_relVALUES (4,4);

SELECTpathman.create_range_partitions('test.range_rel','dt','2015-01-01'::DATE,'1 month'::INTERVAL,2);

ALTERTABLEtest.range_rel ALTER COLUMN dtSETNOT NULL;

SELECTpathman.create_range_partitions('test.range_rel','dt','2015-01-01'::DATE,'1 month'::INTERVAL,2);

SELECTpathman.create_range_partitions('test.range_rel','dt','2015-01-01'::DATE,'1 month'::INTERVAL);

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

SELECTCOUNT(*)FROMtest.range_rel;

SELECTCOUNT(*)FROM ONLYtest.range_rel;

dtTIMESTAMP);

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

ALTERTABLEtest.hash_rel ADD COLUMN abcint;

INSERT INTOtest.hash_rel (id, value, abc)VALUES (123,456,789);

SELECT*FROMtest.hash_relWHERE id=123;

if (!handle)

{

ereport(WARNING,

(errmsg("pg_pathman worker:ivalid dsm_handle")));

(errmsg("pg_pathman worker:invalid dsm_handle")));

}

segment=dsm_attach(handle);

args=dsm_segment_address(segment);