#include "utils/injection_point.h"

static void ginFinishOldSplit(GinBtree btree, GinBtreeStack *stack,

GinStatsData *buildStats, int access);

ginFinishOldSplit(btree, stack, NULL, access);

ginFinishOldSplit(btree, stack, NULL, access);

ginFinishOldSplit(btree, ptr, NULL, GIN_EXCLUSIVE);

ginFinishOldSplit(btree, ptr, NULL, GIN_EXCLUSIVE);

#ifdef USE_INJECTION_POINTS

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

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

else

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

ginFinishOldSplit(btree, parent, buildStats, GIN_EXCLUSIVE);

ginFinishOldSplit(btree, parent, buildStats, GIN_EXCLUSIVE);

static void

ginFinishOldSplit(GinBtree btree, GinBtreeStack *stack, GinStatsData *buildStats, int access)

{

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

}

ginFinishOldSplit(btree, stack, buildStats, GIN_EXCLUSIVE);

SUBDIRS += injection_points gin

ALWAYS_SUBDIRS += injection_points gin

EXTRA_INSTALL = src/test/modules/injection_points

REGRESS = gin_incomplete_splits

ifdef USE_PGXS

PG_CONFIG = pg_config

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

include $(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)

if not get_option('injection_points')

subdir_done()

tests += {

'name': 'gin',

'sd': meson.current_source_dir(),

'bd': meson.current_build_dir(),

'regress': {

'sql': [

'gin_incomplete_splits',

],

},

}