Bufferchildbuf,GinStatsData*buildStats);

staticvoidginFinishSplit(GinBtreebtree,GinBtreeStack*stack,

boolfreestack,GinStatsData*buildStats);

staticvoidginFinishOldSplit(GinBtreebtree,GinBtreeStack*stack,

GinStatsData*buildStats,intaccess);

if (!searchMode&&GinPageIsIncompleteSplit(page))

ginFinishSplit(btree,stack,false,NULL);

ginFinishOldSplit(btree,stack,NULL,access);

page=BufferGetPage(stack->buffer);

if (!searchMode&&GinPageIsIncompleteSplit(page))

ginFinishSplit(btree,stack,false,NULL);

ginFinishOldSplit(btree,stack,NULL,access);

}

if (GinPageIsLeaf(page))/* we found, return locked page */

ginStepRight(Bufferbuffer,Relationindex,intlockmode)

ptr->parent=root;

ptr->off=InvalidOffsetNumber;

ginFinishSplit(btree,ptr,false,NULL);

ginFinishOldSplit(btree,ptr,NULL,GIN_EXCLUSIVE);

}

leftmostBlkno=btree->getLeftMostChild(btree,page);

ptr->parent=root;

ptr->off=InvalidOffsetNumber;

ginFinishSplit(btree,ptr,false,NULL);

ginFinishOldSplit(btree,ptr,NULL,GIN_EXCLUSIVE);

}

}

booldone;

boolfirst= true;

if (!freestack)

elog(DEBUG1,"finishing incomplete split of block %u in gin index \"%s\"",

stack->blkno,RelationGetRelationName(btree->index));

{

GinBtreeStack*parent=stack->parent;

void*insertdata;

BlockNumberupdateblkno;

if (GinPageIsLeaf(BufferGetPage(stack->buffer)))

INJECTION_POINT("gin-leave-leaf-split-incomplete");

INJECTION_POINT("gin-leave-internal-split-incomplete");

LockBuffer(parent->buffer,GIN_EXCLUSIVE);

if (GinPageIsIncompleteSplit(BufferGetPage(parent->buffer)))

ginFinishSplit(btree,parent,false,buildStats);

ginFinishOldSplit(btree,parent,buildStats,GIN_EXCLUSIVE);

page=BufferGetPage(parent->buffer);

page=BufferGetPage(parent->buffer);

if (GinPageIsIncompleteSplit(BufferGetPage(parent->buffer)))

ginFinishSplit(btree,parent,false,buildStats);

ginFinishOldSplit(btree,parent,buildStats,GIN_EXCLUSIVE);

}

freeGinBtreeStack(stack);

}

ginFinishOldSplit(GinBtreebtree,GinBtreeStack*stack,GinStatsData*buildStats,intaccess)

{

INJECTION_POINT("gin-finish-incomplete-split");

elog(DEBUG1,"finishing incomplete split of block %u in gin index \"%s\"",

stack->blkno,RelationGetRelationName(btree->index));

if (access==GIN_SHARE)

{

LockBuffer(stack->buffer,GIN_UNLOCK);

LockBuffer(stack->buffer,GIN_EXCLUSIVE);

if (!GinPageIsIncompleteSplit(BufferGetPage(stack->buffer)))

{

return;

}

}

ginFinishSplit(btree,stack, false,buildStats);

}

if (GinPageIsIncompleteSplit(BufferGetPage(stack->buffer)))

ginFinishSplit(btree,stack,false,buildStats);

ginFinishOldSplit(btree,stack,buildStats,GIN_EXCLUSIVE);

done=ginPlaceToPage(btree,stack,

insertdata,InvalidBlockNumber,

ifeq ($(enable_injection_points),yes)

SUBDIRS += injection_points

SUBDIRS += injection_points gin

ALWAYS_SUBDIRS += injection_points

ALWAYS_SUBDIRS += injection_points gin

ifeq ($(with_ssl),openssl)

EXTRA_INSTALL = src/test/modules/injection_points

REGRESS = gin_incomplete_splits

PG_CONFIG = pg_config

PGXS :=$(shell$(PG_CONFIG) --pgxs)

else

subdir = src/test/modules/gin

top_builddir = ../../../..

include$(top_builddir)/src/Makefile.global

include$(top_srcdir)/contrib/contrib-global.mk

--

-- The test uses a GIN index over int[]. The table contains arrays

-- with integers from 1 to :next_i. Each integer occurs exactly once,

-- no gaps or duplicates, although the index does contain some

-- duplicate elements because some of the inserting transactions are

-- rolled back during the test. The exact contents of the table depend

-- on the physical layout of the index, which in turn depends at least

-- on the block size, so instead of check for the exact contents, we

-- check those invariants. :next_i psql variable is maintained at all

-- times to hold the last inserted integer + 1.

--

-- This uses injection points to cause errors that leave some page

-- splits in "incomplete" state

create extension injection_points;

-- Use the index for all the queries

set enable_seqscan=off;

-- Print a NOTICE whenever an incomplete split gets fixed

SELECT injection_points_attach('gin-finish-incomplete-split', 'notice');

injection_points_attach

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

(1 row)

--

-- First create the test table and some helper functions

--

create table gin_incomplete_splits(i int4[]) with (autovacuum_enabled = off);

create index on gin_incomplete_splits using gin (i) with (fastupdate = off);

-- Creates an array with all integers from $1 (inclusive) $2 (exclusive)

create function range_array(int, int) returns int[] language sql immutable as $$

select array_agg(g) from generate_series($1, $2 - 1) g

$$;

-- Inserts an array with 'n' rows to the test table. Pass :next_i as

-- the first argument, returns the new value for :next_i.

create function insert_n(first_i int, n int) returns int language plpgsql as $$

begin

insert into gin_incomplete_splits values (range_array(first_i, first_i+n));

return first_i + n;

end;

$$;

-- Inserts to the table until an insert fails. Like insert_n(), returns the

-- new value for :next_i.

create function insert_until_fail(next_i int, step int default 1) returns int language plpgsql as $$

declare

i integer;

begin

-- Insert arrays with 'step' elements each, until an error occurs.

loop

begin

select insert_n(next_i, step) into next_i;

exception when others then

raise notice 'failed with: %', sqlerrm;

exit;

end;

-- The caller is expected to set an injection point that eventuall

-- causes an error. But bail out if still no error after 10000

-- attempts, so that we don't get stuck in an infinite loop.

i := i + 1;

if i = 10000 then

raise 'no error on inserts after ';

end if;

end loop;

return next_i;

end;

$$;

-- Check the invariants.

create function verify(next_i int) returns bool language plpgsql as $$

declare

a integer[];

elem integer;

c integer;

begin

-- Perform a scan over the trailing part of the index, where the

-- possible incomplete splits are. (We don't check the whole table,

-- because that'd be pretty slow.)

c := 0;

-- Find all arrays that overlap with the last 200 inserted integers. Or

-- the next 100, which shouldn't exist.

for a in select i from gin_incomplete_splits where i && range_array(next_i - 200, next_i + 100)

loop

-- count all elements in those arrays in the window.

foreach elem in ARRAY a loop

if elem >= next_i then

raise 'unexpected value % in array', elem;

end if;

if elem >= next_i - 200 then

c := c + 1;

end if;

end loop;

end loop;

if c <> 200 then

raise 'unexpected count % ', c;

end if;

return true;

end;

$$;

-- Insert one array to get started.

select insert_n(1, 1000) as next_i

\gset

select verify(:next_i);

verify

--------

t

(1 row)

--

-- Test incomplete leaf split

--

SELECT injection_points_attach('gin-leave-leaf-split-incomplete', 'error');

injection_points_attach

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

(1 row)

select insert_until_fail(:next_i) as next_i

\gset

NOTICE: failed with: error triggered for injection point gin-leave-leaf-split-incomplete

SELECT injection_points_detach('gin-leave-leaf-split-incomplete');

injection_points_detach

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

(1 row)

-- Verify that a scan works even though there's an incomplete split

select verify(:next_i);

verify

--------

t

(1 row)

-- Insert some more rows, finishing the split

select insert_n(:next_i, 10) as next_i

\gset

NOTICE: notice triggered for injection point gin-finish-incomplete-split

-- Verify that a scan still works

select verify(:next_i);

verify

--------

t

(1 row)

--

-- Test incomplete internal page split

--

SELECT injection_points_attach('gin-leave-internal-split-incomplete', 'error');

injection_points_attach

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

(1 row)

select insert_until_fail(:next_i, 100) as next_i

\gset

NOTICE: failed with: error triggered for injection point gin-leave-internal-split-incomplete

SELECT injection_points_detach('gin-leave-internal-split-incomplete');

injection_points_detach

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

(1 row)

-- Verify that a scan works even though there's an incomplete split

select verify(:next_i);

verify

--------

t

(1 row)

-- Insert some more rows, finishing the split

select insert_n(:next_i, 10) as next_i

\gset

NOTICE: notice triggered for injection point gin-finish-incomplete-split

-- Verify that a scan still works

select verify(:next_i);

verify

--------

t

(1 row)

ifnotget_option('injection_points')

subdir_done()

tests+= {

'name':'gin',

'sd':meson.current_source_dir(),

'bd':meson.current_build_dir(),

'regress': {

'sql': [

'gin_incomplete_splits',

],

},

}