staticdsm_segment*segment=NULL;

{

dsm_handlesegment_handle;

size_tblock_size;

size_tblocks_count;

size_tfirst_free;

}DsmConfig;

staticDsmConfig*dsm_cfg=NULL;

typedefintBlockHeader;

typedefBlockHeader*BlockHeaderPtr;

#defineFREE_BIT 0x80000000

#defineis_free(header) \

((*header) & FREE_BIT)

#defineset_free(header) \

((*header) | FREE_BIT)

#defineset_used(header) \

((*header) & ~FREE_BIT)

#defineget_length(header) \

((*header) & ~FREE_BIT)

#defineset_length(header,length) \

((length) | ((*header) & FREE_BIT))

alloc_dsm_table()

{

boolfound;

table=(Table*)ShmemInitStruct("dsmtable",sizeof(Table),&found);

dsm_cfg=ShmemInitStruct("dsmconfig",sizeof(DsmConfig),&found);

if (!found)

table->segment_handle=0;

{

dsm_cfg->segment_handle=0;

dsm_cfg->block_size=0;

dsm_cfg->blocks_count=INITIAL_BLOCKS_COUNT;

dsm_cfg->first_free=0;

}

}

init_dsm_segment(size_tblock_size)

init_dsm_segment(size_tblocks_count,size_tblock_size)

{

boolret;

dsm_handlehandle;

LWLockAcquire(dsm_init_lock,LW_EXCLUSIVE);

if (table->segment_handle!=0)

if (dsm_cfg->segment_handle!=0)

{

ret= false;

segment=dsm_attach(table->segment_handle);

segment=dsm_attach(dsm_cfg->segment_handle);

}

if (table->segment_handle==0||segment==NULL)

if (dsm_cfg->segment_handle==0||segment==NULL)

{

segment=dsm_create(block_size*BLOCKS_COUNT,0);

handle=dsm_segment_handle(segment);

init_dsm_table(table,handle,block_size);

segment=dsm_create(block_size*blocks_count,0);

dsm_cfg->segment_handle=dsm_segment_handle(segment);

dsm_cfg->first_free=0;

dsm_cfg->block_size=block_size;

dsm_cfg->blocks_count=blocks_count;

init_dsm_table(block_size,0,dsm_cfg->blocks_count);

ret= true;

}

returnret;

}

init_dsm_table(Table*tbl,dsm_handleh,size_tblock_size)

init_dsm_table(size_tblock_size,size_tstart,size_tend)

{

inti;

Block*block;

memset(table,0,sizeof(Table));

table->segment_handle=h;

table->block_size=block_size;

table->first_free=0;

BlockHeaderPtrheader;

char*ptr=dsm_segment_address(segment);

for (i=0;i<BLOCKS_COUNT;i++)

for (i=start;i<end;i++)

{

block=&table->blocks[i];

block->segment=h;

block->offset=i*block_size;

block->is_free= true;

header= (BlockHeaderPtr)&ptr[i*block_size];

*header=set_free(header);

*header=set_length(header,1);

}

return;

alloc_dsm_array(DsmArray*arr,size_tentry_size,size_tlength)

{

inti=0;

Block*block=NULL;

intfree_count=0;

intsize_requested=entry_size*length;

intmin_pos=0;

intmax_pos=0;

for (i=table->first_free;i<BLOCKS_COUNT;i++)

boolfound= false;

boolcollecting_blocks= false;

size_toffset=-1;

size_ttotal_length=0;

BlockHeaderPtrheader;

char*ptr=dsm_segment_address(segment);

for (i=dsm_cfg->first_free;i<dsm_cfg->blocks_count; )

{

if (table->blocks[i].is_free)

header= (BlockHeaderPtr)&ptr[i*dsm_cfg->block_size];

if (is_free(header))

{

if (!block)

if (!collecting_blocks)

{

block=&table->blocks[i];

offset=i*dsm_cfg->block_size;

total_length=dsm_cfg->block_size-sizeof(BlockHeader);

min_pos=i;

collecting_blocks= true;

}

{

total_length+=dsm_cfg->block_size;

}

free_count++;

i++;

}

{

free_count=0;

block=NULL;

collecting_blocks= false;

offset=0;

total_length=0;

i+=get_length(header);

}

if (free_count*table->block_size >=size_requested)

if (total_length >=size_requested)

{

max_pos=i;

max_pos=i-1;

found=true;

break;

}

}

if (!found)

{

size_tnew_blocks_count=dsm_cfg->blocks_count*2;

dsm_resize(segment,new_blocks_count*dsm_cfg->block_size);

init_dsm_table(dsm_cfg->block_size,dsm_cfg->blocks_count,new_blocks_count);

dsm_cfg->blocks_count=new_blocks_count;

returnalloc_dsm_array(arr,entry_size,length);

}

for (i=i+1;i<BLOCKS_COUNT;i++)

if (table->blocks[i].is_free== true)

if (dsm_cfg->first_free==min_pos)

{

for (;i<dsm_cfg->blocks_count; )

{

table->first_free=i;

break;

header= (BlockHeaderPtr)&ptr[i*dsm_cfg->block_size];

if (is_free(header))

{

dsm_cfg->first_free=i;

break;

}

{

i+=get_length(header);

}

}

}

if (free_count*table->block_size >=size_requested)

if (total_length >=size_requested)

{

for(i=min_pos;i<=max_pos;i++)

table->blocks[i].is_free= false;

arr->offset=block->offset;

header= (BlockHeaderPtr)&ptr[min_pos*dsm_cfg->block_size];

*header=set_used(header);

*header=set_length(header,max_pos-min_pos+1);

arr->offset=offset;

arr->length=length;

}

}

free_dsm_array(DsmArray*arr)

{

intstart=arr->offset /table->block_size;

intstart=arr->offset /dsm_cfg->block_size;

inti=0;

char*ptr=dsm_segment_address(segment);

BlockHeaderPtrheader= (BlockHeaderPtr)&ptr[start*dsm_cfg->block_size];

size_tblocks_count=get_length(header);

for(;;i++)

for(;i<blocks_count;i++)

{

table->blocks[start+i].is_free= true;

break;

header= (BlockHeaderPtr)&ptr[(start+i)*dsm_cfg->block_size];

*header=set_length(header,1);

}

if (arr->offset<table->first_free)

table->first_free=arr->offset;

if (start<dsm_cfg->first_free)

dsm_cfg->first_free=start;

arr->offset=0;

arr->length=0;

dsm_array_get_pointer(constDsmArray*arr)

{

return (uint8_t*)dsm_segment_address(segment)+arr->offset;

return (char*)dsm_segment_address(segment)+arr->offset+sizeof(BlockHeader);

}

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

create_hash_partitions

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

(1 row)

CREATE TABLE test.range_rel (

id SERIAL PRIMARY KEY,

dt TIMESTAMP,

txt TEXT);

CREATE INDEX ON test.range_rel (dt);

INSERT INTO test.range_rel (dt, txt)

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

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

NOTICE: sequence "range_rel_seq" does not exist, skipping

create_range_partitions

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

4

(1 row)

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

NOTICE: Copying data to test.range_rel_4 (condition: ((dt >= 'Wed Apr 01 00:00:00 2015'::timestamp without time zone) AND (dt < 'Fri May 01 00:00:00 2015'::timestamp without time zone)))

NOTICE: Copying data to test.range_rel_3 (condition: ((dt >= 'Sun Mar 01 00:00:00 2015'::timestamp without time zone) AND (dt < 'Wed Apr 01 00:00:00 2015'::timestamp without time zone)))

NOTICE: Copying data to test.range_rel_2 (condition: ((dt >= 'Sun Feb 01 00:00:00 2015'::timestamp without time zone) AND (dt < 'Sun Mar 01 00:00:00 2015'::timestamp without time zone)))

NOTICE: Copying data to test.range_rel_1 (condition: ((dt >= 'Thu Jan 01 00:00:00 2015'::timestamp without time zone) AND (dt < 'Sun Feb 01 00:00:00 2015'::timestamp without time zone)))

partition_data

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

0

(1 row)

CREATE TABLE test.num_range_rel (

NOTICE: sequence "num_range_rel_seq" does not exist, skipping

create_range_partitions

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

(1 row)

INSERT INTO test.num_range_rel

SELECT g, md5(g::TEXT) FROM generate_series(1, 3000) as g;

INSERT INTO test.range_rel (dt, txt)

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

INSERT INTO test.hash_rel VALUES (1, 1);

INSERT INTO test.hash_rel VALUES (2, 2);

INSERT INTO test.hash_rel VALUES (3, 3);

NOTICE: function hash_rel_hash_update_trigger_func() does not exist, skipping

create_hash_partitions

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

(1 row)

SELECT partition_data('hash_rel');

NOTICE: sequence "range_rel_seq" does not exist, skipping

create_range_partitions

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

(1 row)

SELECT partition_data('range_rel');

boolnew_segment_created;

initialization_needed= false;

new_segment_created=init_dsm_segment(32);

new_segment_created=init_dsm_segment(INITIAL_BLOCKS_COUNT,32);

LWLockAcquire(load_config_lock,LW_EXCLUSIVE);

load_relations_hashtable(new_segment_created);

{

SPITupleTable*tuptable=SPI_tuptable;

Oid*children;

RangeEntry*ranges=NULL;

RangeEntry*ranges;

Datummin;

Datummax;

inthash;