OBJS= verify_nbtree.o$(WIN32RES)

EXTENSION = amcheck

DATA = amcheck--1.0--1.1.sql amcheck--1.0.sql

DATA = amcheck--1.1--1.2.sql amcheck--1.0--1.1.sql amcheck--1.0.sql

PGFILEDESC = "amcheck - function for verifying relation integrity"

REGRESS = check check_btree

\echo Use"ALTER EXTENSION amcheck UPDATE TO '1.2'" to load this file. \quit

CREATEFUNCTIONbt_index_parent_check(index regclass,

heapallindexedboolean, rootdescendboolean)

RETURNS VOID

AS'MODULE_PATHNAME','bt_index_parent_check'

LANGUAGE C STRICT PARALLEL RESTRICTED;

REVOKE ALLON FUNCTION bt_index_parent_check(regclass,boolean,boolean)FROM PUBLIC;

# amcheck extension

comment = 'functions for verifying relation integrity'

default_version = '1.1'

default_version = '1.2'

module_pathname = '$libdir/amcheck'

relocatable = true

(1 row)

--

-- Test for multilevel page deletion/downlink present checks

-- Test for multilevel page deletion/downlink present checks, and rootdescend

-- checks

--

INSERT INTO delete_test_table SELECT i, 1, 2, 3 FROM generate_series(1,80000) i;

ALTER TABLE delete_test_table ADD PRIMARY KEY (a,b,c,d);

-- root"

DELETE FROM delete_test_table WHERE a < 79990;

VACUUM delete_test_table;

SELECT bt_index_parent_check('delete_test_table_pkey', true);

SELECT bt_index_parent_check('delete_test_table_pkey', true, true);

bt_index_parent_check

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

SELECT bt_index_parent_check('bttest_multi_idx', true);

INSERT INTO delete_test_tableSELECT i,1,2,3FROM generate_series(1,80000) i;

ALTERTABLE delete_test_table ADDPRIMARY KEY (a,b,c,d);

DELETEFROM delete_test_tableWHERE a<79990;

VACUUM delete_test_table;

SELECT bt_index_parent_check('delete_test_table_pkey', true);

SELECT bt_index_parent_check('delete_test_table_pkey', true, true);

boolreadonly;

boolheapallindexed;

boolrootdescend;

MemoryContexttargetcontext;

PG_FUNCTION_INFO_V1(bt_index_parent_check);

staticvoidbt_index_check_internal(Oidindrelid,boolparentcheck,

boolheapallindexed);

boolheapallindexed,boolrootdescend);

staticinlinevoidbtree_index_checkable(Relationrel);

staticvoidbt_check_every_level(Relationrel,Relationheaprel,

boolheapkeyspace,boolreadonly,boolheapallindexed);

boolheapkeyspace,boolreadonly,boolheapallindexed,

boolrootdescend);

staticBtreeLevelbt_check_level_from_leftmost(BtreeCheckState*state,

BtreeLevellevel);

staticvoidbt_target_page_check(BtreeCheckState*state);

booltupleIsAlive,void*checkstate);

staticIndexTuplebt_normalize_tuple(BtreeCheckState*state,

IndexTupleitup);

staticboolbt_rootdescend(BtreeCheckState*state,IndexTupleitup);

staticinlinebooloffset_is_negative_infinity(BTPageOpaqueopaque,

OffsetNumberoffset);

staticinlineboolinvariant_l_offset(BtreeCheckState*state,BTScanInsertkey,

if (PG_NARGS()==2)

heapallindexed=PG_GETARG_BOOL(1);

bt_index_check_internal(indrelid, false,heapallindexed);

bt_index_check_internal(indrelid, false,heapallindexed, false);

PG_RETURN_VOID();

}

{

Oidindrelid=PG_GETARG_OID(0);

boolheapallindexed= false;

boolrootdescend= false;

if (PG_NARGS()==2)

if (PG_NARGS()>=2)

heapallindexed=PG_GETARG_BOOL(1);

if (PG_NARGS()==3)

rootdescend=PG_GETARG_BOOL(2);

bt_index_check_internal(indrelid, true,heapallindexed);

bt_index_check_internal(indrelid, true,heapallindexed,rootdescend);

PG_RETURN_VOID();

}

bt_index_check_internal(Oidindrelid,boolparentcheck,boolheapallindexed)

bt_index_check_internal(Oidindrelid,boolparentcheck,boolheapallindexed,

boolrootdescend)

{

Oidheapid;

Relationindrel;

heapkeyspace=_bt_heapkeyspace(indrel);

bt_check_every_level(indrel,heaprel,heapkeyspace,parentcheck,

heapallindexed);

heapallindexed,rootdescend);

bt_check_every_level(Relationrel,Relationheaprel,boolheapkeyspace,

boolreadonly,boolheapallindexed)

boolreadonly,boolheapallindexed,boolrootdescend)

{

BtreeCheckState*state;

Pagemetapage;

state->heapkeyspace=heapkeyspace;

state->readonly=readonly;

state->heapallindexed=heapallindexed;

state->rootdescend=rootdescend;

if (state->heapallindexed)

{

}

}

Assert(!state->rootdescend||state->readonly);

if (state->rootdescend&& !state->heapkeyspace)

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("cannot verify that tuples from index \"%s\" can each be found by an independent index search",

RelationGetRelationName(rel)),

errhint("Only B-Tree version 4 indexes support rootdescend verification.")));

state->targetcontext=AllocSetContextCreate(CurrentMemoryContext,

"amcheck context",

if (offset_is_negative_infinity(topaque,offset))

continue;

if (state->rootdescend&&P_ISLEAF(topaque)&&

!bt_rootdescend(state,itup))

{

char*itid,

*htid;

itid=psprintf("(%u,%u)",state->targetblock,offset);

htid=psprintf("(%u,%u)",

ItemPointerGetBlockNumber(&(itup->t_tid)),

ItemPointerGetOffsetNumber(&(itup->t_tid)));

ereport(ERROR,

(errcode(ERRCODE_INDEX_CORRUPTED),

errmsg("could not find tuple using search from root page in index \"%s\"",

RelationGetRelationName(state->rel)),

errdetail_internal("Index tid=%s points to heap tid=%s page lsn=%X/%X.",

itid,htid,

(uint32) (state->targetlsn >>32),

(uint32)state->targetlsn)));

}

skey=bt_mkscankey_pivotsearch(state->rel,itup);

if (offset_is_negative_infinity(copaque,offset))

continue;

returnreformed;

}

bt_rootdescend(BtreeCheckState*state,IndexTupleitup)

{

BTScanInsertkey;

BTStackstack;

Bufferlbuf;

boolexists;

key=_bt_mkscankey(state->rel,itup);

Assert(key->heapkeyspace&&key->scantid!=NULL);

Assert(state->readonly&&state->rootdescend);

exists= false;

stack=_bt_search(state->rel,key,&lbuf,BT_READ,NULL);

if (BufferIsValid(lbuf))

{

BTInsertStateDatainsertstate;

OffsetNumberoffnum;

Pagepage;

insertstate.itup=itup;

insertstate.itemsz=MAXALIGN(IndexTupleSize(itup));

insertstate.itup_key=key;

insertstate.bounds_valid= false;

insertstate.buf=lbuf;

offnum=_bt_binsrch_insert(state->rel,&insertstate);

page=BufferGetPage(lbuf);

if (offnum <=PageGetMaxOffsetNumber(page)&&

_bt_compare(state->rel,key,page,offnum)==0)

exists= true;

_bt_relbuf(state->rel,lbuf);

}

_bt_freestack(stack);

pfree(key);

returnexists;

}

<varlistentry>

<term>

<function>bt_index_parent_check(index regclass, heapallindexed boolean) returns void</function>

<function>bt_index_parent_check(index regclass, heapallindexed boolean, rootdescend boolean) returns void</function>

<indexterm>

<primary>bt_index_parent_check</primary>

</indexterm>

argument is <literal>true</literal>, the function verifies the

presence of all heap tuples that should be found within the

index, and that there are no missing downlinks in the index

structure. The checks that can be performed by

structure. When the optional <parameter>rootdescend</parameter>

argument is <literal>true</literal>, verification re-finds

tuples on the leaf level by performing a new search from the

root page for each tuple. The checks that can be performed by

<function>bt_index_parent_check</function> are a superset of the

checks that can be performed by <function>bt_index_check</function>.

<function>bt_index_parent_check</function> can be thought of as