10

(1 row)

/* Check callbacks */

CREATE TABLE log(id serial, message text);

CREATE FUNCTION abc_on_partition_created_callback(args jsonb)

RETURNS VOID AS $$

DECLARE

start_value TEXT := args->>'start';

end_value TEXT := args::jsonb->'end';

BEGIN

-- raise notice 'callback: %', args->start;

INSERT INTO log(message)

VALUES (start_value || '-' || end_value);

END

$$ language plpgsql;

CREATE TABLE abc(a serial, b int);

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

NOTICE: sequence "abc_seq" does not exist, skipping

create_range_partitions

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

2

(1 row)

SELECT set_callback('abc', 'abc_on_partition_created_callback');

set_callback

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

(1 row)

INSERT INTO abc VALUES (123, 1);

INSERT INTO abc VALUES (223, 1);

SELECT append_range_partition('abc');

append_range_partition

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

public.abc_4

(1 row)

SELECT prepend_range_partition('abc');

prepend_range_partition

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

public.abc_5

(1 row)

SELECT add_range_partition('abc', 401, 501);

add_range_partition

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

public.abc_6

(1 row)

SELECT message FROM log;

message

---------

201-301

301-401

-99-1

401-501

(4 rows)

CREATETABLEIF NOT EXISTS @extschema@.pathman_config_params (

partrelREGCLASSNOT NULLPRIMARY KEY,

enable_parentBOOLEANNOT NULL DEFAULT TRUE,

autoBOOLEANNOT NULL DEFAULT TRUE

autoBOOLEANNOT NULL DEFAULT TRUE,

callbackREGPROCEDURE

);

ON @extschema@.pathman_config_params(partrel);

CREATETYPEpartitionAS (

parentREGCLASS,

parttypeINTEGER,

childREGCLASS,

start_valueTEXT,

end_valueTEXT

);

CREATEOR REPLACE FUNCTION @extschema@.pathman_set_param(

relationREGCLASS,

paramTEXT,

valueBOOLEAN)

valueANYELEMENT)

RETURNS VOIDAS

$$

$$

LANGUAGE plpgsql;

CREATEOR REPLACE FUNCTION @extschema@.set_callback(relation REGCLASS, callback REGPROC)

RETURNS VOIDAS

$$

PERFORM @extschema@.validate_on_partition_created_callback(callback);

PERFORM @extschema@.pathman_set_param(relation,'callback', callback);

END

$$

LANGUAGE plpgsql;

CREATEOR REPLACE FUNCTION @extschema@.get_rel_tablespace_name(relation REGCLASS)

RETURNSTEXTAS'pg_pathman','get_rel_tablespace_name'

LANGUAGE C STRICT;

CREATEOR REPLACE FUNCTION @extschema@.validate_on_partition_created_callback(callback REGPROC)

RETURNS VOIDAS'pg_pathman','validate_on_partition_created_callback'

LANGUAGE C STRICT;

CREATEOR REPLACE FUNCTION @extschema@.invoke_on_partition_created_callback(

parentREGCLASS,

partitionREGCLASS,

start_valueANYELEMENT,

end_valueANYELEMENT)

RETURNS VOIDAS'pg_pathman','invoke_on_partition_created_callback'

LANGUAGE C STRICT;

if NOT tablespace ISNULL THEN

v_create_table_query := v_create_table_query||' TABLESPACE'||tablespace;

END IF;

RAISE NOTICE'query: %', v_create_table_query;

EXECUTE format(v_create_table_query,

v_child_relname,

p_end_value));

PERFORM @extschema@.copy_foreign_keys(parent_relid, v_child_relname::REGCLASS);

PERFORM @extschema@.invoke_on_partition_created_callback(parent_relid,

v_child_relname,

p_start_value,

p_end_value);

RETURN v_child_relname;

END

END

$$ LANGUAGE plpgsql;

INSERT INTO test_fkeyVALUES(1,'wrong');

INSERT INTO test_fkeyVALUES(1,'test');

SELECT drop_partitions('test_fkey');

CREATETABLElog(idserial, messagetext);

CREATE OR REPLACEFUNCTIONabc_on_partition_created_callback(args jsonb)

RETURNS VOIDAS $$

DECLARE

start_valueTEXT := args->>'start';

end_valueTEXT := args::jsonb->'end';

INSERT INTO log(message)

VALUES (start_value||'-'|| end_value);

END

$$ language plpgsql;

CREATETABLEabc(aserial, bint);

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

SELECT set_callback('abc','abc_on_partition_created_callback');

INSERT INTO abcVALUES (123,1);

INSERT INTO abcVALUES (223,1);

SELECT append_range_partition('abc');

SELECT prepend_range_partition('abc');

SELECT add_range_partition('abc',401,501);

SELECT messageFROM log;

#definePATHMAN_CONFIG_PARAMS"pathman_config_params"

#defineAnum_pathman_config_params_partrel1/* primary key */

#defineAnum_pathman_config_params_enable_parent2/* include parent into plan */

#defineAnum_pathman_config_params_auto3/* auto partitions creation */

#defineAnum_pathman_config_params_callback4/* auto partitions creation */

PG_FUNCTION_INFO_V1(prevent_relation_modification );

PG_FUNCTION_INFO_V1(debug_capture );

PG_FUNCTION_INFO_V1(get_rel_tablespace_name );

PG_FUNCTION_INFO_V1(validate_on_partition_created_callback );

PG_FUNCTION_INFO_V1(invoke_on_partition_created_callback );

staticvoidon_partitions_created_internal(Oidpartitioned_table,booladd_callbacks);

staticvoidon_partitions_updated_internal(Oidpartitioned_table,booladd_callbacks);

result=get_tablespace_name(tablespace_id);

PG_RETURN_TEXT_P(cstring_to_text(result));

}

validate_on_partition_created_callback(PG_FUNCTION_ARGS)

{

HeapTupletp;

Oidcallback=PG_GETARG_OID(0);

Form_pg_procfunctup;

tp=SearchSysCache1(PROCOID,ObjectIdGetDatum(callback));

if (!HeapTupleIsValid(tp))

elog(ERROR,"cache lookup failed for function %u",callback);

functup= (Form_pg_proc)GETSTRUCT(tp);

if (functup->pronargs!=1||functup->proargtypes.values[0]!=JSONBOID||

functup->prorettype!=VOIDOID)

elog(ERROR,

"and return VOID");

ReleaseSysCache(tp);

PG_RETURN_VOID();

}

invoke_on_partition_created_callback(PG_FUNCTION_ARGS)

{

char*json;

Datumjsonb;

Oidparent_oid=PG_GETARG_OID(0);

Oidpartition_oid=PG_GETARG_OID(1);

Oidtype=get_fn_expr_argtype(fcinfo->flinfo,2);

Datumstart_value=PG_GETARG_DATUM(2);

Datumend_value=PG_GETARG_DATUM(3);

constPartRelationInfo*prel;

if ((prel=get_pathman_relation_info(parent_oid))==NULL)

elog(ERROR,

"Relation %s isn't partitioned by pg_pathman",

get_rel_name(parent_oid));

if (!prel->callback)

PG_RETURN_VOID();

start_value=convert_to_jsonb(start_value,type);

end_value=convert_to_jsonb(end_value,type);

json=psprintf("{"

"\"value_type\": %u}",

parent_oid,

partition_oid,

prel->parttype,

datum_to_cstring(start_value,JSONBOID),

datum_to_cstring(end_value,JSONBOID),

);

jsonb=OidFunctionCall1(F_JSONB_IN,CStringGetDatum(json));

OidFunctionCall1(prel->callback,JsonbGetDatum(jsonb));

PG_RETURN_JSONB(jsonb);

}

{

prel->enable_parent=param_values[Anum_pathman_config_params_enable_parent-1];

prel->auto_partition=param_values[Anum_pathman_config_params_auto-1];

prel->callback=param_values[Anum_pathman_config_params_callback-1];

}

{

prel->enable_parent= false;

prel->auto_partition= true;

prel->callback=InvalidOid;

}

boolvalid;/* is this entry valid? */

boolenable_parent;/* include parent to the plan */

boolauto_partition;/* auto partition creation */

Oidcallback;/* callback for partition creation */

uint32children_count;

Oid*children;/* Oids of child partitions */