#include "access/amapi.h"
#include "access/itup.h"
#include "access/sdir.h"
#include "catalog/pg_am_d.h"
#include "catalog/pg_class.h"
#include "catalog/pg_index.h"
#include "lib/stringinfo.h"
#include "storage/bufmgr.h"
#include "storage/dsm.h"
#include "storage/shm_toc.h"
#include "utils/skipsupport.h"

Include dependency graph for nbtree.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	BTPageOpaqueData

struct	BTMetaPageData

struct	BTDeletedPageData

struct	BTPendingFSM

struct	BTVacState

struct	BTStackData

struct	BTScanInsertData

struct	BTInsertStateData

struct	BTDedupInterval

struct	BTDedupStateData

struct	BTVacuumPostingData

struct	BTScanPosItem

struct	BTScanPosData

struct	BTArrayKeyInfo

struct	BTScanOpaqueData

struct	BTOptions

Macros
#define	BTPageGetOpaque(page) ((BTPageOpaque) PageGetSpecialPointer(page))

#define	BTP_LEAF (1 << 0) /* leaf page, i.e. not internal page */

#define	BTP_ROOT (1 << 1) /* root page (has no parent) */

#define	BTP_DELETED (1 << 2) /* page has been deleted from tree */

#define	BTP_META (1 << 3) /* meta-page */

#define	BTP_HALF_DEAD (1 << 4) /* empty, but still in tree */

#define	BTP_SPLIT_END (1 << 5) /* rightmost page of split group */

#define	BTP_HAS_GARBAGE (1 << 6) /* page has LP_DEAD tuples (deprecated) */

#define	BTP_INCOMPLETE_SPLIT (1 << 7) /* right sibling's downlink is missing */

#define	BTP_HAS_FULLXID (1 << 8) /* contains BTDeletedPageData */

#define	MAX_BT_CYCLE_ID 0xFF7F

#define	BTPageGetMeta(p) ((BTMetaPageData *) PageGetContents(p))

#define	BTREE_METAPAGE 0 /* first page is meta */

#define	BTREE_MAGIC 0x053162 /* magic number in metapage */

#define	BTREE_VERSION 4 /* current version number */

#define	BTREE_MIN_VERSION 2 /* minimum supported version */

#define	BTREE_NOVAC_VERSION 3 /* version with all meta fields set */

#define	BTMaxItemSize

#define	BTMaxItemSizeNoHeapTid

#define	MaxTIDsPerBTreePage

#define	BTREE_MIN_FILLFACTOR 10

#define	BTREE_DEFAULT_FILLFACTOR 90

#define	BTREE_NONLEAF_FILLFACTOR 70

#define	BTREE_SINGLEVAL_FILLFACTOR 96

#define	P_NONE 0

#define	P_LEFTMOST(opaque) ((opaque)->btpo_prev == P_NONE)

#define	P_RIGHTMOST(opaque) ((opaque)->btpo_next == P_NONE)

#define	P_ISLEAF(opaque) (((opaque)->btpo_flags & BTP_LEAF) != 0)

#define	P_ISROOT(opaque) (((opaque)->btpo_flags & BTP_ROOT) != 0)

#define	P_ISDELETED(opaque) (((opaque)->btpo_flags & BTP_DELETED) != 0)

#define	P_ISMETA(opaque) (((opaque)->btpo_flags & BTP_META) != 0)

#define	P_ISHALFDEAD(opaque) (((opaque)->btpo_flags & BTP_HALF_DEAD) != 0)

#define	P_IGNORE(opaque) (((opaque)->btpo_flags & (BTP_DELETED\|BTP_HALF_DEAD)) != 0)

#define	P_HAS_GARBAGE(opaque) (((opaque)->btpo_flags & BTP_HAS_GARBAGE) != 0)

#define	P_INCOMPLETE_SPLIT(opaque) (((opaque)->btpo_flags & BTP_INCOMPLETE_SPLIT) != 0)

#define	P_HAS_FULLXID(opaque) (((opaque)->btpo_flags & BTP_HAS_FULLXID) != 0)

#define	P_HIKEY ((OffsetNumber) 1)

#define	P_FIRSTKEY ((OffsetNumber) 2)

#define	P_FIRSTDATAKEY(opaque) (P_RIGHTMOST(opaque) ? P_HIKEY : P_FIRSTKEY)

#define	INDEX_ALT_TID_MASK INDEX_AM_RESERVED_BIT

#define	BT_OFFSET_MASK 0x0FFF

#define	BT_STATUS_OFFSET_MASK 0xF000

#define	BT_PIVOT_HEAP_TID_ATTR 0x1000

#define	BT_IS_POSTING 0x2000

#define	BTreeTupleGetNAtts(itup, rel)

#define	BTCommuteStrategyNumber(strat) (BTMaxStrategyNumber + 1 - (strat))

#define	BTORDER_PROC 1

#define	BTSORTSUPPORT_PROC 2

#define	BTINRANGE_PROC 3

#define	BTEQUALIMAGE_PROC 4

#define	BTOPTIONS_PROC 5

#define	BTSKIPSUPPORT_PROC 6

#define	BTNProcs 6

#define	BT_READ BUFFER_LOCK_SHARE

#define	BT_WRITE BUFFER_LOCK_EXCLUSIVE

#define	BTScanPosIsPinned(scanpos)

#define	BTScanPosUnpin(scanpos)

#define	BTScanPosUnpinIfPinned(scanpos)

#define	BTScanPosIsValid(scanpos)

#define	BTScanPosInvalidate(scanpos)

#define	SK_BT_REQFWD 0x00010000 /* required to continue forward scan */

#define	SK_BT_REQBKWD 0x00020000 /* required to continue backward scan */

#define	SK_BT_SKIP 0x00040000 /* skip array on column without input = */

#define	SK_BT_MINVAL 0x00080000 /* invalid sk_argument, use low_compare */

#define	SK_BT_MAXVAL 0x00100000 /* invalid sk_argument, use high_compare */

#define	SK_BT_NEXT 0x00200000 /* positions the scan > sk_argument */

#define	SK_BT_PRIOR 0x00400000 /* positions the scan < sk_argument */

#define	SK_BT_INDOPTION_SHIFT 24 /* must clear the above bits */

#define	SK_BT_DESC (INDOPTION_DESC << SK_BT_INDOPTION_SHIFT)

#define	SK_BT_NULLS_FIRST (INDOPTION_NULLS_FIRST << SK_BT_INDOPTION_SHIFT)

#define	BTGetFillFactor(relation)

#define	BTGetTargetPageFreeSpace(relation) (BLCKSZ * (100 - BTGetFillFactor(relation)) / 100)

#define	BTGetDeduplicateItems(relation)

#define	PROGRESS_BTREE_PHASE_INDEXBUILD_TABLESCAN 2

#define	PROGRESS_BTREE_PHASE_PERFORMSORT_1 3

#define	PROGRESS_BTREE_PHASE_PERFORMSORT_2 4

#define	PROGRESS_BTREE_PHASE_LEAF_LOAD 5

Typedefs
typedef uint16	BTCycleId

typedef struct BTPageOpaqueData	BTPageOpaqueData

typedef BTPageOpaqueData *	BTPageOpaque

typedef struct BTMetaPageData	BTMetaPageData

typedef struct BTDeletedPageData	BTDeletedPageData

typedef struct BTPendingFSM	BTPendingFSM

typedef struct BTVacState	BTVacState

typedef struct BTStackData	BTStackData

typedef BTStackData *	BTStack

typedef struct BTScanInsertData	BTScanInsertData

typedef BTScanInsertData *	BTScanInsert

typedef struct BTInsertStateData	BTInsertStateData

typedef BTInsertStateData *	BTInsertState

typedef struct BTDedupInterval	BTDedupInterval

typedef struct BTDedupStateData	BTDedupStateData

typedef BTDedupStateData *	BTDedupState

typedef struct BTVacuumPostingData	BTVacuumPostingData

typedef BTVacuumPostingData *	BTVacuumPosting

typedef struct BTScanPosItem	BTScanPosItem

typedef struct BTScanPosData	BTScanPosData

typedef BTScanPosData *	BTScanPos

typedef struct BTArrayKeyInfo	BTArrayKeyInfo

typedef struct BTScanOpaqueData	BTScanOpaqueData

typedef BTScanOpaqueData *	BTScanOpaque

typedef struct BTOptions	BTOptions

Functions
static void	BTPageSetDeleted (Page page, FullTransactionId safexid)

static FullTransactionId	BTPageGetDeleteXid (Page page)

static bool	BTPageIsRecyclable (Page page, Relation heaprel)

	StaticAssertDecl (BT_OFFSET_MASK >=INDEX_MAX_KEYS, "BT_OFFSET_MASK can't fit INDEX_MAX_KEYS")

static bool	BTreeTupleIsPivot (IndexTuple itup)

static bool	BTreeTupleIsPosting (IndexTuple itup)

static void	BTreeTupleSetPosting (IndexTuple itup, uint16 nhtids, int postingoffset)

static uint16	BTreeTupleGetNPosting (IndexTuple posting)

static uint32	BTreeTupleGetPostingOffset (IndexTuple posting)

static ItemPointer	BTreeTupleGetPosting (IndexTuple posting)

static ItemPointer	BTreeTupleGetPostingN (IndexTuple posting, int n)

static BlockNumber	BTreeTupleGetDownLink (IndexTuple pivot)

static void	BTreeTupleSetDownLink (IndexTuple pivot, BlockNumber blkno)

static void	BTreeTupleSetNAtts (IndexTuple itup, uint16 nkeyatts, bool heaptid)

static BlockNumber	BTreeTupleGetTopParent (IndexTuple leafhikey)

static void	BTreeTupleSetTopParent (IndexTuple leafhikey, BlockNumber blkno)

static ItemPointer	BTreeTupleGetHeapTID (IndexTuple itup)

static ItemPointer	BTreeTupleGetMaxHeapTID (IndexTuple itup)

void	btbuildempty (Relation index)

bool	btinsert (Relation rel, Datum values, bool isnull, ItemPointer ht_ctid, Relation heapRel, IndexUniqueCheck checkUnique, bool indexUnchanged, struct IndexInfo *indexInfo)

IndexScanDesc	btbeginscan (Relation rel, int nkeys, int norderbys)

Size	btestimateparallelscan (Relation rel, int nkeys, int norderbys)

void	btinitparallelscan (void *target)

bool	btgettuple (IndexScanDesc scan, ScanDirection dir)

int64	btgetbitmap (IndexScanDesc scan, TIDBitmap *tbm)

void	btrescan (IndexScanDesc scan, ScanKey scankey, int nscankeys, ScanKey orderbys, int norderbys)

void	btparallelrescan (IndexScanDesc scan)

void	btendscan (IndexScanDesc scan)

void	btmarkpos (IndexScanDesc scan)

void	btrestrpos (IndexScanDesc scan)

IndexBulkDeleteResult *	btbulkdelete (IndexVacuumInfo info, IndexBulkDeleteResult stats, IndexBulkDeleteCallback callback, void *callback_state)

IndexBulkDeleteResult *	btvacuumcleanup (IndexVacuumInfo info, IndexBulkDeleteResult stats)

bool	btcanreturn (Relation index, int attno)

int	btgettreeheight (Relation rel)

CompareType	bttranslatestrategy (StrategyNumber strategy, Oid opfamily)

StrategyNumber	bttranslatecmptype (CompareType cmptype, Oid opfamily)

bool	_bt_parallel_seize (IndexScanDesc scan, BlockNumber next_scan_page, BlockNumber last_curr_page, bool first)

void	_bt_parallel_release (IndexScanDesc scan, BlockNumber next_scan_page, BlockNumber curr_page)

void	_bt_parallel_done (IndexScanDesc scan)

void	_bt_parallel_primscan_schedule (IndexScanDesc scan, BlockNumber curr_page)

void	_bt_dedup_pass (Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz, bool bottomupdedup)

bool	_bt_bottomupdel_pass (Relation rel, Buffer buf, Relation heapRel, Size newitemsz)

void	_bt_dedup_start_pending (BTDedupState state, IndexTuple base, OffsetNumber baseoff)

bool	_bt_dedup_save_htid (BTDedupState state, IndexTuple itup)

Size	_bt_dedup_finish_pending (Page newpage, BTDedupState state)

IndexTuple	_bt_form_posting (IndexTuple base, const ItemPointerData *htids, int nhtids)

void	_bt_update_posting (BTVacuumPosting vacposting)

IndexTuple	_bt_swap_posting (IndexTuple newitem, IndexTuple oposting, int postingoff)

bool	_bt_doinsert (Relation rel, IndexTuple itup, IndexUniqueCheck checkUnique, bool indexUnchanged, Relation heapRel)

void	_bt_finish_split (Relation rel, Relation heaprel, Buffer lbuf, BTStack stack)

Buffer	_bt_getstackbuf (Relation rel, Relation heaprel, BTStack stack, BlockNumber child)

OffsetNumber	_bt_findsplitloc (Relation rel, Page origpage, OffsetNumber newitemoff, Size newitemsz, IndexTuple newitem, bool *newitemonleft)

void	_bt_initmetapage (Page page, BlockNumber rootbknum, uint32 level, bool allequalimage)

bool	_bt_vacuum_needs_cleanup (Relation rel)

void	_bt_set_cleanup_info (Relation rel, BlockNumber num_delpages)

void	_bt_upgrademetapage (Page page)

Buffer	_bt_getroot (Relation rel, Relation heaprel, int access)

Buffer	_bt_gettrueroot (Relation rel)

int	_bt_getrootheight (Relation rel)

void	_bt_metaversion (Relation rel, bool heapkeyspace, bool allequalimage)

void	_bt_checkpage (Relation rel, Buffer buf)

Buffer	_bt_getbuf (Relation rel, BlockNumber blkno, int access)

Buffer	_bt_allocbuf (Relation rel, Relation heaprel)

Buffer	_bt_relandgetbuf (Relation rel, Buffer obuf, BlockNumber blkno, int access)

void	_bt_relbuf (Relation rel, Buffer buf)

void	_bt_lockbuf (Relation rel, Buffer buf, int access)

void	_bt_unlockbuf (Relation rel, Buffer buf)

bool	_bt_conditionallockbuf (Relation rel, Buffer buf)

void	_bt_upgradelockbufcleanup (Relation rel, Buffer buf)

void	_bt_pageinit (Page page, Size size)

void	_bt_delitems_vacuum (Relation rel, Buffer buf, OffsetNumber deletable, int ndeletable, BTVacuumPosting updatable, int nupdatable)

void	_bt_delitems_delete_check (Relation rel, Buffer buf, Relation heapRel, struct TM_IndexDeleteOp *delstate)

void	_bt_pagedel (Relation rel, Buffer leafbuf, BTVacState *vstate)

void	_bt_pendingfsm_init (Relation rel, BTVacState *vstate, bool cleanuponly)

void	_bt_pendingfsm_finalize (Relation rel, BTVacState *vstate)

void	_bt_preprocess_keys (IndexScanDesc scan)

bool	_bt_readpage (IndexScanDesc scan, ScanDirection dir, OffsetNumber offnum, bool firstpage)

void	_bt_start_array_keys (IndexScanDesc scan, ScanDirection dir)

int	_bt_binsrch_array_skey (FmgrInfo orderproc, bool cur_elem_trig, ScanDirection dir, Datum tupdatum, bool tupnull, BTArrayKeyInfo array, ScanKey cur, int32 *set_elem_result)

BTStack	_bt_search (Relation rel, Relation heaprel, BTScanInsert key, Buffer *bufP, int access, bool returnstack)

OffsetNumber	_bt_binsrch_insert (Relation rel, BTInsertState insertstate)

int32	_bt_compare (Relation rel, BTScanInsert key, Page page, OffsetNumber offnum)

bool	_bt_first (IndexScanDesc scan, ScanDirection dir)

bool	_bt_next (IndexScanDesc scan, ScanDirection dir)

Buffer	_bt_get_endpoint (Relation rel, uint32 level, bool rightmost)

BTScanInsert	_bt_mkscankey (Relation rel, IndexTuple itup)

void	_bt_killitems (IndexScanDesc scan)

BTCycleId	_bt_vacuum_cycleid (Relation rel)

BTCycleId	_bt_start_vacuum (Relation rel)

void	_bt_end_vacuum (Relation rel)

void	_bt_end_vacuum_callback (int code, Datum arg)

bytea *	btoptions (Datum reloptions, bool validate)

bool	btproperty (Oid index_oid, int attno, IndexAMProperty prop, const char propname, bool res, bool *isnull)

char *	btbuildphasename (int64 phasenum)

IndexTuple	_bt_truncate (Relation rel, IndexTuple lastleft, IndexTuple firstright, BTScanInsert itup_key)

int	_bt_keep_natts_fast (Relation rel, IndexTuple lastleft, IndexTuple firstright)

bool	_bt_check_natts (Relation rel, bool heapkeyspace, Page page, OffsetNumber offnum)

void	_bt_check_third_page (Relation rel, Relation heap, bool needheaptidspace, Page page, IndexTuple newtup)

bool	_bt_allequalimage (Relation rel, bool debugmessage)

bool	btvalidate (Oid opclassoid)

void	btadjustmembers (Oid opfamilyoid, Oid opclassoid, List operators, List functions)

IndexBuildResult *	btbuild (Relation heap, Relation index, struct IndexInfo *indexInfo)

void	_bt_parallel_build_main (dsm_segment seg, shm_toc toc)

Macro Definition Documentation

◆ BT_IS_POSTING

#define BT_IS_POSTING 0x2000

Definition at line 467 of file nbtree.h.

◆ BT_OFFSET_MASK

#define BT_OFFSET_MASK 0x0FFF

Definition at line 463 of file nbtree.h.

◆ BT_PIVOT_HEAP_TID_ATTR

#define BT_PIVOT_HEAP_TID_ATTR 0x1000

Definition at line 466 of file nbtree.h.

◆ BT_READ

#define BT_READ BUFFER_LOCK_SHARE

Definition at line 730 of file nbtree.h.

◆ BT_STATUS_OFFSET_MASK

#define BT_STATUS_OFFSET_MASK 0xF000

Definition at line 464 of file nbtree.h.

◆ BT_WRITE

#define BT_WRITE BUFFER_LOCK_EXCLUSIVE

Definition at line 731 of file nbtree.h.

◆ BTCommuteStrategyNumber

#define BTCommuteStrategyNumber ( strat ) (BTMaxStrategyNumber + 1 - (strat))

Definition at line 686 of file nbtree.h.

◆ BTEQUALIMAGE_PROC

#define BTEQUALIMAGE_PROC 4

Definition at line 720 of file nbtree.h.

◆ BTGetDeduplicateItems

#define BTGetDeduplicateItems ( relation )

Value:

    (AssertMacro(relation->rd_rel->relkind == RELKIND_INDEX && \
                 relation->rd_rel->relam == BTREE_AM_OID), \
    ((relation)->rd_options ? \
     ((BTOptions *) (relation)->rd_options)->deduplicate_items : true))

Definition at line 1135 of file nbtree.h.

1139 : true))

◆ BTGetFillFactor

#define BTGetFillFactor ( relation )

Value:

    (AssertMacro(relation->rd_rel->relkind == RELKIND_INDEX && \
                 relation->rd_rel->relam == BTREE_AM_OID), \
     (relation)->rd_options ? \
     ((BTOptions *) (relation)->rd_options)->fillfactor : \
     BTREE_DEFAULT_FILLFACTOR)

Definition at line 1127 of file nbtree.h.

1131 : \

1132 BTREE_DEFAULT_FILLFACTOR)

◆ BTGetTargetPageFreeSpace

#define BTGetTargetPageFreeSpace ( relation ) (BLCKSZ * (100 - BTGetFillFactor(relation)) / 100)

Definition at line 1133 of file nbtree.h.

◆ BTINRANGE_PROC

#define BTINRANGE_PROC 3

Definition at line 719 of file nbtree.h.

◆ BTMaxItemSize

#define BTMaxItemSize

Value:

    (MAXALIGN_DOWN((BLCKSZ - \
                    MAXALIGN(SizeOfPageHeaderData + 3*sizeof(ItemIdData)) - \
                    MAXALIGN(sizeof(BTPageOpaqueData))) / 3) - \
					MAXALIGN(sizeof(ItemPointerData)))

Definition at line 165 of file nbtree.h.

◆ BTMaxItemSizeNoHeapTid

#define BTMaxItemSizeNoHeapTid

Value:

    MAXALIGN_DOWN((BLCKSZ - \
                   MAXALIGN(SizeOfPageHeaderData + 3*sizeof(ItemIdData)) - \
                   MAXALIGN(sizeof(BTPageOpaqueData))) / 3)

Definition at line 170 of file nbtree.h.

◆ BTNProcs

#define BTNProcs 6

Definition at line 723 of file nbtree.h.

◆ BTOPTIONS_PROC

#define BTOPTIONS_PROC 5

Definition at line 721 of file nbtree.h.

◆ BTORDER_PROC

#define BTORDER_PROC 1

Definition at line 717 of file nbtree.h.

◆ BTP_DELETED

#define BTP_DELETED (1 << 2) /* page has been deleted from tree */

Definition at line 79 of file nbtree.h.

◆ BTP_HALF_DEAD

#define BTP_HALF_DEAD (1 << 4) /* empty, but still in tree */

Definition at line 81 of file nbtree.h.

◆ BTP_HAS_FULLXID

#define BTP_HAS_FULLXID (1 << 8) /* contains BTDeletedPageData */

Definition at line 85 of file nbtree.h.

◆ BTP_HAS_GARBAGE

#define BTP_HAS_GARBAGE (1 << 6) /* page has LP_DEAD tuples (deprecated) */

Definition at line 83 of file nbtree.h.

◆ BTP_INCOMPLETE_SPLIT

#define BTP_INCOMPLETE_SPLIT (1 << 7) /* right sibling's downlink is missing */

Definition at line 84 of file nbtree.h.

◆ BTP_LEAF

#define BTP_LEAF (1 << 0) /* leaf page, i.e. not internal page */

Definition at line 77 of file nbtree.h.

◆ BTP_META

#define BTP_META (1 << 3) /* meta-page */

Definition at line 80 of file nbtree.h.

◆ BTP_ROOT

#define BTP_ROOT (1 << 1) /* root page (has no parent) */

Definition at line 78 of file nbtree.h.

◆ BTP_SPLIT_END

#define BTP_SPLIT_END (1 << 5) /* rightmost page of split group */

Definition at line 82 of file nbtree.h.

◆ BTPageGetMeta

#define BTPageGetMeta ( p ) ((BTMetaPageData *) PageGetContents(p))

Definition at line 122 of file nbtree.h.

◆ BTPageGetOpaque

#define BTPageGetOpaque ( page ) ((BTPageOpaque) PageGetSpecialPointer(page))

Definition at line 74 of file nbtree.h.

◆ BTREE_DEFAULT_FILLFACTOR

#define BTREE_DEFAULT_FILLFACTOR 90

Definition at line 201 of file nbtree.h.

◆ BTREE_MAGIC

#define BTREE_MAGIC 0x053162 /* magic number in metapage */

Definition at line 150 of file nbtree.h.

◆ BTREE_METAPAGE

#define BTREE_METAPAGE 0 /* first page is meta */

Definition at line 149 of file nbtree.h.

◆ BTREE_MIN_FILLFACTOR

#define BTREE_MIN_FILLFACTOR 10

Definition at line 200 of file nbtree.h.

◆ BTREE_MIN_VERSION

#define BTREE_MIN_VERSION 2 /* minimum supported version */

Definition at line 152 of file nbtree.h.

◆ BTREE_NONLEAF_FILLFACTOR

#define BTREE_NONLEAF_FILLFACTOR 70

Definition at line 202 of file nbtree.h.

◆ BTREE_NOVAC_VERSION

#define BTREE_NOVAC_VERSION 3 /* version with all meta fields set */

Definition at line 153 of file nbtree.h.

◆ BTREE_SINGLEVAL_FILLFACTOR

#define BTREE_SINGLEVAL_FILLFACTOR 96

Definition at line 203 of file nbtree.h.

◆ BTREE_VERSION

#define BTREE_VERSION 4 /* current version number */

Definition at line 151 of file nbtree.h.

◆ BTreeTupleGetNAtts

#define BTreeTupleGetNAtts	(	itup,
		rel
	)

Value:

    ( \
        (BTreeTupleIsPivot(itup)) ? \
        ( \
            ItemPointerGetOffsetNumberNoCheck(&(itup)->t_tid) & BT_OFFSET_MASK \
        ) \
        : \
        IndexRelationGetNumberOfAttributes(rel) \
    )

Definition at line 578 of file nbtree.h.

        : \
		IndexRelationGetNumberOfAttributes(rel) \
    )

◆ BTScanPosInvalidate

#define BTScanPosInvalidate ( scanpos )

Value:

    do { \
        (scanpos).buf = InvalidBuffer; \
        (scanpos).currPage = InvalidBlockNumber; \
    } while (0)

Definition at line 1027 of file nbtree.h.

       { \
        (scanpos).buf = InvalidBuffer; \
        (scanpos).currPage = InvalidBlockNumber; \
    } while (0)

◆ BTScanPosIsPinned

#define BTScanPosIsPinned ( scanpos )

Value:

( \
	AssertMacro(BlockNumberIsValid((scanpos).currPage) || \
                !BufferIsValid((scanpos).buf)), \
	BufferIsValid((scanpos).buf) \
)

Definition at line 1004 of file nbtree.h.

◆ BTScanPosIsValid

#define BTScanPosIsValid ( scanpos )

Value:

( \
	AssertMacro(BlockNumberIsValid((scanpos).currPage) || \
                !BufferIsValid((scanpos).buf)), \
	BlockNumberIsValid((scanpos).currPage) \
)

Definition at line 1021 of file nbtree.h.

◆ BTScanPosUnpin

#define BTScanPosUnpin ( scanpos )

Value:

    do { \
		ReleaseBuffer((scanpos).buf); \
        (scanpos).buf = InvalidBuffer; \
    } while (0)

Definition at line 1010 of file nbtree.h.

       { \
		ReleaseBuffer((scanpos).buf); \
        (scanpos).buf = InvalidBuffer; \
    } while (0)

◆ BTScanPosUnpinIfPinned

#define BTScanPosUnpinIfPinned ( scanpos )

Value:

    do { \
		if (BTScanPosIsPinned(scanpos)) \
			BTScanPosUnpin(scanpos); \
    } while (0)

Definition at line 1015 of file nbtree.h.

       { \
		if (BTScanPosIsPinned(scanpos)) \
			BTScanPosUnpin(scanpos); \
    } while (0)

◆ BTSKIPSUPPORT_PROC

#define BTSKIPSUPPORT_PROC 6

Definition at line 722 of file nbtree.h.

◆ BTSORTSUPPORT_PROC

#define BTSORTSUPPORT_PROC 2

Definition at line 718 of file nbtree.h.

◆ INDEX_ALT_TID_MASK

#define INDEX_ALT_TID_MASK INDEX_AM_RESERVED_BIT

Definition at line 460 of file nbtree.h.

◆ MAX_BT_CYCLE_ID

#define MAX_BT_CYCLE_ID 0xFF7F

Definition at line 94 of file nbtree.h.

◆ MaxTIDsPerBTreePage

#define MaxTIDsPerBTreePage

Value:

(int) ((BLCKSZ - SizeOfPageHeaderData - sizeof(BTPageOpaqueData)) / \

sizeof(ItemPointerData))

Definition at line 186 of file nbtree.h.

◆ P_FIRSTDATAKEY

#define P_FIRSTDATAKEY ( opaque ) (P_RIGHTMOST(opaque) ? P_HIKEY : P_FIRSTKEY)

Definition at line 370 of file nbtree.h.

◆ P_FIRSTKEY

#define P_FIRSTKEY ((OffsetNumber) 2)

Definition at line 369 of file nbtree.h.

◆ P_HAS_FULLXID

#define P_HAS_FULLXID ( opaque ) (((opaque)->btpo_flags & BTP_HAS_FULLXID) != 0)

Definition at line 229 of file nbtree.h.

◆ P_HAS_GARBAGE

#define P_HAS_GARBAGE ( opaque ) (((opaque)->btpo_flags & BTP_HAS_GARBAGE) != 0)

Definition at line 227 of file nbtree.h.

◆ P_HIKEY

#define P_HIKEY ((OffsetNumber) 1)

Definition at line 368 of file nbtree.h.

◆ P_IGNORE

#define P_IGNORE ( opaque ) (((opaque)->btpo_flags & (BTP_DELETED|BTP_HALF_DEAD)) != 0)

Definition at line 226 of file nbtree.h.

◆ P_INCOMPLETE_SPLIT

#define P_INCOMPLETE_SPLIT ( opaque ) (((opaque)->btpo_flags & BTP_INCOMPLETE_SPLIT) != 0)

Definition at line 228 of file nbtree.h.

◆ P_ISDELETED

#define P_ISDELETED ( opaque ) (((opaque)->btpo_flags & BTP_DELETED) != 0)

Definition at line 223 of file nbtree.h.

◆ P_ISHALFDEAD

#define P_ISHALFDEAD ( opaque ) (((opaque)->btpo_flags & BTP_HALF_DEAD) != 0)

Definition at line 225 of file nbtree.h.

◆ P_ISLEAF

#define P_ISLEAF ( opaque ) (((opaque)->btpo_flags & BTP_LEAF) != 0)

Definition at line 221 of file nbtree.h.

◆ P_ISMETA

#define P_ISMETA ( opaque ) (((opaque)->btpo_flags & BTP_META) != 0)

Definition at line 224 of file nbtree.h.

◆ P_ISROOT

#define P_ISROOT ( opaque ) (((opaque)->btpo_flags & BTP_ROOT) != 0)

Definition at line 222 of file nbtree.h.

◆ P_LEFTMOST

#define P_LEFTMOST ( opaque ) ((opaque)->btpo_prev == P_NONE)

Definition at line 219 of file nbtree.h.

◆ P_NONE

#define P_NONE 0

Definition at line 213 of file nbtree.h.

◆ P_RIGHTMOST

#define P_RIGHTMOST ( opaque ) ((opaque)->btpo_next == P_NONE)

Definition at line 220 of file nbtree.h.

◆ PROGRESS_BTREE_PHASE_INDEXBUILD_TABLESCAN

#define PROGRESS_BTREE_PHASE_INDEXBUILD_TABLESCAN 2

Definition at line 1146 of file nbtree.h.

◆ PROGRESS_BTREE_PHASE_LEAF_LOAD

#define PROGRESS_BTREE_PHASE_LEAF_LOAD 5

Definition at line 1149 of file nbtree.h.

◆ PROGRESS_BTREE_PHASE_PERFORMSORT_1

#define PROGRESS_BTREE_PHASE_PERFORMSORT_1 3

Definition at line 1147 of file nbtree.h.

◆ PROGRESS_BTREE_PHASE_PERFORMSORT_2

#define PROGRESS_BTREE_PHASE_PERFORMSORT_2 4

Definition at line 1148 of file nbtree.h.

◆ SK_BT_DESC

#define SK_BT_DESC (INDOPTION_DESC << SK_BT_INDOPTION_SHIFT)

Definition at line 1116 of file nbtree.h.

◆ SK_BT_INDOPTION_SHIFT

#define SK_BT_INDOPTION_SHIFT 24 /* must clear the above bits */

Definition at line 1115 of file nbtree.h.

◆ SK_BT_MAXVAL

#define SK_BT_MAXVAL 0x00100000 /* invalid sk_argument, use high_compare */

Definition at line 1110 of file nbtree.h.

◆ SK_BT_MINVAL

#define SK_BT_MINVAL 0x00080000 /* invalid sk_argument, use low_compare */

Definition at line 1109 of file nbtree.h.

◆ SK_BT_NEXT

#define SK_BT_NEXT 0x00200000 /* positions the scan > sk_argument */

Definition at line 1111 of file nbtree.h.

◆ SK_BT_NULLS_FIRST

#define SK_BT_NULLS_FIRST (INDOPTION_NULLS_FIRST << SK_BT_INDOPTION_SHIFT)

Definition at line 1117 of file nbtree.h.

◆ SK_BT_PRIOR

#define SK_BT_PRIOR 0x00400000 /* positions the scan < sk_argument */

Definition at line 1112 of file nbtree.h.

◆ SK_BT_REQBKWD

#define SK_BT_REQBKWD 0x00020000 /* required to continue backward scan */

Definition at line 1105 of file nbtree.h.

◆ SK_BT_REQFWD

#define SK_BT_REQFWD 0x00010000 /* required to continue forward scan */

Definition at line 1104 of file nbtree.h.

◆ SK_BT_SKIP

#define SK_BT_SKIP 0x00040000 /* skip array on column without input = */

Definition at line 1106 of file nbtree.h.

Typedef Documentation

◆ BTArrayKeyInfo

typedef struct BTArrayKeyInfo BTArrayKeyInfo

◆ BTCycleId

typedef uint16 BTCycleId

Definition at line 30 of file nbtree.h.

◆ BTDedupInterval

typedef struct BTDedupInterval BTDedupInterval

◆ BTDedupState

typedef BTDedupStateData* BTDedupState

Definition at line 904 of file nbtree.h.

◆ BTDedupStateData

typedef struct BTDedupStateData BTDedupStateData

◆ BTDeletedPageData

typedef struct BTDeletedPageData BTDeletedPageData

◆ BTInsertState

typedef BTInsertStateData* BTInsertState

Definition at line 846 of file nbtree.h.

◆ BTInsertStateData

typedef struct BTInsertStateData BTInsertStateData

◆ BTMetaPageData

typedef struct BTMetaPageData BTMetaPageData

◆ BTOptions

typedef struct BTOptions BTOptions

◆ BTPageOpaque

typedef BTPageOpaqueData* BTPageOpaque

Definition at line 72 of file nbtree.h.

◆ BTPageOpaqueData

typedef struct BTPageOpaqueData BTPageOpaqueData

◆ BTPendingFSM

typedef struct BTPendingFSM BTPendingFSM

◆ BTScanInsert

typedef BTScanInsertData* BTScanInsert

Definition at line 807 of file nbtree.h.

◆ BTScanInsertData

typedef struct BTScanInsertData BTScanInsertData

◆ BTScanOpaque

typedef BTScanOpaqueData* BTScanOpaque

Definition at line 1097 of file nbtree.h.

◆ BTScanOpaqueData

typedef struct BTScanOpaqueData BTScanOpaqueData

◆ BTScanPos

typedef BTScanPosData* BTScanPos

Definition at line 1002 of file nbtree.h.

◆ BTScanPosData

typedef struct BTScanPosData BTScanPosData

◆ BTScanPosItem

typedef struct BTScanPosItem BTScanPosItem

◆ BTStack

typedef BTStackData* BTStack

Definition at line 750 of file nbtree.h.

◆ BTStackData

typedef struct BTStackData BTStackData

◆ BTVacState

typedef struct BTVacState BTVacState

◆ BTVacuumPosting

typedef BTVacuumPostingData* BTVacuumPosting

Definition at line 925 of file nbtree.h.

◆ BTVacuumPostingData

typedef struct BTVacuumPostingData BTVacuumPostingData

Function Documentation

◆ _bt_allequalimage()

bool _bt_allequalimage	(	Relation	rel,
		bool	debugmessage
	)

extern

Definition at line 1175 of file nbtutils.c.

{
    bool        allequalimage = true;
 
    /* INCLUDE indexes can never support deduplication */
    if (IndexRelationGetNumberOfAttributes(rel) !=
        IndexRelationGetNumberOfKeyAttributes(rel))
        return false;
 
    for (int i = 0; i < IndexRelationGetNumberOfKeyAttributes(rel); i++)
    {
        Oid         opfamily = rel->rd_opfamily[i];
        Oid         opcintype = rel->rd_opcintype[i];
        Oid         collation = rel->rd_indcollation[i];
        Oid         equalimageproc;
 
        equalimageproc = get_opfamily_proc(opfamily, opcintype, opcintype,
                                           BTEQUALIMAGE_PROC);
 
        /*
         * If there is no BTEQUALIMAGE_PROC then deduplication is assumed to
         * be unsafe.  Otherwise, actually call proc and see what it says.
         */
        if (!OidIsValid(equalimageproc) ||
            !DatumGetBool(OidFunctionCall1Coll(equalimageproc, collation,
                                               ObjectIdGetDatum(opcintype))))
        {
            allequalimage = false;
            break;
        }
    }
 
    if (debugmessage)
    {
        if (allequalimage)
            elog(DEBUG1, "index \"%s\" can safely use deduplication",
                 RelationGetRelationName(rel));
        else
            elog(DEBUG1, "index \"%s\" cannot use deduplication",
                 RelationGetRelationName(rel));
    }
 
    return allequalimage;
}

References BTEQUALIMAGE_PROC, DatumGetBool(), DEBUG1, elog, fb(), get_opfamily_proc(), i, IndexRelationGetNumberOfAttributes, IndexRelationGetNumberOfKeyAttributes, ObjectIdGetDatum(), OidFunctionCall1Coll(), OidIsValid, RelationData::rd_indcollation, RelationData::rd_opcintype, RelationData::rd_opfamily, and RelationGetRelationName.

Referenced by _bt_leafbuild(), bt_index_check_callback(), and btbuildempty().

◆ _bt_allocbuf()

Buffer _bt_allocbuf	(	Relation	rel,
		Relation	heaprel
	)

extern

Definition at line 874 of file nbtpage.c.

{
    Buffer      buf;
    BlockNumber blkno;
    Page        page;
 
    Assert(heaprel != NULL);
 
    /*
     * First see if the FSM knows of any free pages.
     *
     * We can't trust the FSM's report unreservedly; we have to check that the
     * page is still free.  (For example, an already-free page could have been
     * re-used between the time the last VACUUM scanned it and the time the
     * VACUUM made its FSM updates.)
     *
     * In fact, it's worse than that: we can't even assume that it's safe to
     * take a lock on the reported page.  If somebody else has a lock on it,
     * or even worse our own caller does, we could deadlock.  (The own-caller
     * scenario is actually not improbable. Consider an index on a serial or
     * timestamp column.  Nearly all splits will be at the rightmost page, so
     * it's entirely likely that _bt_split will call us while holding a lock
     * on the page most recently acquired from FSM. A VACUUM running
     * concurrently with the previous split could well have placed that page
     * back in FSM.)
     *
     * To get around that, we ask for only a conditional lock on the reported
     * page.  If we fail, then someone else is using the page, and we may
     * reasonably assume it's not free.  (If we happen to be wrong, the worst
     * consequence is the page will be lost to use till the next VACUUM, which
     * is no big problem.)
     */
    for (;;)
    {
        blkno = GetFreeIndexPage(rel);
        if (blkno == InvalidBlockNumber)
            break;
        buf = ReadBuffer(rel, blkno);
        if (_bt_conditionallockbuf(rel, buf))
        {
            page = BufferGetPage(buf);
 
            /*
             * It's possible to find an all-zeroes page in an index.  For
             * example, a backend might successfully extend the relation one
             * page and then crash before it is able to make a WAL entry for
             * adding the page.  If we find a zeroed page then reclaim it
             * immediately.
             */
            if (PageIsNew(page))
            {
                /* Okay to use page.  Initialize and return it. */
                _bt_pageinit(page, BufferGetPageSize(buf));
                return buf;
            }
 
            if (BTPageIsRecyclable(page, heaprel))
            {
                /*
                 * If we are generating WAL for Hot Standby then create a WAL
                 * record that will allow us to conflict with queries running
                 * on standby, in case they have snapshots older than safexid
                 * value
                 */
                if (RelationNeedsWAL(rel) && XLogStandbyInfoActive())
                {
                    xl_btree_reuse_page xlrec_reuse;
 
                    /*
                     * Note that we don't register the buffer with the record,
                     * because this operation doesn't modify the page (that
                     * already happened, back when VACUUM deleted the page).
                     * This record only exists to provide a conflict point for
                     * Hot Standby.  See record REDO routine comments.
                     */
                    xlrec_reuse.locator = rel->rd_locator;
                    xlrec_reuse.block = blkno;
                    xlrec_reuse.snapshotConflictHorizon = BTPageGetDeleteXid(page);
                    xlrec_reuse.isCatalogRel =
                        RelationIsAccessibleInLogicalDecoding(heaprel);
 
                    XLogBeginInsert();
                    XLogRegisterData(&xlrec_reuse, SizeOfBtreeReusePage);
 
                    XLogInsert(RM_BTREE_ID, XLOG_BTREE_REUSE_PAGE);
                }
 
                /* Okay to use page.  Re-initialize and return it. */
                _bt_pageinit(page, BufferGetPageSize(buf));
                return buf;
            }
            elog(DEBUG2, "FSM returned nonrecyclable page");
            _bt_relbuf(rel, buf);
        }
        else
        {
            elog(DEBUG2, "FSM returned nonlockable page");
            /* couldn't get lock, so just drop pin */
            ReleaseBuffer(buf);
        }
    }
 
    /*
     * Extend the relation by one page. Need to use RBM_ZERO_AND_LOCK or we
     * risk a race condition against btvacuumscan --- see comments therein.
     * This forces us to repeat the valgrind request that _bt_lockbuf()
     * otherwise would make, as we can't use _bt_lockbuf() without introducing
     * a race.
     */
    buf = ExtendBufferedRel(BMR_REL(rel), MAIN_FORKNUM, NULL, EB_LOCK_FIRST);
    if (!RelationUsesLocalBuffers(rel))
        VALGRIND_MAKE_MEM_DEFINED(BufferGetPage(buf), BLCKSZ);
 
    /* Initialize the new page before returning it */
    page = BufferGetPage(buf);
    Assert(PageIsNew(page));
    _bt_pageinit(page, BufferGetPageSize(buf));
 
    return buf;
}

References _bt_conditionallockbuf(), _bt_pageinit(), _bt_relbuf(), Assert, BMR_REL, BTPageGetDeleteXid(), BTPageIsRecyclable(), buf, BufferGetPage(), BufferGetPageSize(), DEBUG2, EB_LOCK_FIRST, elog, ExtendBufferedRel(), fb(), GetFreeIndexPage(), InvalidBlockNumber, xl_btree_reuse_page::locator, MAIN_FORKNUM, PageIsNew(), RelationData::rd_locator, ReadBuffer(), RelationIsAccessibleInLogicalDecoding, RelationNeedsWAL, RelationUsesLocalBuffers, ReleaseBuffer(), SizeOfBtreeReusePage, VALGRIND_MAKE_MEM_DEFINED, XLOG_BTREE_REUSE_PAGE, XLogBeginInsert(), XLogInsert(), XLogRegisterData(), and XLogStandbyInfoActive.

Referenced by _bt_getroot(), _bt_newlevel(), and _bt_split().

◆ _bt_binsrch_array_skey()

int _bt_binsrch_array_skey	(	FmgrInfo *	orderproc,
		bool	cur_elem_trig,
		ScanDirection	dir,
		Datum	tupdatum,
		bool	tupnull,
		BTArrayKeyInfo *	array,
		ScanKey	cur,
		int32 *	set_elem_result
	)

extern

Definition at line 3415 of file nbtreadpage.c.

{
    int         low_elem = 0,
                mid_elem = -1,
                high_elem = array->num_elems - 1,
                result = 0;
    Datum       arrdatum;
 
    Assert(cur->sk_flags & SK_SEARCHARRAY);
    Assert(!(cur->sk_flags & SK_BT_SKIP));
    Assert(!(cur->sk_flags & SK_ISNULL));   /* SAOP arrays never have NULLs */
    Assert(cur->sk_strategy == BTEqualStrategyNumber);
 
    if (cur_elem_trig)
    {
        Assert(!ScanDirectionIsNoMovement(dir));
        Assert(cur->sk_flags & SK_BT_REQFWD);
 
        /*
         * When the scan key that triggered array advancement is a required
         * array scan key, it is now certain that the current array element
         * (plus all prior elements relative to the current scan direction)
         * cannot possibly be at or ahead of the corresponding tuple value.
         * (_bt_checkkeys must have called _bt_tuple_before_array_skeys, which
         * makes sure this is true as a condition of advancing the arrays.)
         *
         * This makes it safe to exclude array elements up to and including
         * the former-current array element from our search.
         *
         * Separately, when array advancement was triggered by a required scan
         * key, the array element immediately after the former-current element
         * is often either an exact tupdatum match, or a "close by" near-match
         * (a near-match tupdatum is one whose key space falls _between_ the
         * former-current and new-current array elements).  We'll detect both
         * cases via an optimistic comparison of the new search lower bound
         * (or new search upper bound in the case of backwards scans).
         */
        if (ScanDirectionIsForward(dir))
        {
            low_elem = array->cur_elem + 1; /* old cur_elem exhausted */
 
            /* Compare prospective new cur_elem (also the new lower bound) */
            if (high_elem >= low_elem)
            {
                arrdatum = array->elem_values[low_elem];
                result = _bt_compare_array_skey(orderproc, tupdatum, tupnull,
                                                arrdatum, cur);
 
                if (result <= 0)
                {
                    /* Optimistic comparison optimization worked out */
                    *set_elem_result = result;
                    return low_elem;
                }
                mid_elem = low_elem;
                low_elem++;     /* this cur_elem exhausted, too */
            }
 
            if (high_elem < low_elem)
            {
                /* Caller needs to perform "beyond end" array advancement */
                *set_elem_result = 1;
                return high_elem;
            }
        }
        else
        {
            high_elem = array->cur_elem - 1;    /* old cur_elem exhausted */
 
            /* Compare prospective new cur_elem (also the new upper bound) */
            if (high_elem >= low_elem)
            {
                arrdatum = array->elem_values[high_elem];
                result = _bt_compare_array_skey(orderproc, tupdatum, tupnull,
                                                arrdatum, cur);
 
                if (result >= 0)
                {
                    /* Optimistic comparison optimization worked out */
                    *set_elem_result = result;
                    return high_elem;
                }
                mid_elem = high_elem;
                high_elem--;    /* this cur_elem exhausted, too */
            }
 
            if (high_elem < low_elem)
            {
                /* Caller needs to perform "beyond end" array advancement */
                *set_elem_result = -1;
                return low_elem;
            }
        }
    }
 
    while (high_elem > low_elem)
    {
        mid_elem = low_elem + ((high_elem - low_elem) / 2);
        arrdatum = array->elem_values[mid_elem];
 
        result = _bt_compare_array_skey(orderproc, tupdatum, tupnull,
                                        arrdatum, cur);
 
        if (result == 0)
        {
            /*
             * It's safe to quit as soon as we see an equal array element.
             * This often saves an extra comparison or two...
             */
            low_elem = mid_elem;
            break;
        }
 
        if (result > 0)
            low_elem = mid_elem + 1;
        else
            high_elem = mid_elem;
    }
 
    /*
     * ...but our caller also cares about how its searched-for tuple datum
     * compares to the low_elem datum.  Must always set *set_elem_result with
     * the result of that comparison specifically.
     */
    if (low_elem != mid_elem)
        result = _bt_compare_array_skey(orderproc, tupdatum, tupnull,
                                        array->elem_values[low_elem], cur);
 
    *set_elem_result = result;
 
    return low_elem;
}

References _bt_compare_array_skey(), Assert, BTEqualStrategyNumber, cur, BTArrayKeyInfo::cur_elem, BTArrayKeyInfo::elem_values, fb(), BTArrayKeyInfo::num_elems, result, ScanDirectionIsForward, ScanDirectionIsNoMovement, SK_BT_REQFWD, SK_BT_SKIP, SK_ISNULL, and SK_SEARCHARRAY.

Referenced by _bt_advance_array_keys(), _bt_saoparray_shrink(), and _bt_set_startikey().

◆ _bt_binsrch_insert()

OffsetNumber _bt_binsrch_insert	(	Relation	rel,
		BTInsertState	insertstate
	)

extern

Definition at line 475 of file nbtsearch.c.

{
    BTScanInsert key = insertstate->itup_key;
    Page        page;
    BTPageOpaque opaque;
    OffsetNumber low,
                high,
                stricthigh;
    int32       result,
                cmpval;
 
    page = BufferGetPage(insertstate->buf);
    opaque = BTPageGetOpaque(page);
 
    Assert(P_ISLEAF(opaque));
    Assert(!key->nextkey);
    Assert(insertstate->postingoff == 0);
 
    if (!insertstate->bounds_valid)
    {
        /* Start new binary search */
        low = P_FIRSTDATAKEY(opaque);
        high = PageGetMaxOffsetNumber(page);
    }
    else
    {
        /* Restore result of previous binary search against same page */
        low = insertstate->low;
        high = insertstate->stricthigh;
    }
 
    /* If there are no keys on the page, return the first available slot */
    if (unlikely(high < low))
    {
        /* Caller can't reuse bounds */
        insertstate->low = InvalidOffsetNumber;
        insertstate->stricthigh = InvalidOffsetNumber;
        insertstate->bounds_valid = false;
        return low;
    }
 
    /*
     * Binary search to find the first key on the page >= scan key. (nextkey
     * is always false when inserting).
     *
     * The loop invariant is: all slots before 'low' are < scan key, all slots
     * at or after 'high' are >= scan key.  'stricthigh' is > scan key, and is
     * maintained to save additional search effort for caller.
     *
     * We can fall out when high == low.
     */
    if (!insertstate->bounds_valid)
        high++;                 /* establish the loop invariant for high */
    stricthigh = high;          /* high initially strictly higher */
 
    cmpval = 1;                 /* !nextkey comparison value */
 
    while (high > low)
    {
        OffsetNumber mid = low + ((high - low) / 2);
 
        /* We have low <= mid < high, so mid points at a real slot */
 
        result = _bt_compare(rel, key, page, mid);
 
        if (result >= cmpval)
            low = mid + 1;
        else
        {
            high = mid;
            if (result != 0)
                stricthigh = high;
        }
 
        /*
         * If tuple at offset located by binary search is a posting list whose
         * TID range overlaps with caller's scantid, perform posting list
         * binary search to set postingoff for caller.  Caller must split the
         * posting list when postingoff is set.  This should happen
         * infrequently.
         */
        if (unlikely(result == 0 && key->scantid != NULL))
        {
            /*
             * postingoff should never be set more than once per leaf page
             * binary search.  That would mean that there are duplicate table
             * TIDs in the index, which is never okay.  Check for that here.
             */
            if (insertstate->postingoff != 0)
                ereport(ERROR,
                        (errcode(ERRCODE_INDEX_CORRUPTED),
                         errmsg_internal("table tid from new index tuple (%u,%u) cannot find insert offset between offsets %u and %u of block %u in index \"%s\"",
                                         ItemPointerGetBlockNumber(key->scantid),
                                         ItemPointerGetOffsetNumber(key->scantid),
                                         low, stricthigh,
                                         BufferGetBlockNumber(insertstate->buf),
                                         RelationGetRelationName(rel))));
 
            insertstate->postingoff = _bt_binsrch_posting(key, page, mid);
        }
    }
 
    /*
     * On a leaf page, a binary search always returns the first key >= scan
     * key (at least in !nextkey case), which could be the last slot + 1. This
     * is also the lower bound of cached search.
     *
     * stricthigh may also be the last slot + 1, which prevents caller from
     * using bounds directly, but is still useful to us if we're called a
     * second time with cached bounds (cached low will be < stricthigh when
     * that happens).
     */
    insertstate->low = low;
    insertstate->stricthigh = stricthigh;
    insertstate->bounds_valid = true;
 
    return low;
}

References _bt_binsrch_posting(), _bt_compare(), Assert, BTPageGetOpaque, BufferGetBlockNumber(), BufferGetPage(), ereport, errcode(), errmsg_internal(), ERROR, fb(), InvalidOffsetNumber, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), P_FIRSTDATAKEY, P_ISLEAF, PageGetMaxOffsetNumber(), RelationGetRelationName, result, and unlikely.

Referenced by _bt_check_unique(), _bt_findinsertloc(), and bt_rootdescend().

◆ _bt_bottomupdel_pass()

bool _bt_bottomupdel_pass	(	Relation	rel,
		Buffer	buf,
		Relation	heapRel,
		Size	newitemsz
	)

extern

Definition at line 309 of file nbtdedup.c.

{
    OffsetNumber offnum,
                minoff,
                maxoff;
    Page        page = BufferGetPage(buf);
    BTPageOpaque opaque = BTPageGetOpaque(page);
    BTDedupState state;
    TM_IndexDeleteOp delstate;
    bool        neverdedup;
    int         nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
 
    /* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
    newitemsz += sizeof(ItemIdData);
 
    /* Initialize deduplication state */
    state = palloc_object(BTDedupStateData);
    state->deduplicate = true;
    state->nmaxitems = 0;
    state->maxpostingsize = BLCKSZ; /* We're not really deduplicating */
    state->base = NULL;
    state->baseoff = InvalidOffsetNumber;
    state->basetupsize = 0;
    state->htids = palloc(state->maxpostingsize);
    state->nhtids = 0;
    state->nitems = 0;
    state->phystupsize = 0;
    state->nintervals = 0;
 
    /*
     * Initialize tableam state that describes bottom-up index deletion
     * operation.
     *
     * We'll go on to ask the tableam to search for TIDs whose index tuples we
     * can safely delete.  The tableam will search until our leaf page space
     * target is satisfied, or until the cost of continuing with the tableam
     * operation seems too high.  It focuses its efforts on TIDs associated
     * with duplicate index tuples that we mark "promising".
     *
     * This space target is a little arbitrary.  The tableam must be able to
     * keep the costs and benefits in balance.  We provide the tableam with
     * exhaustive information about what might work, without directly
     * concerning ourselves with avoiding work during the tableam call.  Our
     * role in costing the bottom-up deletion process is strictly advisory.
     */
    delstate.irel = rel;
    delstate.iblknum = BufferGetBlockNumber(buf);
    delstate.bottomup = true;
    delstate.bottomupfreespace = Max(BLCKSZ / 16, newitemsz);
    delstate.ndeltids = 0;
    delstate.deltids = palloc_array(TM_IndexDelete, MaxTIDsPerBTreePage);
    delstate.status = palloc_array(TM_IndexStatus, MaxTIDsPerBTreePage);
 
    minoff = P_FIRSTDATAKEY(opaque);
    maxoff = PageGetMaxOffsetNumber(page);
    for (offnum = minoff;
         offnum <= maxoff;
         offnum = OffsetNumberNext(offnum))
    {
        ItemId      itemid = PageGetItemId(page, offnum);
        IndexTuple  itup = (IndexTuple) PageGetItem(page, itemid);
 
        Assert(!ItemIdIsDead(itemid));
 
        if (offnum == minoff)
        {
            /* itup starts first pending interval */
            _bt_dedup_start_pending(state, itup, offnum);
        }
        else if (_bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
                 _bt_dedup_save_htid(state, itup))
        {
            /* Tuple is equal; just added its TIDs to pending interval */
        }
        else
        {
            /* Finalize interval -- move its TIDs to delete state */
            _bt_bottomupdel_finish_pending(page, state, &delstate);
 
            /* itup starts new pending interval */
            _bt_dedup_start_pending(state, itup, offnum);
        }
    }
    /* Finalize final interval -- move its TIDs to delete state */
    _bt_bottomupdel_finish_pending(page, state, &delstate);
 
    /*
     * We don't give up now in the event of having few (or even zero)
     * promising tuples for the tableam because it's not up to us as the index
     * AM to manage costs (note that the tableam might have heuristics of its
     * own that work out what to do).  We should at least avoid having our
     * caller do a useless deduplication pass after we return in the event of
     * zero promising tuples, though.
     */
    neverdedup = false;
    if (state->nintervals == 0)
        neverdedup = true;
 
    pfree(state->htids);
    pfree(state);
 
    /* Ask tableam which TIDs are deletable, then physically delete them */
    _bt_delitems_delete_check(rel, buf, heapRel, &delstate);
 
    pfree(delstate.deltids);
    pfree(delstate.status);
 
    /* Report "success" to caller unconditionally to avoid deduplication */
    if (neverdedup)
        return true;
 
    /* Don't dedup when we won't end up back here any time soon anyway */
    return PageGetExactFreeSpace(page) >= Max(BLCKSZ / 24, newitemsz);
}

References _bt_bottomupdel_finish_pending(), _bt_dedup_save_htid(), _bt_dedup_start_pending(), _bt_delitems_delete_check(), _bt_keep_natts_fast(), Assert, BTPageGetOpaque, buf, BufferGetBlockNumber(), BufferGetPage(), fb(), IndexRelationGetNumberOfKeyAttributes, InvalidOffsetNumber, ItemIdIsDead, Max, MaxTIDsPerBTreePage, OffsetNumberNext, P_FIRSTDATAKEY, PageGetExactFreeSpace(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), palloc(), palloc_array, palloc_object, and pfree().

Referenced by _bt_delete_or_dedup_one_page().

◆ _bt_check_natts()

bool _bt_check_natts	(	Relation	rel,
		bool	heapkeyspace,
		Page	page,
		OffsetNumber	offnum
	)

extern

Definition at line 958 of file nbtutils.c.

{
    int16       natts = IndexRelationGetNumberOfAttributes(rel);
    int16       nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
    BTPageOpaque opaque = BTPageGetOpaque(page);
    IndexTuple  itup;
    int         tupnatts;
 
    /*
     * We cannot reliably test a deleted or half-dead page, since they have
     * dummy high keys
     */
    if (P_IGNORE(opaque))
        return true;
 
    Assert(offnum >= FirstOffsetNumber &&
           offnum <= PageGetMaxOffsetNumber(page));
 
    itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
    tupnatts = BTreeTupleGetNAtts(itup, rel);
 
    /* !heapkeyspace indexes do not support deduplication */
    if (!heapkeyspace && BTreeTupleIsPosting(itup))
        return false;
 
    /* Posting list tuples should never have "pivot heap TID" bit set */
    if (BTreeTupleIsPosting(itup) &&
        (ItemPointerGetOffsetNumberNoCheck(&itup->t_tid) &
         BT_PIVOT_HEAP_TID_ATTR) != 0)
        return false;
 
    /* INCLUDE indexes do not support deduplication */
    if (natts != nkeyatts && BTreeTupleIsPosting(itup))
        return false;
 
    if (P_ISLEAF(opaque))
    {
        if (offnum >= P_FIRSTDATAKEY(opaque))
        {
            /*
             * Non-pivot tuple should never be explicitly marked as a pivot
             * tuple
             */
            if (BTreeTupleIsPivot(itup))
                return false;
 
            /*
             * Leaf tuples that are not the page high key (non-pivot tuples)
             * should never be truncated.  (Note that tupnatts must have been
             * inferred, even with a posting list tuple, because only pivot
             * tuples store tupnatts directly.)
             */
            return tupnatts == natts;
        }
        else
        {
            /*
             * Rightmost page doesn't contain a page high key, so tuple was
             * checked above as ordinary leaf tuple
             */
            Assert(!P_RIGHTMOST(opaque));
 
            /*
             * !heapkeyspace high key tuple contains only key attributes. Note
             * that tupnatts will only have been explicitly represented in
             * !heapkeyspace indexes that happen to have non-key attributes.
             */
            if (!heapkeyspace)
                return tupnatts == nkeyatts;
 
            /* Use generic heapkeyspace pivot tuple handling */
        }
    }
    else                        /* !P_ISLEAF(opaque) */
    {
        if (offnum == P_FIRSTDATAKEY(opaque))
        {
            /*
             * The first tuple on any internal page (possibly the first after
             * its high key) is its negative infinity tuple.  Negative
             * infinity tuples are always truncated to zero attributes.  They
             * are a particular kind of pivot tuple.
             */
            if (heapkeyspace)
                return tupnatts == 0;
 
            /*
             * The number of attributes won't be explicitly represented if the
             * negative infinity tuple was generated during a page split that
             * occurred with a version of Postgres before v11.  There must be
             * a problem when there is an explicit representation that is
             * non-zero, or when there is no explicit representation and the
             * tuple is evidently not a pre-pg_upgrade tuple.
             *
             * Prior to v11, downlinks always had P_HIKEY as their offset.
             * Accept that as an alternative indication of a valid
             * !heapkeyspace negative infinity tuple.
             */
            return tupnatts == 0 ||
                ItemPointerGetOffsetNumber(&(itup->t_tid)) == P_HIKEY;
        }
        else
        {
            /*
             * !heapkeyspace downlink tuple with separator key contains only
             * key attributes.  Note that tupnatts will only have been
             * explicitly represented in !heapkeyspace indexes that happen to
             * have non-key attributes.
             */
            if (!heapkeyspace)
                return tupnatts == nkeyatts;
 
            /* Use generic heapkeyspace pivot tuple handling */
        }
    }
 
    /* Handle heapkeyspace pivot tuples (excluding minus infinity items) */
    Assert(heapkeyspace);
 
    /*
     * Explicit representation of the number of attributes is mandatory with
     * heapkeyspace index pivot tuples, regardless of whether or not there are
     * non-key attributes.
     */
    if (!BTreeTupleIsPivot(itup))
        return false;
 
    /* Pivot tuple should not use posting list representation (redundant) */
    if (BTreeTupleIsPosting(itup))
        return false;
 
    /*
     * Heap TID is a tiebreaker key attribute, so it cannot be untruncated
     * when any other key attribute is truncated
     */
    if (BTreeTupleGetHeapTID(itup) != NULL && tupnatts != nkeyatts)
        return false;
 
    /*
     * Pivot tuple must have at least one untruncated key attribute (minus
     * infinity pivot tuples are the only exception).  Pivot tuples can never
     * represent that there is a value present for a key attribute that
     * exceeds pg_index.indnkeyatts for the index.
     */
    return tupnatts > 0 && tupnatts <= nkeyatts;
}

References Assert, BT_PIVOT_HEAP_TID_ATTR, BTPageGetOpaque, BTreeTupleGetHeapTID(), BTreeTupleGetNAtts, BTreeTupleIsPivot(), BTreeTupleIsPosting(), fb(), FirstOffsetNumber, IndexRelationGetNumberOfAttributes, IndexRelationGetNumberOfKeyAttributes, ItemPointerGetOffsetNumber(), ItemPointerGetOffsetNumberNoCheck(), P_FIRSTDATAKEY, P_HIKEY, P_IGNORE, P_ISLEAF, P_RIGHTMOST, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), and IndexTupleData::t_tid.

Referenced by _bt_compare(), and bt_target_page_check().

◆ _bt_check_third_page()

void _bt_check_third_page	(	Relation	rel,
		Relation	heap,
		bool	needheaptidspace,
		Page	page,
		IndexTuple	newtup
	)

extern

Definition at line 1118 of file nbtutils.c.

{
    Size        itemsz;
    BTPageOpaque opaque;
 
    itemsz = MAXALIGN(IndexTupleSize(newtup));
 
    /* Double check item size against limit */
    if (itemsz <= BTMaxItemSize)
        return;
 
    /*
     * Tuple is probably too large to fit on page, but it's possible that the
     * index uses version 2 or version 3, or that page is an internal page, in
     * which case a slightly higher limit applies.
     */
    if (!needheaptidspace && itemsz <= BTMaxItemSizeNoHeapTid)
        return;
 
    /*
     * Internal page insertions cannot fail here, because that would mean that
     * an earlier leaf level insertion that should have failed didn't
     */
    opaque = BTPageGetOpaque(page);
    if (!P_ISLEAF(opaque))
        elog(ERROR, "cannot insert oversized tuple of size %zu on internal page of index \"%s\"",
             itemsz, RelationGetRelationName(rel));
 
    ereport(ERROR,
            (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
             errmsg("index row size %zu exceeds btree version %u maximum %zu for index \"%s\"",
                    itemsz,
                    needheaptidspace ? BTREE_VERSION : BTREE_NOVAC_VERSION,
                    needheaptidspace ? BTMaxItemSize : BTMaxItemSizeNoHeapTid,
                    RelationGetRelationName(rel)),
             errdetail("Index row references tuple (%u,%u) in relation \"%s\".",
                       ItemPointerGetBlockNumber(BTreeTupleGetHeapTID(newtup)),
                       ItemPointerGetOffsetNumber(BTreeTupleGetHeapTID(newtup)),
                       RelationGetRelationName(heap)),
             errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
                     "Consider a function index of an MD5 hash of the value, "
                     "or use full text indexing."),
             errtableconstraint(heap, RelationGetRelationName(rel))));
}

References BTMaxItemSize, BTMaxItemSizeNoHeapTid, BTPageGetOpaque, BTREE_NOVAC_VERSION, BTREE_VERSION, BTreeTupleGetHeapTID(), elog, ereport, errcode(), errdetail(), errhint(), errmsg, ERROR, errtableconstraint(), fb(), IndexTupleSize(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), MAXALIGN, P_ISLEAF, and RelationGetRelationName.

Referenced by _bt_buildadd(), and _bt_findinsertloc().

◆ _bt_checkpage()

void _bt_checkpage	(	Relation	rel,
		Buffer	buf
	)

extern

Definition at line 802 of file nbtpage.c.

{
    Page        page = BufferGetPage(buf);
 
    /*
     * ReadBuffer verifies that every newly-read page passes
     * PageHeaderIsValid, which means it either contains a reasonably sane
     * page header or is all-zero.  We have to defend against the all-zero
     * case, however.
     */
    if (PageIsNew(page))
        ereport(ERROR,
                (errcode(ERRCODE_INDEX_CORRUPTED),
                 errmsg("index \"%s\" contains unexpected zero page at block %u",
                        RelationGetRelationName(rel),
                        BufferGetBlockNumber(buf)),
                 errhint("Please REINDEX it.")));
 
    /*
     * Additionally check that the special area looks sane.
     */
    if (PageGetSpecialSize(page) != MAXALIGN(sizeof(BTPageOpaqueData)))
        ereport(ERROR,
                (errcode(ERRCODE_INDEX_CORRUPTED),
                 errmsg("index \"%s\" contains corrupted page at block %u",
                        RelationGetRelationName(rel),
                        BufferGetBlockNumber(buf)),
                 errhint("Please REINDEX it.")));
}

References buf, BufferGetBlockNumber(), BufferGetPage(), ereport, errcode(), errhint(), errmsg, ERROR, fb(), MAXALIGN, PageGetSpecialSize(), PageIsNew(), and RelationGetRelationName.

Referenced by _bt_getbuf(), _bt_relandgetbuf(), _bt_search_insert(), bt_recheck_sibling_links(), btvacuumpage(), and palloc_btree_page().

◆ _bt_compare()

int32 _bt_compare	(	Relation	rel,
		BTScanInsert	key,
		Page	page,
		OffsetNumber	offnum
	)

extern

Definition at line 689 of file nbtsearch.c.

{
    TupleDesc   itupdesc = RelationGetDescr(rel);
    BTPageOpaque opaque = BTPageGetOpaque(page);
    IndexTuple  itup;
    ItemPointer heapTid;
    ScanKey     scankey;
    int         ncmpkey;
    int         ntupatts;
    int32       result;
 
    Assert(_bt_check_natts(rel, key->heapkeyspace, page, offnum));
    Assert(key->keysz <= IndexRelationGetNumberOfKeyAttributes(rel));
    Assert(key->heapkeyspace || key->scantid == NULL);
 
    /*
     * Force result ">" if target item is first data item on an internal page
     * --- see NOTE above.
     */
    if (!P_ISLEAF(opaque) && offnum == P_FIRSTDATAKEY(opaque))
        return 1;
 
    itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
    ntupatts = BTreeTupleGetNAtts(itup, rel);
 
    /*
     * The scan key is set up with the attribute number associated with each
     * term in the key.  It is important that, if the index is multi-key, the
     * scan contain the first k key attributes, and that they be in order.  If
     * you think about how multi-key ordering works, you'll understand why
     * this is.
     *
     * We don't test for violation of this condition here, however.  The
     * initial setup for the index scan had better have gotten it right (see
     * _bt_first).
     */
 
    ncmpkey = Min(ntupatts, key->keysz);
    Assert(key->heapkeyspace || ncmpkey == key->keysz);
    Assert(!BTreeTupleIsPosting(itup) || key->allequalimage);
    scankey = key->scankeys;
    for (int i = 1; i <= ncmpkey; i++)
    {
        Datum       datum;
        bool        isNull;
 
        datum = index_getattr(itup, scankey->sk_attno, itupdesc, &isNull);
 
        if (scankey->sk_flags & SK_ISNULL)  /* key is NULL */
        {
            if (isNull)
                result = 0;     /* NULL "=" NULL */
            else if (scankey->sk_flags & SK_BT_NULLS_FIRST)
                result = -1;    /* NULL "<" NOT_NULL */
            else
                result = 1;     /* NULL ">" NOT_NULL */
        }
        else if (isNull)        /* key is NOT_NULL and item is NULL */
        {
            if (scankey->sk_flags & SK_BT_NULLS_FIRST)
                result = 1;     /* NOT_NULL ">" NULL */
            else
                result = -1;    /* NOT_NULL "<" NULL */
        }
        else
        {
            /*
             * The sk_func needs to be passed the index value as left arg and
             * the sk_argument as right arg (they might be of different
             * types).  Since it is convenient for callers to think of
             * _bt_compare as comparing the scankey to the index item, we have
             * to flip the sign of the comparison result.  (Unless it's a DESC
             * column, in which case we *don't* flip the sign.)
             */
            result = DatumGetInt32(FunctionCall2Coll(&scankey->sk_func,
                                                     scankey->sk_collation,
                                                     datum,
                                                     scankey->sk_argument));
 
            if (!(scankey->sk_flags & SK_BT_DESC))
                INVERT_COMPARE_RESULT(result);
        }
 
        /* if the keys are unequal, return the difference */
        if (result != 0)
            return result;
 
        scankey++;
    }
 
    /*
     * All non-truncated attributes (other than heap TID) were found to be
     * equal.  Treat truncated attributes as minus infinity when scankey has a
     * key attribute value that would otherwise be compared directly.
     *
     * Note: it doesn't matter if ntupatts includes non-key attributes;
     * scankey won't, so explicitly excluding non-key attributes isn't
     * necessary.
     */
    if (key->keysz > ntupatts)
        return 1;
 
    /*
     * Use the heap TID attribute and scantid to try to break the tie.  The
     * rules are the same as any other key attribute -- only the
     * representation differs.
     */
    heapTid = BTreeTupleGetHeapTID(itup);
    if (key->scantid == NULL)
    {
        /*
         * Forward scans have a scankey that is considered greater than a
         * truncated pivot tuple if and when the scankey has equal values for
         * attributes up to and including the least significant untruncated
         * attribute in tuple.  Even attributes that were omitted from the
         * scan key are considered greater than -inf truncated attributes.
         * (See _bt_binsrch for an explanation of our backward scan behavior.)
         *
         * For example, if an index has the minimum two attributes (single
         * user key attribute, plus heap TID attribute), and a page's high key
         * is ('foo', -inf), and scankey is ('foo', <omitted>), the search
         * will not descend to the page to the left.  The search will descend
         * right instead.  The truncated attribute in pivot tuple means that
         * all non-pivot tuples on the page to the left are strictly < 'foo',
         * so it isn't necessary to descend left.  In other words, search
         * doesn't have to descend left because it isn't interested in a match
         * that has a heap TID value of -inf.
         *
         * Note: the heap TID part of the test ensures that scankey is being
         * compared to a pivot tuple with one or more truncated -inf key
         * attributes.  The heap TID attribute is the last key attribute in
         * every index, of course, but other than that it isn't special.
         */
        if (!key->backward && key->keysz == ntupatts && heapTid == NULL &&
            key->heapkeyspace)
            return 1;
 
        /* All provided scankey arguments found to be equal */
        return 0;
    }
 
    /*
     * Treat truncated heap TID as minus infinity, since scankey has a key
     * attribute value (scantid) that would otherwise be compared directly
     */
    Assert(key->keysz == IndexRelationGetNumberOfKeyAttributes(rel));
    if (heapTid == NULL)
        return 1;
 
    /*
     * Scankey must be treated as equal to a posting list tuple if its scantid
     * value falls within the range of the posting list.  In all other cases
     * there can only be a single heap TID value, which is compared directly
     * with scantid.
     */
    Assert(ntupatts >= IndexRelationGetNumberOfKeyAttributes(rel));
    result = ItemPointerCompare(key->scantid, heapTid);
    if (result <= 0 || !BTreeTupleIsPosting(itup))
        return result;
    else
    {
        result = ItemPointerCompare(key->scantid,
                                    BTreeTupleGetMaxHeapTID(itup));
        if (result > 0)
            return 1;
    }
 
    return 0;
}

References _bt_check_natts(), Assert, BTPageGetOpaque, BTreeTupleGetHeapTID(), BTreeTupleGetMaxHeapTID(), BTreeTupleGetNAtts, BTreeTupleIsPosting(), DatumGetInt32(), fb(), FunctionCall2Coll(), i, index_getattr(), IndexRelationGetNumberOfKeyAttributes, INVERT_COMPARE_RESULT, ItemPointerCompare(), Min, P_FIRSTDATAKEY, P_ISLEAF, PageGetItem(), PageGetItemId(), RelationGetDescr, result, SK_BT_DESC, SK_BT_NULLS_FIRST, and SK_ISNULL.

Referenced by _bt_binsrch(), _bt_binsrch_insert(), _bt_check_unique(), _bt_findinsertloc(), _bt_moveright(), _bt_search_insert(), bt_rootdescend(), bt_target_page_check(), invariant_g_offset(), invariant_l_nontarget_offset(), invariant_l_offset(), and invariant_leq_offset().

◆ _bt_conditionallockbuf()

bool _bt_conditionallockbuf	(	Relation	rel,
		Buffer	buf
	)

extern

Definition at line 1121 of file nbtpage.c.

{
    /* ConditionalLockBuffer() asserts that pin is held by this backend */
    if (!ConditionalLockBuffer(buf))
        return false;
 
    if (!RelationUsesLocalBuffers(rel))
        VALGRIND_MAKE_MEM_DEFINED(BufferGetPage(buf), BLCKSZ);
 
    return true;
}

References buf, BufferGetPage(), ConditionalLockBuffer(), fb(), RelationUsesLocalBuffers, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by _bt_allocbuf(), and _bt_search_insert().

◆ _bt_dedup_finish_pending()

Size _bt_dedup_finish_pending	(	Page	newpage,
		BTDedupState	state
	)

extern

Definition at line 557 of file nbtdedup.c.

{
    OffsetNumber tupoff;
    Size        tuplesz;
    Size        spacesaving;
 
    Assert(state->nitems > 0);
    Assert(state->nitems <= state->nhtids);
    Assert(state->intervals[state->nintervals].baseoff == state->baseoff);
 
    tupoff = OffsetNumberNext(PageGetMaxOffsetNumber(newpage));
    if (state->nitems == 1)
    {
        /* Use original, unchanged base tuple */
        tuplesz = IndexTupleSize(state->base);
        Assert(tuplesz == MAXALIGN(IndexTupleSize(state->base)));
        Assert(tuplesz <= BTMaxItemSize);
        if (PageAddItem(newpage, state->base, tuplesz, tupoff, false, false) == InvalidOffsetNumber)
            elog(ERROR, "deduplication failed to add tuple to page");
 
        spacesaving = 0;
    }
    else
    {
        IndexTuple  final;
 
        /* Form a tuple with a posting list */
        final = _bt_form_posting(state->base, state->htids, state->nhtids);
        tuplesz = IndexTupleSize(final);
        Assert(tuplesz <= state->maxpostingsize);
 
        /* Save final number of items for posting list */
        state->intervals[state->nintervals].nitems = state->nitems;
 
        Assert(tuplesz == MAXALIGN(IndexTupleSize(final)));
        Assert(tuplesz <= BTMaxItemSize);
        if (PageAddItem(newpage, final, tuplesz, tupoff, false, false) == InvalidOffsetNumber)
            elog(ERROR, "deduplication failed to add tuple to page");
 
        pfree(final);
        spacesaving = state->phystupsize - (tuplesz + sizeof(ItemIdData));
        /* Increment nintervals, since we wrote a new posting list tuple */
        state->nintervals++;
        Assert(spacesaving > 0 && spacesaving < BLCKSZ);
    }
 
    /* Reset state for next pending posting list */
    state->nhtids = 0;
    state->nitems = 0;
    state->phystupsize = 0;
 
    return spacesaving;
}

References _bt_form_posting(), Assert, BTMaxItemSize, elog, ERROR, fb(), IndexTupleSize(), InvalidOffsetNumber, MAXALIGN, OffsetNumberNext, PageAddItem, PageGetMaxOffsetNumber(), and pfree().

Referenced by _bt_dedup_pass(), and btree_xlog_dedup().

◆ _bt_dedup_pass()

void _bt_dedup_pass	(	Relation	rel,
		Buffer	buf,
		IndexTuple	newitem,
		Size	newitemsz,
		bool	bottomupdedup
	)

extern

Definition at line 59 of file nbtdedup.c.

{
    OffsetNumber offnum,
                minoff,
                maxoff;
    Page        page = BufferGetPage(buf);
    BTPageOpaque opaque = BTPageGetOpaque(page);
    Page        newpage;
    BTDedupState state;
    Size        pagesaving PG_USED_FOR_ASSERTS_ONLY = 0;
    bool        singlevalstrat = false;
    int         nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
    XLogRecPtr  recptr;
 
    /* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
    newitemsz += sizeof(ItemIdData);
 
    /*
     * Initialize deduplication state.
     *
     * It would be possible for maxpostingsize (limit on posting list tuple
     * size) to be set to one third of the page.  However, it seems like a
     * good idea to limit the size of posting lists to one sixth of a page.
     * That ought to leave us with a good split point when pages full of
     * duplicates can be split several times.
     */
    state = palloc_object(BTDedupStateData);
    state->deduplicate = true;
    state->nmaxitems = 0;
    state->maxpostingsize = Min(BTMaxItemSize / 2, INDEX_SIZE_MASK);
    /* Metadata about base tuple of current pending posting list */
    state->base = NULL;
    state->baseoff = InvalidOffsetNumber;
    state->basetupsize = 0;
    /* Metadata about current pending posting list TIDs */
    state->htids = palloc(state->maxpostingsize);
    state->nhtids = 0;
    state->nitems = 0;
    /* Size of all physical tuples to be replaced by pending posting list */
    state->phystupsize = 0;
    /* nintervals should be initialized to zero */
    state->nintervals = 0;
 
    minoff = P_FIRSTDATAKEY(opaque);
    maxoff = PageGetMaxOffsetNumber(page);
 
    /*
     * Consider applying "single value" strategy, though only if the page
     * seems likely to be split in the near future
     */
    if (!bottomupdedup)
        singlevalstrat = _bt_do_singleval(rel, page, state, minoff, newitem);
 
    /*
     * Deduplicate items from page, and write them to newpage.
     *
     * Copy the original page's LSN into newpage copy.  This will become the
     * updated version of the page.  We need this because XLogInsert will
     * examine the LSN and possibly dump it in a page image.
     */
    newpage = PageGetTempPageCopySpecial(page);
    PageSetLSN(newpage, PageGetLSN(page));
 
    /* Copy high key, if any */
    if (!P_RIGHTMOST(opaque))
    {
        ItemId      hitemid = PageGetItemId(page, P_HIKEY);
        Size        hitemsz = ItemIdGetLength(hitemid);
        IndexTuple  hitem = (IndexTuple) PageGetItem(page, hitemid);
 
        if (PageAddItem(newpage, hitem, hitemsz, P_HIKEY, false, false) == InvalidOffsetNumber)
            elog(ERROR, "deduplication failed to add highkey");
    }
 
    for (offnum = minoff;
         offnum <= maxoff;
         offnum = OffsetNumberNext(offnum))
    {
        ItemId      itemid = PageGetItemId(page, offnum);
        IndexTuple  itup = (IndexTuple) PageGetItem(page, itemid);
 
        Assert(!ItemIdIsDead(itemid));
 
        if (offnum == minoff)
        {
            /*
             * No previous/base tuple for the data item -- use the data item
             * as base tuple of pending posting list
             */
            _bt_dedup_start_pending(state, itup, offnum);
        }
        else if (state->deduplicate &&
                 _bt_keep_natts_fast(rel, state->base, itup) > nkeyatts &&
                 _bt_dedup_save_htid(state, itup))
        {
            /*
             * Tuple is equal to base tuple of pending posting list.  Heap
             * TID(s) for itup have been saved in state.
             */
        }
        else
        {
            /*
             * Tuple is not equal to pending posting list tuple, or
             * _bt_dedup_save_htid() opted to not merge current item into
             * pending posting list for some other reason (e.g., adding more
             * TIDs would have caused posting list to exceed current
             * maxpostingsize).
             *
             * If state contains pending posting list with more than one item,
             * form new posting tuple and add it to our temp page (newpage).
             * Else add pending interval's base tuple to the temp page as-is.
             */
            pagesaving += _bt_dedup_finish_pending(newpage, state);
 
            if (singlevalstrat)
            {
                /*
                 * Single value strategy's extra steps.
                 *
                 * Lower maxpostingsize for sixth and final large posting list
                 * tuple at the point where 5 maxpostingsize-capped tuples
                 * have either been formed or observed.
                 *
                 * When a sixth maxpostingsize-capped item is formed/observed,
                 * stop merging together tuples altogether.  The few tuples
                 * that remain at the end of the page won't be merged together
                 * at all (at least not until after a future page split takes
                 * place, when this page's newly allocated right sibling page
                 * gets its first deduplication pass).
                 */
                if (state->nmaxitems == 5)
                    _bt_singleval_fillfactor(page, state, newitemsz);
                else if (state->nmaxitems == 6)
                {
                    state->deduplicate = false;
                    singlevalstrat = false; /* won't be back here */
                }
            }
 
            /* itup starts new pending posting list */
            _bt_dedup_start_pending(state, itup, offnum);
        }
    }
 
    /* Handle the last item */
    pagesaving += _bt_dedup_finish_pending(newpage, state);
 
    /*
     * If no items suitable for deduplication were found, newpage must be
     * exactly the same as the original page, so just return from function.
     *
     * We could determine whether or not to proceed on the basis the space
     * savings being sufficient to avoid an immediate page split instead.  We
     * don't do that because there is some small value in nbtsplitloc.c always
     * operating against a page that is fully deduplicated (apart from
     * newitem).  Besides, most of the cost has already been paid.
     */
    if (state->nintervals == 0)
    {
        /* cannot leak memory here */
        pfree(newpage);
        pfree(state->htids);
        pfree(state);
        return;
    }
 
    /*
     * By here, it's clear that deduplication will definitely go ahead.
     *
     * Clear the BTP_HAS_GARBAGE page flag.  The index must be a heapkeyspace
     * index, and as such we'll never pay attention to BTP_HAS_GARBAGE anyway.
     * But keep things tidy.
     */
    if (P_HAS_GARBAGE(opaque))
    {
        BTPageOpaque nopaque = BTPageGetOpaque(newpage);
 
        nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
    }
 
    START_CRIT_SECTION();
 
    PageRestoreTempPage(newpage, page);
    MarkBufferDirty(buf);
 
    /* XLOG stuff */
    if (RelationNeedsWAL(rel))
    {
        xl_btree_dedup xlrec_dedup;
 
        xlrec_dedup.nintervals = state->nintervals;
 
        XLogBeginInsert();
        XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
        XLogRegisterData(&xlrec_dedup, SizeOfBtreeDedup);
 
        /*
         * The intervals array is not in the buffer, but pretend that it is.
         * When XLogInsert stores the whole buffer, the array need not be
         * stored too.
         */
        XLogRegisterBufData(0, state->intervals,
                            state->nintervals * sizeof(BTDedupInterval));
 
        recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
    }
    else
        recptr = XLogGetFakeLSN(rel);
 
    PageSetLSN(page, recptr);
 
    END_CRIT_SECTION();
 
    /* Local space accounting should agree with page accounting */
    Assert(pagesaving < newitemsz || PageGetExactFreeSpace(page) >= newitemsz);
 
    /* cannot leak memory here */
    pfree(state->htids);
    pfree(state);
}

References _bt_dedup_finish_pending(), _bt_dedup_save_htid(), _bt_dedup_start_pending(), _bt_do_singleval(), _bt_keep_natts_fast(), _bt_singleval_fillfactor(), Assert, BTMaxItemSize, BTPageGetOpaque, buf, BufferGetPage(), elog, END_CRIT_SECTION, ERROR, fb(), INDEX_SIZE_MASK, IndexRelationGetNumberOfKeyAttributes, InvalidOffsetNumber, ItemIdGetLength, ItemIdIsDead, MarkBufferDirty(), Min, xl_btree_dedup::nintervals, OffsetNumberNext, P_FIRSTDATAKEY, P_HAS_GARBAGE, P_HIKEY, P_RIGHTMOST, PageAddItem, PageGetExactFreeSpace(), PageGetItem(), PageGetItemId(), PageGetLSN(), PageGetMaxOffsetNumber(), PageGetTempPageCopySpecial(), PageRestoreTempPage(), PageSetLSN(), palloc(), palloc_object, pfree(), PG_USED_FOR_ASSERTS_ONLY, REGBUF_STANDARD, RelationNeedsWAL, SizeOfBtreeDedup, START_CRIT_SECTION, XLOG_BTREE_DEDUP, XLogBeginInsert(), XLogGetFakeLSN(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by _bt_delete_or_dedup_one_page().

◆ _bt_dedup_save_htid()

bool _bt_dedup_save_htid	(	BTDedupState	state,
		IndexTuple	itup
	)

extern

Definition at line 486 of file nbtdedup.c.

{
    int         nhtids;
    ItemPointer htids;
    Size        mergedtupsz;
 
    Assert(!BTreeTupleIsPivot(itup));
 
    if (!BTreeTupleIsPosting(itup))
    {
        nhtids = 1;
        htids = &itup->t_tid;
    }
    else
    {
        nhtids = BTreeTupleGetNPosting(itup);
        htids = BTreeTupleGetPosting(itup);
    }
 
    /*
     * Don't append (have caller finish pending posting list as-is) if
     * appending heap TID(s) from itup would put us over maxpostingsize limit.
     *
     * This calculation needs to match the code used within _bt_form_posting()
     * for new posting list tuples.
     */
    mergedtupsz = MAXALIGN(state->basetupsize +
                           (state->nhtids + nhtids) * sizeof(ItemPointerData));
 
    if (mergedtupsz > state->maxpostingsize)
    {
        /*
         * Count this as an oversized item for single value strategy, though
         * only when there are 50 TIDs in the final posting list tuple.  This
         * limit (which is fairly arbitrary) avoids confusion about how many
         * 1/6 of a page tuples have been encountered/created by the current
         * deduplication pass.
         *
         * Note: We deliberately don't consider which deduplication pass
         * merged together tuples to create this item (could be a previous
         * deduplication pass, or current pass).  See _bt_do_singleval()
         * comments.
         */
        if (state->nhtids > 50)
            state->nmaxitems++;
 
        return false;
    }
 
    /*
     * Save heap TIDs to pending posting list tuple -- itup can be merged into
     * pending posting list
     */
    state->nitems++;
    memcpy(state->htids + state->nhtids, htids,
           sizeof(ItemPointerData) * nhtids);
    state->nhtids += nhtids;
    state->phystupsize += MAXALIGN(IndexTupleSize(itup)) + sizeof(ItemIdData);
 
    return true;
}

References Assert, BTreeTupleGetNPosting(), BTreeTupleGetPosting(), BTreeTupleIsPivot(), BTreeTupleIsPosting(), fb(), IndexTupleSize(), MAXALIGN, memcpy(), and IndexTupleData::t_tid.

Referenced by _bt_bottomupdel_pass(), _bt_dedup_pass(), _bt_load(), and btree_xlog_dedup().

◆ _bt_dedup_start_pending()

void _bt_dedup_start_pending	(	BTDedupState	state,
		IndexTuple	base,
		OffsetNumber	baseoff
	)

extern

Definition at line 435 of file nbtdedup.c.

{
    Assert(state->nhtids == 0);
    Assert(state->nitems == 0);
    Assert(!BTreeTupleIsPivot(base));
 
    /*
     * Copy heap TID(s) from new base tuple for new candidate posting list
     * into working state's array
     */
    if (!BTreeTupleIsPosting(base))
    {
        memcpy(state->htids, &base->t_tid, sizeof(ItemPointerData));
        state->nhtids = 1;
        state->basetupsize = IndexTupleSize(base);
    }
    else
    {
        int         nposting;
 
        nposting = BTreeTupleGetNPosting(base);
        memcpy(state->htids, BTreeTupleGetPosting(base),
               sizeof(ItemPointerData) * nposting);
        state->nhtids = nposting;
        /* basetupsize should not include existing posting list */
        state->basetupsize = BTreeTupleGetPostingOffset(base);
    }
 
    /*
     * Save new base tuple itself -- it'll be needed if we actually create a
     * new posting list from new pending posting list.
     *
     * Must maintain physical size of all existing tuples (including line
     * pointer overhead) so that we can calculate space savings on page.
     */
    state->nitems = 1;
    state->base = base;
    state->baseoff = baseoff;
    state->phystupsize = MAXALIGN(IndexTupleSize(base)) + sizeof(ItemIdData);
    /* Also save baseoff in pending state for interval */
    state->intervals[state->nintervals].baseoff = state->baseoff;
}

References Assert, BTreeTupleGetNPosting(), BTreeTupleGetPosting(), BTreeTupleGetPostingOffset(), BTreeTupleIsPivot(), BTreeTupleIsPosting(), fb(), IndexTupleSize(), MAXALIGN, memcpy(), and IndexTupleData::t_tid.

Referenced by _bt_bottomupdel_pass(), _bt_dedup_pass(), _bt_load(), and btree_xlog_dedup().

◆ _bt_delitems_delete_check()

void _bt_delitems_delete_check	(	Relation	rel,
		Buffer	buf,
		Relation	heapRel,
		struct TM_IndexDeleteOp *	delstate
	)

extern

Definition at line 1543 of file nbtpage.c.

{
    Page        page = BufferGetPage(buf);
    TransactionId snapshotConflictHorizon;
    bool        isCatalogRel;
    OffsetNumber postingidxoffnum = InvalidOffsetNumber;
    int         ndeletable = 0,
                nupdatable = 0;
    OffsetNumber deletable[MaxIndexTuplesPerPage];
    BTVacuumPosting updatable[MaxIndexTuplesPerPage];
 
    /* Use tableam interface to determine which tuples to delete first */
    snapshotConflictHorizon = table_index_delete_tuples(heapRel, delstate);
    isCatalogRel = RelationIsAccessibleInLogicalDecoding(heapRel);
 
    /* Should not WAL-log snapshotConflictHorizon unless it's required */
    if (!XLogStandbyInfoActive())
        snapshotConflictHorizon = InvalidTransactionId;
 
    /*
     * Construct a leaf-page-wise description of what _bt_delitems_delete()
     * needs to do to physically delete index tuples from the page.
     *
     * Must sort deltids array to restore leaf-page-wise order (original order
     * before call to tableam).  This is the order that the loop expects.
     *
     * Note that deltids array might be a lot smaller now.  It might even have
     * no entries at all (with bottom-up deletion caller), in which case there
     * is nothing left to do.
     */
    qsort(delstate->deltids, delstate->ndeltids, sizeof(TM_IndexDelete),
          _bt_delitems_cmp);
    if (delstate->ndeltids == 0)
    {
        Assert(delstate->bottomup);
        return;
    }
 
    /* We definitely have to delete at least one index tuple (or one TID) */
    for (int i = 0; i < delstate->ndeltids; i++)
    {
        TM_IndexStatus *dstatus = delstate->status + delstate->deltids[i].id;
        OffsetNumber idxoffnum = dstatus->idxoffnum;
        ItemId      itemid = PageGetItemId(page, idxoffnum);
        IndexTuple  itup = (IndexTuple) PageGetItem(page, itemid);
        int         nestedi,
                    nitem;
        BTVacuumPosting vacposting;
 
        Assert(OffsetNumberIsValid(idxoffnum));
 
        if (idxoffnum == postingidxoffnum)
        {
            /*
             * This deltid entry is a TID from a posting list tuple that has
             * already been completely processed
             */
            Assert(BTreeTupleIsPosting(itup));
            Assert(ItemPointerCompare(BTreeTupleGetHeapTID(itup),
                                      &delstate->deltids[i].tid) < 0);
            Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(itup),
                                      &delstate->deltids[i].tid) >= 0);
            continue;
        }
 
        if (!BTreeTupleIsPosting(itup))
        {
            /* Plain non-pivot tuple */
            Assert(ItemPointerEquals(&itup->t_tid, &delstate->deltids[i].tid));
            if (dstatus->knowndeletable)
                deletable[ndeletable++] = idxoffnum;
            continue;
        }
 
        /*
         * itup is a posting list tuple whose lowest deltids entry (which may
         * or may not be for the first TID from itup) is considered here now.
         * We should process all of the deltids entries for the posting list
         * together now, though (not just the lowest).  Remember to skip over
         * later itup-related entries during later iterations of outermost
         * loop.
         */
        postingidxoffnum = idxoffnum;   /* Remember work in outermost loop */
        nestedi = i;            /* Initialize for first itup deltids entry */
        vacposting = NULL;      /* Describes final action for itup */
        nitem = BTreeTupleGetNPosting(itup);
        for (int p = 0; p < nitem; p++)
        {
            ItemPointer ptid = BTreeTupleGetPostingN(itup, p);
            int         ptidcmp = -1;
 
            /*
             * This nested loop reuses work across ptid TIDs taken from itup.
             * We take advantage of the fact that both itup's TIDs and deltids
             * entries (within a single itup/posting list grouping) must both
             * be in ascending TID order.
             */
            for (; nestedi < delstate->ndeltids; nestedi++)
            {
                TM_IndexDelete *tcdeltid = &delstate->deltids[nestedi];
                TM_IndexStatus *tdstatus = (delstate->status + tcdeltid->id);
 
                /* Stop once we get past all itup related deltids entries */
                Assert(tdstatus->idxoffnum >= idxoffnum);
                if (tdstatus->idxoffnum != idxoffnum)
                    break;
 
                /* Skip past non-deletable itup related entries up front */
                if (!tdstatus->knowndeletable)
                    continue;
 
                /* Entry is first partial ptid match (or an exact match)? */
                ptidcmp = ItemPointerCompare(&tcdeltid->tid, ptid);
                if (ptidcmp >= 0)
                {
                    /* Greater than or equal (partial or exact) match... */
                    break;
                }
            }
 
            /* ...exact ptid match to a deletable deltids entry? */
            if (ptidcmp != 0)
                continue;
 
            /* Exact match for deletable deltids entry -- ptid gets deleted */
            if (vacposting == NULL)
            {
                vacposting = palloc(offsetof(BTVacuumPostingData, deletetids) +
                                    nitem * sizeof(uint16));
                vacposting->itup = itup;
                vacposting->updatedoffset = idxoffnum;
                vacposting->ndeletedtids = 0;
            }
            vacposting->deletetids[vacposting->ndeletedtids++] = p;
        }
 
        /* Final decision on itup, a posting list tuple */
 
        if (vacposting == NULL)
        {
            /* No TIDs to delete from itup -- do nothing */
        }
        else if (vacposting->ndeletedtids == nitem)
        {
            /* Straight delete of itup (to delete all TIDs) */
            deletable[ndeletable++] = idxoffnum;
            /* Turns out we won't need granular information */
            pfree(vacposting);
        }
        else
        {
            /* Delete some (but not all) TIDs from itup */
            Assert(vacposting->ndeletedtids > 0 &&
                   vacposting->ndeletedtids < nitem);
            updatable[nupdatable++] = vacposting;
        }
    }
 
    /* Physically delete tuples (or TIDs) using deletable (or updatable) */
    _bt_delitems_delete(rel, buf, snapshotConflictHorizon, isCatalogRel,
                        deletable, ndeletable, updatable, nupdatable);
 
    /* be tidy */
    for (int i = 0; i < nupdatable; i++)
        pfree(updatable[i]);
}

References _bt_delitems_cmp(), _bt_delitems_delete(), Assert, BTreeTupleGetHeapTID(), BTreeTupleGetMaxHeapTID(), BTreeTupleGetNPosting(), BTreeTupleGetPostingN(), BTreeTupleIsPosting(), buf, BufferGetPage(), fb(), i, TM_IndexStatus::idxoffnum, InvalidOffsetNumber, InvalidTransactionId, ItemPointerCompare(), ItemPointerEquals(), MaxIndexTuplesPerPage, OffsetNumberIsValid, PageGetItem(), PageGetItemId(), palloc(), pfree(), qsort, RelationIsAccessibleInLogicalDecoding, IndexTupleData::t_tid, table_index_delete_tuples(), and XLogStandbyInfoActive.

Referenced by _bt_bottomupdel_pass(), and _bt_simpledel_pass().

◆ _bt_delitems_vacuum()

void _bt_delitems_vacuum	(	Relation	rel,
		Buffer	buf,
		OffsetNumber *	deletable,
		int	ndeletable,
		BTVacuumPosting *	updatable,
		int	nupdatable
	)

extern

Definition at line 1182 of file nbtpage.c.

{
    Page        page = BufferGetPage(buf);
    BTPageOpaque opaque;
    bool        needswal = RelationNeedsWAL(rel);
    char       *updatedbuf = NULL;
    Size        updatedbuflen = 0;
    OffsetNumber updatedoffsets[MaxIndexTuplesPerPage];
    XLogRecPtr  recptr;
 
    /* Shouldn't be called unless there's something to do */
    Assert(ndeletable > 0 || nupdatable > 0);
 
    /* Generate new version of posting lists without deleted TIDs */
    if (nupdatable > 0)
        updatedbuf = _bt_delitems_update(updatable, nupdatable,
                                         updatedoffsets, &updatedbuflen,
                                         needswal);
 
    /* No ereport(ERROR) until changes are logged */
    START_CRIT_SECTION();
 
    /*
     * Handle posting tuple updates.
     *
     * Deliberately do this before handling simple deletes.  If we did it the
     * other way around (i.e. WAL record order -- simple deletes before
     * updates) then we'd have to make compensating changes to the 'updatable'
     * array of offset numbers.
     *
     * PageIndexTupleOverwrite() won't unset each item's LP_DEAD bit when it
     * happens to already be set.  It's important that we not interfere with
     * any future simple index tuple deletion operations.
     */
    for (int i = 0; i < nupdatable; i++)
    {
        OffsetNumber updatedoffset = updatedoffsets[i];
        IndexTuple  itup;
        Size        itemsz;
 
        itup = updatable[i]->itup;
        itemsz = MAXALIGN(IndexTupleSize(itup));
        if (!PageIndexTupleOverwrite(page, updatedoffset, itup, itemsz))
            elog(PANIC, "failed to update partially dead item in block %u of index \"%s\"",
                 BufferGetBlockNumber(buf), RelationGetRelationName(rel));
    }
 
    /* Now handle simple deletes of entire tuples */
    if (ndeletable > 0)
        PageIndexMultiDelete(page, deletable, ndeletable);
 
    /*
     * We can clear the vacuum cycle ID since this page has certainly been
     * processed by the current vacuum scan.
     */
    opaque = BTPageGetOpaque(page);
    opaque->btpo_cycleid = 0;
 
    /*
     * Clear the BTP_HAS_GARBAGE page flag.
     *
     * This flag indicates the presence of LP_DEAD items on the page (though
     * not reliably).  Note that we only rely on it with pg_upgrade'd
     * !heapkeyspace indexes.  That's why clearing it here won't usually
     * interfere with simple index tuple deletion.
     */
    opaque->btpo_flags &= ~BTP_HAS_GARBAGE;
 
    MarkBufferDirty(buf);
 
    /* XLOG stuff */
    if (needswal)
    {
        xl_btree_vacuum xlrec_vacuum;
 
        xlrec_vacuum.ndeleted = ndeletable;
        xlrec_vacuum.nupdated = nupdatable;
 
        XLogBeginInsert();
        XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
        XLogRegisterData(&xlrec_vacuum, SizeOfBtreeVacuum);
 
        if (ndeletable > 0)
            XLogRegisterBufData(0, deletable,
                                ndeletable * sizeof(OffsetNumber));
 
        if (nupdatable > 0)
        {
            XLogRegisterBufData(0, updatedoffsets,
                                nupdatable * sizeof(OffsetNumber));
            XLogRegisterBufData(0, updatedbuf, updatedbuflen);
        }
 
        recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_VACUUM);
    }
    else
        recptr = XLogGetFakeLSN(rel);
 
    PageSetLSN(page, recptr);
 
    END_CRIT_SECTION();
 
    /* can't leak memory here */
    if (updatedbuf != NULL)
        pfree(updatedbuf);
    /* free tuples allocated within _bt_delitems_update() */
    for (int i = 0; i < nupdatable; i++)
        pfree(updatable[i]->itup);
}

References _bt_delitems_update(), Assert, BTPageGetOpaque, BTPageOpaqueData::btpo_cycleid, BTPageOpaqueData::btpo_flags, buf, BufferGetBlockNumber(), BufferGetPage(), elog, END_CRIT_SECTION, fb(), i, IndexTupleSize(), BTVacuumPostingData::itup, MarkBufferDirty(), MAXALIGN, MaxIndexTuplesPerPage, xl_btree_vacuum::ndeleted, PageIndexMultiDelete(), PageIndexTupleOverwrite(), PageSetLSN(), PANIC, pfree(), REGBUF_STANDARD, RelationGetRelationName, RelationNeedsWAL, SizeOfBtreeVacuum, START_CRIT_SECTION, XLOG_BTREE_VACUUM, XLogBeginInsert(), XLogGetFakeLSN(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by btvacuumpage().

◆ _bt_doinsert()

bool _bt_doinsert	(	Relation	rel,
		IndexTuple	itup,
		IndexUniqueCheck	checkUnique,
		bool	indexUnchanged,
		Relation	heapRel
	)

extern

Definition at line 105 of file nbtinsert.c.

{
    bool        is_unique = false;
    BTInsertStateData insertstate;
    BTScanInsert itup_key;
    BTStack     stack;
    bool        checkingunique = (checkUnique != UNIQUE_CHECK_NO);
 
    /* we need an insertion scan key to do our search, so build one */
    itup_key = _bt_mkscankey(rel, itup);
 
    if (checkingunique)
    {
        if (!itup_key->anynullkeys)
        {
            /* No (heapkeyspace) scantid until uniqueness established */
            itup_key->scantid = NULL;
        }
        else
        {
            /*
             * Scan key for new tuple contains NULL key values.  Bypass
             * checkingunique steps.  They are unnecessary because core code
             * considers NULL unequal to every value, including NULL.
             *
             * This optimization avoids O(N^2) behavior within the
             * _bt_findinsertloc() heapkeyspace path when a unique index has a
             * large number of "duplicates" with NULL key values.
             */
            checkingunique = false;
            /* Tuple is unique in the sense that core code cares about */
            Assert(checkUnique != UNIQUE_CHECK_EXISTING);
            is_unique = true;
        }
    }
 
    /*
     * Fill in the BTInsertState working area, to track the current page and
     * position within the page to insert on.
     *
     * Note that itemsz is passed down to lower level code that deals with
     * inserting the item.  It must be MAXALIGN()'d.  This ensures that space
     * accounting code consistently considers the alignment overhead that we
     * expect PageAddItem() will add later.  (Actually, index_form_tuple() is
     * already conservative about alignment, but we don't rely on that from
     * this distance.  Besides, preserving the "true" tuple size in index
     * tuple headers for the benefit of nbtsplitloc.c might happen someday.
     * Note that heapam does not MAXALIGN() each heap tuple's lp_len field.)
     */
    insertstate.itup = itup;
    insertstate.itemsz = MAXALIGN(IndexTupleSize(itup));
    insertstate.itup_key = itup_key;
    insertstate.bounds_valid = false;
    insertstate.buf = InvalidBuffer;
    insertstate.postingoff = 0;
 
search:
 
    /*
     * Find and lock the leaf page that the tuple should be added to by
     * searching from the root page.  insertstate.buf will hold a buffer that
     * is locked in exclusive mode afterwards.
     */
    stack = _bt_search_insert(rel, heapRel, &insertstate);
 
    /*
     * checkingunique inserts are not allowed to go ahead when two tuples with
     * equal key attribute values would be visible to new MVCC snapshots once
     * the xact commits.  Check for conflicts in the locked page/buffer (if
     * needed) here.
     *
     * It might be necessary to check a page to the right in _bt_check_unique,
     * though that should be very rare.  In practice the first page the value
     * could be on (with scantid omitted) is almost always also the only page
     * that a matching tuple might be found on.  This is due to the behavior
     * of _bt_findsplitloc with duplicate tuples -- a group of duplicates can
     * only be allowed to cross a page boundary when there is no candidate
     * leaf page split point that avoids it.  Also, _bt_check_unique can use
     * the leaf page high key to determine that there will be no duplicates on
     * the right sibling without actually visiting it (it uses the high key in
     * cases where the new item happens to belong at the far right of the leaf
     * page).
     *
     * NOTE: obviously, _bt_check_unique can only detect keys that are already
     * in the index; so it cannot defend against concurrent insertions of the
     * same key.  We protect against that by means of holding a write lock on
     * the first page the value could be on, with omitted/-inf value for the
     * implicit heap TID tiebreaker attribute.  Any other would-be inserter of
     * the same key must acquire a write lock on the same page, so only one
     * would-be inserter can be making the check at one time.  Furthermore,
     * once we are past the check we hold write locks continuously until we
     * have performed our insertion, so no later inserter can fail to see our
     * insertion.  (This requires some care in _bt_findinsertloc.)
     *
     * If we must wait for another xact, we release the lock while waiting,
     * and then must perform a new search.
     *
     * For a partial uniqueness check, we don't wait for the other xact. Just
     * let the tuple in and return false for possibly non-unique, or true for
     * definitely unique.
     */
    if (checkingunique)
    {
        TransactionId xwait;
        uint32      speculativeToken;
 
        xwait = _bt_check_unique(rel, &insertstate, heapRel, checkUnique,
                                 &is_unique, &speculativeToken);
 
        if (unlikely(TransactionIdIsValid(xwait)))
        {
            /* Have to wait for the other guy ... */
            _bt_relbuf(rel, insertstate.buf);
            insertstate.buf = InvalidBuffer;
 
            /*
             * If it's a speculative insertion, wait for it to finish (ie. to
             * go ahead with the insertion, or kill the tuple).  Otherwise
             * wait for the transaction to finish as usual.
             */
            if (speculativeToken)
                SpeculativeInsertionWait(xwait, speculativeToken);
            else
                XactLockTableWait(xwait, rel, &itup->t_tid, XLTW_InsertIndex);
 
            /* start over... */
            if (stack)
                _bt_freestack(stack);
            goto search;
        }
 
        /* Uniqueness is established -- restore heap tid as scantid */
        if (itup_key->heapkeyspace)
            itup_key->scantid = &itup->t_tid;
    }
 
    if (checkUnique != UNIQUE_CHECK_EXISTING)
    {
        OffsetNumber newitemoff;
 
        /*
         * The only conflict predicate locking cares about for indexes is when
         * an index tuple insert conflicts with an existing lock.  We don't
         * know the actual page we're going to insert on for sure just yet in
         * checkingunique and !heapkeyspace cases, but it's okay to use the
         * first page the value could be on (with scantid omitted) instead.
         */
        CheckForSerializableConflictIn(rel, NULL, BufferGetBlockNumber(insertstate.buf));
 
        /*
         * Do the insertion.  Note that insertstate contains cached binary
         * search bounds established within _bt_check_unique when insertion is
         * checkingunique.
         */
        newitemoff = _bt_findinsertloc(rel, &insertstate, checkingunique,
                                       indexUnchanged, stack, heapRel);
        _bt_insertonpg(rel, heapRel, itup_key, insertstate.buf, InvalidBuffer,
                       stack, itup, insertstate.itemsz, newitemoff,
                       insertstate.postingoff, false);
    }
    else
    {
        /* just release the buffer */
        _bt_relbuf(rel, insertstate.buf);
    }
 
    /* be tidy */
    if (stack)
        _bt_freestack(stack);
    pfree(itup_key);
 
    return is_unique;
}

References _bt_check_unique(), _bt_findinsertloc(), _bt_freestack(), _bt_insertonpg(), _bt_mkscankey(), _bt_relbuf(), _bt_search_insert(), BTScanInsertData::anynullkeys, Assert, BufferGetBlockNumber(), CheckForSerializableConflictIn(), fb(), BTScanInsertData::heapkeyspace, IndexTupleSize(), InvalidBuffer, MAXALIGN, pfree(), BTScanInsertData::scantid, SpeculativeInsertionWait(), IndexTupleData::t_tid, TransactionIdIsValid, UNIQUE_CHECK_EXISTING, UNIQUE_CHECK_NO, unlikely, XactLockTableWait(), and XLTW_InsertIndex.

Referenced by btinsert().

◆ _bt_end_vacuum()

void _bt_end_vacuum ( Relation rel )

extern

Definition at line 530 of file nbtutils.c.

{
    int         i;
 
    LWLockAcquire(BtreeVacuumLock, LW_EXCLUSIVE);
 
    /* Find the array entry */
    for (i = 0; i < btvacinfo->num_vacuums; i++)
    {
        BTOneVacInfo *vac = &btvacinfo->vacuums[i];
 
        if (vac->relid.relId == rel->rd_lockInfo.lockRelId.relId &&
            vac->relid.dbId == rel->rd_lockInfo.lockRelId.dbId)
        {
            /* Remove it by shifting down the last entry */
            *vac = btvacinfo->vacuums[btvacinfo->num_vacuums - 1];
            btvacinfo->num_vacuums--;
            break;
        }
    }
 
    LWLockRelease(BtreeVacuumLock);
}

References btvacinfo, LockRelId::dbId, fb(), i, LockInfoData::lockRelId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), BTVacInfo::num_vacuums, RelationData::rd_lockInfo, BTOneVacInfo::relid, LockRelId::relId, and BTVacInfo::vacuums.

Referenced by _bt_end_vacuum_callback(), and btbulkdelete().

◆ _bt_end_vacuum_callback()

void _bt_end_vacuum_callback	(	int	code,
		Datum	arg
	)

extern

Definition at line 558 of file nbtutils.c.

{
    _bt_end_vacuum((Relation) DatumGetPointer(arg));
}

References _bt_end_vacuum(), arg, and DatumGetPointer().

Referenced by btbulkdelete().

◆ _bt_findsplitloc()

OffsetNumber _bt_findsplitloc	(	Relation	rel,
		Page	origpage,
		OffsetNumber	newitemoff,
		Size	newitemsz,
		IndexTuple	newitem,
		bool *	newitemonleft
	)

extern

Definition at line 130 of file nbtsplitloc.c.

{
    BTPageOpaque opaque;
    int         leftspace,
                rightspace,
                olddataitemstotal,
                olddataitemstoleft,
                perfectpenalty,
                leaffillfactor;
    FindSplitData state;
    FindSplitStrat strategy;
    ItemId      itemid;
    OffsetNumber offnum,
                maxoff,
                firstrightoff;
    double      fillfactormult;
    bool        usemult;
    SplitPoint  leftpage,
                rightpage;
 
    opaque = BTPageGetOpaque(origpage);
    maxoff = PageGetMaxOffsetNumber(origpage);
 
    /* Total free space available on a btree page, after fixed overhead */
    leftspace = rightspace =
        PageGetPageSize(origpage) - SizeOfPageHeaderData -
        MAXALIGN(sizeof(BTPageOpaqueData));
 
    /* The right page will have the same high key as the old page */
    if (!P_RIGHTMOST(opaque))
    {
        itemid = PageGetItemId(origpage, P_HIKEY);
        rightspace -= (int) (MAXALIGN(ItemIdGetLength(itemid)) +
                             sizeof(ItemIdData));
    }
 
    /* Count up total space in data items before actually scanning 'em */
    olddataitemstotal = rightspace - (int) PageGetExactFreeSpace(origpage);
    leaffillfactor = BTGetFillFactor(rel);
 
    /* Passed-in newitemsz is MAXALIGNED but does not include line pointer */
    newitemsz += sizeof(ItemIdData);
    state.rel = rel;
    state.origpage = origpage;
    state.newitem = newitem;
    state.newitemsz = newitemsz;
    state.is_leaf = P_ISLEAF(opaque);
    state.is_rightmost = P_RIGHTMOST(opaque);
    state.leftspace = leftspace;
    state.rightspace = rightspace;
    state.olddataitemstotal = olddataitemstotal;
    state.minfirstrightsz = SIZE_MAX;
    state.newitemoff = newitemoff;
 
    /* newitem cannot be a posting list item */
    Assert(!BTreeTupleIsPosting(newitem));
 
    /*
     * nsplits should never exceed maxoff because there will be at most as
     * many candidate split points as there are points _between_ tuples, once
     * you imagine that the new item is already on the original page (the
     * final number of splits may be slightly lower because not all points
     * between tuples will be legal).
     */
    state.maxsplits = maxoff;
    state.splits = palloc_array(SplitPoint, state.maxsplits);
    state.nsplits = 0;
 
    /*
     * Scan through the data items and calculate space usage for a split at
     * each possible position
     */
    olddataitemstoleft = 0;
 
    for (offnum = P_FIRSTDATAKEY(opaque);
         offnum <= maxoff;
         offnum = OffsetNumberNext(offnum))
    {
        Size        itemsz;
 
        itemid = PageGetItemId(origpage, offnum);
        itemsz = MAXALIGN(ItemIdGetLength(itemid)) + sizeof(ItemIdData);
 
        /*
         * When item offset number is not newitemoff, neither side of the
         * split can be newitem.  Record a split after the previous data item
         * from original page, but before the current data item from original
         * page. (_bt_recsplitloc() will reject the split when there are no
         * previous items, which we rely on.)
         */
        if (offnum < newitemoff)
            _bt_recsplitloc(&state, offnum, false, olddataitemstoleft, itemsz);
        else if (offnum > newitemoff)
            _bt_recsplitloc(&state, offnum, true, olddataitemstoleft, itemsz);
        else
        {
            /*
             * Record a split after all "offnum < newitemoff" original page
             * data items, but before newitem
             */
            _bt_recsplitloc(&state, offnum, false, olddataitemstoleft, itemsz);
 
            /*
             * Record a split after newitem, but before data item from
             * original page at offset newitemoff/current offset
             */
            _bt_recsplitloc(&state, offnum, true, olddataitemstoleft, itemsz);
        }
 
        olddataitemstoleft += itemsz;
    }
 
    /*
     * Record a split after all original page data items, but before newitem.
     * (Though only when it's possible that newitem will end up alone on new
     * right page.)
     */
    Assert(olddataitemstoleft == olddataitemstotal);
    if (newitemoff > maxoff)
        _bt_recsplitloc(&state, newitemoff, false, olddataitemstotal, 0);
 
    /*
     * I believe it is not possible to fail to find a feasible split, but just
     * in case ...
     */
    if (state.nsplits == 0)
        elog(ERROR, "could not find a feasible split point for index \"%s\"",
             RelationGetRelationName(rel));
 
    /*
     * Start search for a split point among list of legal split points.  Give
     * primary consideration to equalizing available free space in each half
     * of the split initially (start with default strategy), while applying
     * rightmost and split-after-new-item optimizations where appropriate.
     * Either of the two other fallback strategies may be required for cases
     * with a large number of duplicates around the original/space-optimal
     * split point.
     *
     * Default strategy gives some weight to suffix truncation in deciding a
     * split point on leaf pages.  It attempts to select a split point where a
     * distinguishing attribute appears earlier in the new high key for the
     * left side of the split, in order to maximize the number of trailing
     * attributes that can be truncated away.  Only candidate split points
     * that imply an acceptable balance of free space on each side are
     * considered.  See _bt_defaultinterval().
     */
    if (!state.is_leaf)
    {
        /* fillfactormult only used on rightmost page */
        usemult = state.is_rightmost;
        fillfactormult = BTREE_NONLEAF_FILLFACTOR / 100.0;
    }
    else if (state.is_rightmost)
    {
        /* Rightmost leaf page --  fillfactormult always used */
        usemult = true;
        fillfactormult = leaffillfactor / 100.0;
    }
    else if (_bt_afternewitemoff(&state, maxoff, leaffillfactor, &usemult))
    {
        /*
         * New item inserted at rightmost point among a localized grouping on
         * a leaf page -- apply "split after new item" optimization, either by
         * applying leaf fillfactor multiplier, or by choosing the exact split
         * point that leaves newitem as lastleft. (usemult is set for us.)
         */
        if (usemult)
        {
            /* fillfactormult should be set based on leaf fillfactor */
            fillfactormult = leaffillfactor / 100.0;
        }
        else
        {
            /* find precise split point after newitemoff */
            for (int i = 0; i < state.nsplits; i++)
            {
                SplitPoint *split = state.splits + i;
 
                if (split->newitemonleft &&
                    newitemoff == split->firstrightoff)
                {
                    pfree(state.splits);
                    *newitemonleft = true;
                    return newitemoff;
                }
            }
 
            /*
             * Cannot legally split after newitemoff; proceed with split
             * without using fillfactor multiplier.  This is defensive, and
             * should never be needed in practice.
             */
            fillfactormult = 0.50;
        }
    }
    else
    {
        /* Other leaf page.  50:50 page split. */
        usemult = false;
        /* fillfactormult not used, but be tidy */
        fillfactormult = 0.50;
    }
 
    /*
     * Save leftmost and rightmost splits for page before original ordinal
     * sort order is lost by delta/fillfactormult sort
     */
    leftpage = state.splits[0];
    rightpage = state.splits[state.nsplits - 1];
 
    /* Give split points a fillfactormult-wise delta, and sort on deltas */
    _bt_deltasortsplits(&state, fillfactormult, usemult);
 
    /* Determine split interval for default strategy */
    state.interval = _bt_defaultinterval(&state);
 
    /*
     * Determine if default strategy/split interval will produce a
     * sufficiently distinguishing split, or if we should change strategies.
     * Alternative strategies change the range of split points that are
     * considered acceptable (split interval), and possibly change
     * fillfactormult, in order to deal with pages with a large number of
     * duplicates gracefully.
     *
     * Pass low and high splits for the entire page (actually, they're for an
     * imaginary version of the page that includes newitem).  These are used
     * when the initial split interval encloses split points that are full of
     * duplicates, and we need to consider if it's even possible to avoid
     * appending a heap TID.
     */
    perfectpenalty = _bt_strategy(&state, &leftpage, &rightpage, &strategy);
 
    if (strategy == SPLIT_DEFAULT)
    {
        /*
         * Default strategy worked out (always works out with internal page).
         * Original split interval still stands.
         */
    }
 
    /*
     * Many duplicates strategy is used when a heap TID would otherwise be
     * appended, but the page isn't completely full of logical duplicates.
     *
     * The split interval is widened to include all legal candidate split
     * points.  There might be a few as two distinct values in the whole-page
     * split interval, though it's also possible that most of the values on
     * the page are unique.  The final split point will either be to the
     * immediate left or to the immediate right of the group of duplicate
     * tuples that enclose the first/delta-optimal split point (perfect
     * penalty was set so that the lowest delta split point that avoids
     * appending a heap TID will be chosen).  Maximizing the number of
     * attributes that can be truncated away is not a goal of the many
     * duplicates strategy.
     *
     * Single value strategy is used when it is impossible to avoid appending
     * a heap TID.  It arranges to leave the left page very full.  This
     * maximizes space utilization in cases where tuples with the same
     * attribute values span many pages.  Newly inserted duplicates will tend
     * to have higher heap TID values, so we'll end up splitting to the right
     * consistently.  (Single value strategy is harmless though not
     * particularly useful with !heapkeyspace indexes.)
     */
    else if (strategy == SPLIT_MANY_DUPLICATES)
    {
        Assert(state.is_leaf);
        /* Shouldn't try to truncate away extra user attributes */
        Assert(perfectpenalty ==
               IndexRelationGetNumberOfKeyAttributes(state.rel));
        /* No need to resort splits -- no change in fillfactormult/deltas */
        state.interval = state.nsplits;
    }
    else if (strategy == SPLIT_SINGLE_VALUE)
    {
        Assert(state.is_leaf);
        /* Split near the end of the page */
        usemult = true;
        fillfactormult = BTREE_SINGLEVAL_FILLFACTOR / 100.0;
        /* Resort split points with new delta */
        _bt_deltasortsplits(&state, fillfactormult, usemult);
        /* Appending a heap TID is unavoidable, so interval of 1 is fine */
        state.interval = 1;
    }
 
    /*
     * Search among acceptable split points (using final split interval) for
     * the entry that has the lowest penalty, and is therefore expected to
     * maximize fan-out.  Sets *newitemonleft for us.
     */
    firstrightoff = _bt_bestsplitloc(&state, perfectpenalty, newitemonleft,
                                     strategy);
    pfree(state.splits);
 
    return firstrightoff;
}

References _bt_afternewitemoff(), _bt_bestsplitloc(), _bt_defaultinterval(), _bt_deltasortsplits(), _bt_recsplitloc(), _bt_strategy(), Assert, BTGetFillFactor, BTPageGetOpaque, BTREE_NONLEAF_FILLFACTOR, BTREE_SINGLEVAL_FILLFACTOR, BTreeTupleIsPosting(), elog, ERROR, fb(), i, IndexRelationGetNumberOfKeyAttributes, ItemIdGetLength, MAXALIGN, OffsetNumberNext, P_FIRSTDATAKEY, P_HIKEY, P_ISLEAF, P_RIGHTMOST, PageGetExactFreeSpace(), PageGetItemId(), PageGetMaxOffsetNumber(), PageGetPageSize(), palloc_array, pfree(), RelationGetRelationName, SizeOfPageHeaderData, SPLIT_DEFAULT, SPLIT_MANY_DUPLICATES, and SPLIT_SINGLE_VALUE.

Referenced by _bt_split().

◆ _bt_finish_split()

void _bt_finish_split	(	Relation	rel,
		Relation	heaprel,
		Buffer	lbuf,
		BTStack	stack
	)

extern

Definition at line 2272 of file nbtinsert.c.

{
    Page        lpage = BufferGetPage(lbuf);
    BTPageOpaque lpageop = BTPageGetOpaque(lpage);
    Buffer      rbuf;
    Page        rpage;
    BTPageOpaque rpageop;
    bool        wasroot;
    bool        wasonly;
 
    Assert(P_INCOMPLETE_SPLIT(lpageop));
    Assert(heaprel != NULL);
 
    /* Lock right sibling, the one missing the downlink */
    rbuf = _bt_getbuf(rel, lpageop->btpo_next, BT_WRITE);
    rpage = BufferGetPage(rbuf);
    rpageop = BTPageGetOpaque(rpage);
 
    /* Could this be a root split? */
    if (!stack)
    {
        Buffer      metabuf;
        Page        metapg;
        BTMetaPageData *metad;
 
        /* acquire lock on the metapage */
        metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_WRITE);
        metapg = BufferGetPage(metabuf);
        metad = BTPageGetMeta(metapg);
 
        wasroot = (metad->btm_root == BufferGetBlockNumber(lbuf));
 
        _bt_relbuf(rel, metabuf);
    }
    else
        wasroot = false;
 
    /* Was this the only page on the level before split? */
    wasonly = (P_LEFTMOST(lpageop) && P_RIGHTMOST(rpageop));
 
    INJECTION_POINT("nbtree-finish-incomplete-split", NULL);
    elog(DEBUG1, "finishing incomplete split of %u/%u",
         BufferGetBlockNumber(lbuf), BufferGetBlockNumber(rbuf));
 
    _bt_insert_parent(rel, heaprel, lbuf, rbuf, stack, wasroot, wasonly);
}

References _bt_getbuf(), _bt_insert_parent(), _bt_relbuf(), Assert, BT_WRITE, BTPageGetMeta, BTPageGetOpaque, BTREE_METAPAGE, BufferGetBlockNumber(), BufferGetPage(), DEBUG1, elog, fb(), INJECTION_POINT, P_INCOMPLETE_SPLIT, P_LEFTMOST, and P_RIGHTMOST.

Referenced by _bt_getstackbuf(), _bt_moveright(), and _bt_stepright().

◆ _bt_first()

bool _bt_first	(	IndexScanDesc	scan,
		ScanDirection	dir
	)

extern

Definition at line 883 of file nbtsearch.c.

{
    Relation    rel = scan->indexRelation;
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
    OffsetNumber offnum;
    BTScanInsertData inskey;
    ScanKey     startKeys[INDEX_MAX_KEYS];
    ScanKeyData notnullkey;
    int         keysz = 0;
    StrategyNumber strat_total = InvalidStrategy;
    BlockNumber blkno = InvalidBlockNumber,
                lastcurrblkno;
 
    Assert(!BTScanPosIsValid(so->currPos));
 
    /*
     * Examine the scan keys and eliminate any redundant keys; also mark the
     * keys that must be matched to continue the scan.
     */
    _bt_preprocess_keys(scan);
 
    /*
     * Quit now if _bt_preprocess_keys() discovered that the scan keys can
     * never be satisfied (eg, x == 1 AND x > 2).
     */
    if (!so->qual_ok)
    {
        Assert(!so->needPrimScan);
        _bt_parallel_done(scan);
        return false;
    }
 
    /*
     * If this is a parallel scan, we must seize the scan.  _bt_readfirstpage
     * will likely release the parallel scan later on.
     */
    if (scan->parallel_scan != NULL &&
        !_bt_parallel_seize(scan, &blkno, &lastcurrblkno, true))
        return false;
 
    /*
     * Initialize the scan's arrays (if any) for the current scan direction
     * (except when they were already set to later values as part of
     * scheduling the primitive index scan that is now underway)
     */
    if (so->numArrayKeys && !so->needPrimScan)
        _bt_start_array_keys(scan, dir);
 
    if (blkno != InvalidBlockNumber)
    {
        /*
         * We anticipated calling _bt_search, but another worker bet us to it.
         * _bt_readnextpage releases the scan for us (not _bt_readfirstpage).
         */
        Assert(scan->parallel_scan != NULL);
        Assert(!so->needPrimScan);
        Assert(blkno != P_NONE);
 
        if (!_bt_readnextpage(scan, blkno, lastcurrblkno, dir, true))
            return false;
 
        _bt_returnitem(scan, so);
        return true;
    }
 
    /*
     * Count an indexscan for stats, now that we know that we'll call
     * _bt_search/_bt_endpoint below
     */
    pgstat_count_index_scan(rel);
    if (scan->instrument)
        scan->instrument->nsearches++;
 
    /*----------
     * Examine the scan keys to discover where we need to start the scan.
     * The selected scan keys (at most one per index column) are remembered by
     * storing their addresses into the local startKeys[] array.  The final
     * startKeys[] entry's strategy is set in strat_total. (Actually, there
     * are a couple of cases where we force a less/more restrictive strategy.)
     *
     * We must use the key that was marked required (in the direction opposite
     * our own scan's) during preprocessing.  Each index attribute can only
     * have one such required key.  In general, the keys that we use to find
     * an initial position when scanning forwards are the same keys that end
     * the scan on the leaf level when scanning backwards (and vice-versa).
     *
     * When the scan keys include cross-type operators, _bt_preprocess_keys
     * may not be able to eliminate redundant keys; in such cases it will
     * arbitrarily pick a usable key for each attribute (and scan direction),
     * ensuring that there is no more than one key required in each direction.
     * We stop considering further keys once we reach the first nonrequired
     * key (which must come after all required keys), so this can't affect us.
     *
     * The required keys that we use as starting boundaries have to be =, >,
     * or >= keys for a forward scan or =, <, <= keys for a backwards scan.
     * We can use keys for multiple attributes so long as the prior attributes
     * had only =, >= (resp. =, <=) keys.  These rules are very similar to the
     * rules that preprocessing used to determine which keys to mark required.
     * We cannot always use every required key as a positioning key, though.
     * Skip arrays necessitate independently applying our own rules here.
     * Skip arrays are always generally considered = array keys, but we'll
     * nevertheless treat them as inequalities at certain points of the scan.
     * When that happens, it _might_ have implications for the number of
     * required keys that we can safely use for initial positioning purposes.
     *
     * For example, a forward scan with a skip array on its leading attribute
     * (with no low_compare/high_compare) will have at least two required scan
     * keys, but we won't use any of them as boundary keys during the scan's
     * initial call here.  Our positioning key during the first call here can
     * be thought of as representing "> -infinity".  Similarly, if such a skip
     * array's low_compare is "a > 'foo'", then we position using "a > 'foo'"
     * during the scan's initial call here; a lower-order key such as "b = 42"
     * can't be used until the "a" array advances beyond MINVAL/low_compare.
     *
     * On the other hand, if such a skip array's low_compare was "a >= 'foo'",
     * then we _can_ use "a >= 'foo' AND b = 42" during the initial call here.
     * A subsequent call here might have us use "a = 'fop' AND b = 42".  Note
     * that we treat = and >= as equivalent when scanning forwards (just as we
     * treat = and <= as equivalent when scanning backwards).  We effectively
     * do the same thing (though with a distinct "a" element/value) each time.
     *
     * All keys (with the exception of SK_SEARCHNULL keys and SK_BT_SKIP
     * array keys whose array is "null_elem=true") imply a NOT NULL qualifier.
     * If the index stores nulls at the end of the index we'll be starting
     * from, and we have no boundary key for the column (which means the key
     * we deduced NOT NULL from is an inequality key that constrains the other
     * end of the index), then we cons up an explicit SK_SEARCHNOTNULL key to
     * use as a boundary key.  If we didn't do this, we might find ourselves
     * traversing a lot of null entries at the start of the scan.
     *
     * In this loop, row-comparison keys are treated the same as keys on their
     * first (leftmost) columns.  We'll add all lower-order columns of the row
     * comparison that were marked required during preprocessing below.
     *
     * _bt_advance_array_keys needs to know exactly how we'll reposition the
     * scan (should it opt to schedule another primitive index scan).  It is
     * critical that primscans only be scheduled when they'll definitely make
     * some useful progress.  _bt_advance_array_keys does this by calling
     * _bt_checkkeys routines that report whether a tuple is past the end of
     * matches for the scan's keys (given the scan's current array elements).
     * If the page's final tuple is "after the end of matches" for a scan that
     * uses the *opposite* scan direction, then it must follow that it's also
     * "before the start of matches" for the actual current scan direction.
     * It is therefore essential that all of our initial positioning rules are
     * symmetric with _bt_checkkeys's corresponding continuescan=false rule.
     * If you update anything here, _bt_checkkeys/_bt_advance_array_keys might
     * need to be kept in sync.
     *----------
     */
    if (so->numberOfKeys > 0)
    {
        AttrNumber  curattr;
        ScanKey     bkey;
        ScanKey     impliesNN;
        ScanKey     cur;
 
        /*
         * bkey will be set to the key that preprocessing left behind as the
         * boundary key for this attribute, in this scan direction (if any)
         */
        cur = so->keyData;
        curattr = 1;
        bkey = NULL;
        /* Also remember any scankey that implies a NOT NULL constraint */
        impliesNN = NULL;
 
        /*
         * Loop iterates from 0 to numberOfKeys inclusive; we use the last
         * pass to handle after-last-key processing.  Actual exit from the
         * loop is at one of the "break" statements below.
         */
        for (int i = 0;; cur++, i++)
        {
            if (i >= so->numberOfKeys || cur->sk_attno != curattr)
            {
                /* Done looking for the curattr boundary key */
                Assert(bkey == NULL ||
                       (bkey->sk_attno == curattr &&
                        (bkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD))));
                Assert(impliesNN == NULL ||
                       (impliesNN->sk_attno == curattr &&
                        (impliesNN->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD))));
 
                /*
                 * If this is a scan key for a skip array whose current
                 * element is MINVAL, choose low_compare (when scanning
                 * backwards it'll be MAXVAL, and we'll choose high_compare).
                 *
                 * Note: if the array's low_compare key makes 'bkey' NULL,
                 * then we behave as if the array's first element is -inf,
                 * except when !array->null_elem implies a usable NOT NULL
                 * constraint.
                 */
                if (bkey != NULL &&
                    (bkey->sk_flags & (SK_BT_MINVAL | SK_BT_MAXVAL)))
                {
                    int         ikey = bkey - so->keyData;
                    ScanKey     skipequalitykey = bkey;
                    BTArrayKeyInfo *array = NULL;
 
                    for (int arridx = 0; arridx < so->numArrayKeys; arridx++)
                    {
                        array = &so->arrayKeys[arridx];
                        if (array->scan_key == ikey)
                            break;
                    }
 
                    if (ScanDirectionIsForward(dir))
                    {
                        Assert(!(skipequalitykey->sk_flags & SK_BT_MAXVAL));
                        bkey = array->low_compare;
                    }
                    else
                    {
                        Assert(!(skipequalitykey->sk_flags & SK_BT_MINVAL));
                        bkey = array->high_compare;
                    }
 
                    Assert(bkey == NULL ||
                           bkey->sk_attno == skipequalitykey->sk_attno);
 
                    if (!array->null_elem)
                        impliesNN = skipequalitykey;
                    else
                        Assert(bkey == NULL && impliesNN == NULL);
                }
 
                /*
                 * If we didn't find a usable boundary key, see if we can
                 * deduce a NOT NULL key
                 */
                if (bkey == NULL && impliesNN != NULL &&
                    ((impliesNN->sk_flags & SK_BT_NULLS_FIRST) ?
                     ScanDirectionIsForward(dir) :
                     ScanDirectionIsBackward(dir)))
                {
                    /* Final startKeys[] entry will be deduced NOT NULL key */
                    bkey = &notnullkey;
                    ScanKeyEntryInitialize(bkey,
                                           (SK_SEARCHNOTNULL | SK_ISNULL |
                                            (impliesNN->sk_flags &
                                             (SK_BT_DESC | SK_BT_NULLS_FIRST))),
                                           curattr,
                                           ScanDirectionIsForward(dir) ?
                                           BTGreaterStrategyNumber : BTLessStrategyNumber,
                                           InvalidOid,
                                           InvalidOid,
                                           InvalidOid,
                                           (Datum) 0);
                }
 
                /*
                 * If preprocessing didn't leave a usable boundary key, quit;
                 * else save the boundary key pointer in startKeys[]
                 */
                if (bkey == NULL)
                    break;
                startKeys[keysz++] = bkey;
 
                /*
                 * We can only consider adding more boundary keys when the one
                 * that we just chose to add uses either the = or >= strategy
                 * (during backwards scans we can only do so when the key that
                 * we just added to startKeys[] uses the = or <= strategy)
                 */
                strat_total = bkey->sk_strategy;
                if (strat_total == BTGreaterStrategyNumber ||
                    strat_total == BTLessStrategyNumber)
                    break;
 
                /*
                 * If the key that we just added to startKeys[] is a skip
                 * array = key whose current element is marked NEXT or PRIOR,
                 * make strat_total > or < (and stop adding boundary keys).
                 * This can only happen with opclasses that lack skip support.
                 */
                if (bkey->sk_flags & (SK_BT_NEXT | SK_BT_PRIOR))
                {
                    Assert(bkey->sk_flags & SK_BT_SKIP);
                    Assert(strat_total == BTEqualStrategyNumber);
 
                    if (ScanDirectionIsForward(dir))
                    {
                        Assert(!(bkey->sk_flags & SK_BT_PRIOR));
                        strat_total = BTGreaterStrategyNumber;
                    }
                    else
                    {
                        Assert(!(bkey->sk_flags & SK_BT_NEXT));
                        strat_total = BTLessStrategyNumber;
                    }
 
                    /*
                     * We're done.  We'll never find an exact = match for a
                     * NEXT or PRIOR sentinel sk_argument value.  There's no
                     * sense in trying to add more keys to startKeys[].
                     */
                    break;
                }
 
                /*
                 * Done if that was the last scan key output by preprocessing.
                 * Also done if we've now examined all keys marked required.
                 */
                if (i >= so->numberOfKeys ||
                    !(cur->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)))
                    break;
 
                /*
                 * Reset for next attr.
                 */
                Assert(cur->sk_attno == curattr + 1);
                curattr = cur->sk_attno;
                bkey = NULL;
                impliesNN = NULL;
            }
 
            /*
             * If we've located the starting boundary key for curattr, we have
             * no interest in curattr's other required key
             */
            if (bkey != NULL)
                continue;
 
            /*
             * Is this key the starting boundary key for curattr?
             *
             * If not, does it imply a NOT NULL constraint?  (Because
             * SK_SEARCHNULL keys are always assigned BTEqualStrategyNumber,
             * *any* inequality key works for that; we need not test.)
             */
            switch (cur->sk_strategy)
            {
                case BTLessStrategyNumber:
                case BTLessEqualStrategyNumber:
                    if (ScanDirectionIsBackward(dir))
                        bkey = cur;
                    else if (impliesNN == NULL)
                        impliesNN = cur;
                    break;
                case BTEqualStrategyNumber:
                    bkey = cur;
                    break;
                case BTGreaterEqualStrategyNumber:
                case BTGreaterStrategyNumber:
                    if (ScanDirectionIsForward(dir))
                        bkey = cur;
                    else if (impliesNN == NULL)
                        impliesNN = cur;
                    break;
            }
        }
    }
 
    /*
     * If we found no usable boundary keys, we have to start from one end of
     * the tree.  Walk down that edge to the first or last key, and scan from
     * there.
     *
     * Note: calls _bt_readfirstpage for us, which releases the parallel scan.
     */
    if (keysz == 0)
        return _bt_endpoint(scan, dir);
 
    /*
     * We want to start the scan somewhere within the index.  Set up an
     * insertion scankey we can use to search for the boundary point we
     * identified above.  The insertion scankey is built using the keys
     * identified by startKeys[].  (Remaining insertion scankey fields are
     * initialized after initial-positioning scan keys are finalized.)
     */
    Assert(keysz <= INDEX_MAX_KEYS);
    for (int i = 0; i < keysz; i++)
    {
        ScanKey     bkey = startKeys[i];
 
        Assert(bkey->sk_attno == i + 1);
 
        if (bkey->sk_flags & SK_ROW_HEADER)
        {
            /*
             * Row comparison header: look to the first row member instead
             */
            ScanKey     subkey = (ScanKey) DatumGetPointer(bkey->sk_argument);
            bool        loosen_strat = false,
                        tighten_strat = false;
 
            /*
             * Cannot be a NULL in the first row member: _bt_preprocess_keys
             * would've marked the qual as unsatisfiable, preventing us from
             * ever getting this far
             */
            Assert(subkey->sk_flags & SK_ROW_MEMBER);
            Assert(subkey->sk_attno == bkey->sk_attno);
            Assert(!(subkey->sk_flags & SK_ISNULL));
 
            /*
             * This is either a > or >= key (during backwards scans it is
             * either < or <=) that was marked required during preprocessing.
             * Later so->keyData[] keys can't have been marked required, so
             * our row compare header key must be the final startKeys[] entry.
             */
            Assert(subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD));
            Assert(subkey->sk_strategy == bkey->sk_strategy);
            Assert(subkey->sk_strategy == strat_total);
            Assert(i == keysz - 1);
 
            /*
             * The member scankeys are already in insertion format (ie, they
             * have sk_func = 3-way-comparison function)
             */
            memcpy(inskey.scankeys + i, subkey, sizeof(ScanKeyData));
 
            /*
             * Now look to later row compare members.
             *
             * If there's an "index attribute gap" between two row compare
             * members, the second member won't have been marked required, and
             * so can't be used as a starting boundary key here.  The part of
             * the row comparison that we do still use has to be treated as a
             * ">=" or "<=" condition.  For example, a qual "(a, c) > (1, 42)"
             * with an omitted intervening index attribute "b" will use an
             * insertion scan key "a >= 1".  Even the first "a = 1" tuple on
             * the leaf level might satisfy the row compare qual.
             *
             * We're able to use a _more_ restrictive strategy when we reach a
             * NULL row compare member, since they're always unsatisfiable.
             * For example, a qual "(a, b, c) >= (1, NULL, 77)" will use an
             * insertion scan key "a > 1".  All tuples where "a = 1" cannot
             * possibly satisfy the row compare qual, so this is safe.
             */
            Assert(!(subkey->sk_flags & SK_ROW_END));
            for (;;)
            {
                subkey++;
                Assert(subkey->sk_flags & SK_ROW_MEMBER);
 
                if (subkey->sk_flags & SK_ISNULL)
                {
                    /*
                     * NULL member key, can only use earlier keys.
                     *
                     * We deliberately avoid checking if this key is marked
                     * required.  All earlier keys are required, and this key
                     * is unsatisfiable either way, so we can't miss anything.
                     */
                    tighten_strat = true;
                    break;
                }
 
                if (!(subkey->sk_flags & (SK_BT_REQFWD | SK_BT_REQBKWD)))
                {
                    /* nonrequired member key, can only use earlier keys */
                    loosen_strat = true;
                    break;
                }
 
                Assert(subkey->sk_attno == keysz + 1);
                Assert(subkey->sk_strategy == bkey->sk_strategy);
                Assert(keysz < INDEX_MAX_KEYS);
 
                memcpy(inskey.scankeys + keysz, subkey, sizeof(ScanKeyData));
                keysz++;
 
                if (subkey->sk_flags & SK_ROW_END)
                    break;
            }
            Assert(!(loosen_strat && tighten_strat));
            if (loosen_strat)
            {
                /* Use less restrictive strategy (and fewer member keys) */
                switch (strat_total)
                {
                    case BTLessStrategyNumber:
                        strat_total = BTLessEqualStrategyNumber;
                        break;
                    case BTGreaterStrategyNumber:
                        strat_total = BTGreaterEqualStrategyNumber;
                        break;
                }
            }
            if (tighten_strat)
            {
                /* Use more restrictive strategy (and fewer member keys) */
                switch (strat_total)
                {
                    case BTLessEqualStrategyNumber:
                        strat_total = BTLessStrategyNumber;
                        break;
                    case BTGreaterEqualStrategyNumber:
                        strat_total = BTGreaterStrategyNumber;
                        break;
                }
            }
 
            /* Done (row compare header key is always last startKeys[] key) */
            break;
        }
 
        /*
         * Ordinary comparison key/search-style key.
         *
         * Transform the search-style scan key to an insertion scan key by
         * replacing the sk_func with the appropriate btree 3-way-comparison
         * function.
         *
         * If scankey operator is not a cross-type comparison, we can use the
         * cached comparison function; otherwise gotta look it up in the
         * catalogs.  (That can't lead to infinite recursion, since no
         * indexscan initiated by syscache lookup will use cross-data-type
         * operators.)
         *
         * We support the convention that sk_subtype == InvalidOid means the
         * opclass input type; this hack simplifies life for ScanKeyInit().
         */
        if (bkey->sk_subtype == rel->rd_opcintype[i] ||
            bkey->sk_subtype == InvalidOid)
        {
            FmgrInfo   *procinfo;
 
            procinfo = index_getprocinfo(rel, bkey->sk_attno, BTORDER_PROC);
            ScanKeyEntryInitializeWithInfo(inskey.scankeys + i,
                                           bkey->sk_flags,
                                           bkey->sk_attno,
                                           InvalidStrategy,
                                           bkey->sk_subtype,
                                           bkey->sk_collation,
                                           procinfo,
                                           bkey->sk_argument);
        }
        else
        {
            RegProcedure cmp_proc;
 
            cmp_proc = get_opfamily_proc(rel->rd_opfamily[i],
                                         rel->rd_opcintype[i],
                                         bkey->sk_subtype, BTORDER_PROC);
            if (!RegProcedureIsValid(cmp_proc))
                elog(ERROR, "missing support function %d(%u,%u) for attribute %d of index \"%s\"",
                     BTORDER_PROC, rel->rd_opcintype[i], bkey->sk_subtype,
                     bkey->sk_attno, RelationGetRelationName(rel));
            ScanKeyEntryInitialize(inskey.scankeys + i,
                                   bkey->sk_flags,
                                   bkey->sk_attno,
                                   InvalidStrategy,
                                   bkey->sk_subtype,
                                   bkey->sk_collation,
                                   cmp_proc,
                                   bkey->sk_argument);
        }
    }
 
    /*----------
     * Examine the selected initial-positioning strategy to determine exactly
     * where we need to start the scan, and set flag variables to control the
     * initial descent by _bt_search (and our _bt_binsrch call for the leaf
     * page _bt_search returns).
     *----------
     */
    _bt_metaversion(rel, &inskey.heapkeyspace, &inskey.allequalimage);
    inskey.anynullkeys = false; /* unused */
    inskey.scantid = NULL;
    inskey.keysz = keysz;
    switch (strat_total)
    {
        case BTLessStrategyNumber:
 
            inskey.nextkey = false;
            inskey.backward = true;
            break;
 
        case BTLessEqualStrategyNumber:
 
            inskey.nextkey = true;
            inskey.backward = true;
            break;
 
        case BTEqualStrategyNumber:
 
            /*
             * If a backward scan was specified, need to start with last equal
             * item not first one.
             */
            if (ScanDirectionIsBackward(dir))
            {
                /*
                 * This is the same as the <= strategy
                 */
                inskey.nextkey = true;
                inskey.backward = true;
            }
            else
            {
                /*
                 * This is the same as the >= strategy
                 */
                inskey.nextkey = false;
                inskey.backward = false;
            }
            break;
 
        case BTGreaterEqualStrategyNumber:
 
            /*
             * Find first item >= scankey
             */
            inskey.nextkey = false;
            inskey.backward = false;
            break;
 
        case BTGreaterStrategyNumber:
 
            /*
             * Find first item > scankey
             */
            inskey.nextkey = true;
            inskey.backward = false;
            break;
 
        default:
            /* can't get here, but keep compiler quiet */
            elog(ERROR, "unrecognized strat_total: %d", (int) strat_total);
            return false;
    }
 
    /*
     * Use the manufactured insertion scan key to descend the tree and
     * position ourselves on the target leaf page.
     */
    Assert(ScanDirectionIsBackward(dir) == inskey.backward);
    _bt_search(rel, NULL, &inskey, &so->currPos.buf, BT_READ, false);
 
    if (!BufferIsValid(so->currPos.buf))
    {
        Assert(!so->needPrimScan);
 
        /*
         * We only get here if the index is completely empty. Lock relation
         * because nothing finer to lock exists.  Without a buffer lock, it's
         * possible for another transaction to insert data between
         * _bt_search() and PredicateLockRelation().  We have to try again
         * after taking the relation-level predicate lock, to close a narrow
         * window where we wouldn't scan concurrently inserted tuples, but the
         * writer wouldn't see our predicate lock.
         */
        if (IsolationIsSerializable())
        {
            PredicateLockRelation(rel, scan->xs_snapshot);
            _bt_search(rel, NULL, &inskey, &so->currPos.buf, BT_READ, false);
        }
 
        if (!BufferIsValid(so->currPos.buf))
        {
            _bt_parallel_done(scan);
            return false;
        }
    }
 
    /* position to the precise item on the page */
    offnum = _bt_binsrch(rel, &inskey, so->currPos.buf);
 
    /*
     * Now load data from the first page of the scan (usually the page
     * currently in so->currPos.buf).
     *
     * If inskey.nextkey = false and inskey.backward = false, offnum is
     * positioned at the first non-pivot tuple >= inskey.scankeys.
     *
     * If inskey.nextkey = false and inskey.backward = true, offnum is
     * positioned at the last non-pivot tuple < inskey.scankeys.
     *
     * If inskey.nextkey = true and inskey.backward = false, offnum is
     * positioned at the first non-pivot tuple > inskey.scankeys.
     *
     * If inskey.nextkey = true and inskey.backward = true, offnum is
     * positioned at the last non-pivot tuple <= inskey.scankeys.
     *
     * It's possible that _bt_binsrch returned an offnum that is out of bounds
     * for the page.  For example, when inskey is both < the leaf page's high
     * key and > all of its non-pivot tuples, offnum will be "maxoff + 1".
     */
    if (!_bt_readfirstpage(scan, offnum, dir))
        return false;
 
    _bt_returnitem(scan, so);
    return true;
}

References _bt_binsrch(), _bt_endpoint(), _bt_metaversion(), _bt_parallel_done(), _bt_parallel_seize(), _bt_preprocess_keys(), _bt_readfirstpage(), _bt_readnextpage(), _bt_returnitem(), _bt_search(), _bt_start_array_keys(), BTScanInsertData::allequalimage, BTScanInsertData::anynullkeys, Assert, BTScanInsertData::backward, BT_READ, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, BTORDER_PROC, BTScanPosIsValid, BufferIsValid(), cur, DatumGetPointer(), elog, ERROR, fb(), get_opfamily_proc(), BTScanInsertData::heapkeyspace, BTArrayKeyInfo::high_compare, i, index_getprocinfo(), INDEX_MAX_KEYS, IndexScanDescData::indexRelation, IndexScanDescData::instrument, InvalidBlockNumber, InvalidOid, InvalidStrategy, IsolationIsSerializable, BTScanInsertData::keysz, BTArrayKeyInfo::low_compare, memcpy(), BTScanInsertData::nextkey, IndexScanInstrumentation::nsearches, BTArrayKeyInfo::null_elem, IndexScanDescData::opaque, P_NONE, IndexScanDescData::parallel_scan, pgstat_count_index_scan, PredicateLockRelation(), RelationData::rd_opcintype, RelationData::rd_opfamily, RegProcedureIsValid, RelationGetRelationName, BTArrayKeyInfo::scan_key, ScanDirectionIsBackward, ScanDirectionIsForward, ScanKeyEntryInitialize(), ScanKeyEntryInitializeWithInfo(), BTScanInsertData::scankeys, BTScanInsertData::scantid, SK_BT_DESC, SK_BT_MAXVAL, SK_BT_MINVAL, SK_BT_NEXT, SK_BT_NULLS_FIRST, SK_BT_PRIOR, SK_BT_REQBKWD, SK_BT_REQFWD, SK_BT_SKIP, ScanKeyData::sk_flags, SK_ISNULL, SK_ROW_END, SK_ROW_HEADER, SK_ROW_MEMBER, SK_SEARCHNOTNULL, and IndexScanDescData::xs_snapshot.

Referenced by btgetbitmap(), and btgettuple().

◆ _bt_form_posting()

IndexTuple _bt_form_posting	(	IndexTuple	base,
		const ItemPointerData *	htids,
		int	nhtids
	)

extern

Definition at line 864 of file nbtdedup.c.

{
    uint32      keysize,
                newsize;
    IndexTuple  itup;
 
    if (BTreeTupleIsPosting(base))
        keysize = BTreeTupleGetPostingOffset(base);
    else
        keysize = IndexTupleSize(base);
 
    Assert(!BTreeTupleIsPivot(base));
    Assert(nhtids > 0 && nhtids <= PG_UINT16_MAX);
    Assert(keysize == MAXALIGN(keysize));
 
    /* Determine final size of new tuple */
    if (nhtids > 1)
        newsize = MAXALIGN(keysize +
                           nhtids * sizeof(ItemPointerData));
    else
        newsize = keysize;
 
    Assert(newsize <= INDEX_SIZE_MASK);
    Assert(newsize == MAXALIGN(newsize));
 
    /* Allocate memory using palloc0() (matches index_form_tuple()) */
    itup = palloc0(newsize);
    memcpy(itup, base, keysize);
    itup->t_info &= ~INDEX_SIZE_MASK;
    itup->t_info |= newsize;
    if (nhtids > 1)
    {
        /* Form posting list tuple */
        BTreeTupleSetPosting(itup, nhtids, keysize);
        memcpy(BTreeTupleGetPosting(itup), htids,
               sizeof(ItemPointerData) * nhtids);
        Assert(_bt_posting_valid(itup));
    }
    else
    {
        /* Form standard non-pivot tuple */
        itup->t_info &= ~INDEX_ALT_TID_MASK;
        ItemPointerCopy(htids, &itup->t_tid);
        Assert(ItemPointerIsValid(&itup->t_tid));
    }
 
    return itup;
}

References Assert, BTreeTupleGetPosting(), BTreeTupleGetPostingOffset(), BTreeTupleIsPivot(), BTreeTupleIsPosting(), BTreeTupleSetPosting(), fb(), INDEX_SIZE_MASK, IndexTupleSize(), ItemPointerCopy(), ItemPointerIsValid(), MAXALIGN, memcpy(), palloc0(), PG_UINT16_MAX, IndexTupleData::t_info, and IndexTupleData::t_tid.

Referenced by _bt_dedup_finish_pending(), _bt_sort_dedup_finish_pending(), and bt_posting_plain_tuple().

◆ _bt_get_endpoint()

Buffer _bt_get_endpoint	(	Relation	rel,
		uint32	level,
		bool	rightmost
	)

extern

Definition at line 2092 of file nbtsearch.c.

{
    Buffer      buf;
    Page        page;
    BTPageOpaque opaque;
    OffsetNumber offnum;
    BlockNumber blkno;
    IndexTuple  itup;
 
    /*
     * If we are looking for a leaf page, okay to descend from fast root;
     * otherwise better descend from true root.  (There is no point in being
     * smarter about intermediate levels.)
     */
    if (level == 0)
        buf = _bt_getroot(rel, NULL, BT_READ);
    else
        buf = _bt_gettrueroot(rel);
 
    if (!BufferIsValid(buf))
        return InvalidBuffer;
 
    page = BufferGetPage(buf);
    opaque = BTPageGetOpaque(page);
 
    for (;;)
    {
        /*
         * If we landed on a deleted page, step right to find a live page
         * (there must be one).  Also, if we want the rightmost page, step
         * right if needed to get to it (this could happen if the page split
         * since we obtained a pointer to it).
         */
        while (P_IGNORE(opaque) ||
               (rightmost && !P_RIGHTMOST(opaque)))
        {
            blkno = opaque->btpo_next;
            if (blkno == P_NONE)
                elog(ERROR, "fell off the end of index \"%s\"",
                     RelationGetRelationName(rel));
            buf = _bt_relandgetbuf(rel, buf, blkno, BT_READ);
            page = BufferGetPage(buf);
            opaque = BTPageGetOpaque(page);
        }
 
        /* Done? */
        if (opaque->btpo_level == level)
            break;
        if (opaque->btpo_level < level)
            ereport(ERROR,
                    (errcode(ERRCODE_INDEX_CORRUPTED),
                     errmsg_internal("btree level %u not found in index \"%s\"",
                                     level, RelationGetRelationName(rel))));
 
        /* Descend to leftmost or rightmost child page */
        if (rightmost)
            offnum = PageGetMaxOffsetNumber(page);
        else
            offnum = P_FIRSTDATAKEY(opaque);
 
        if (offnum < 1 || offnum > PageGetMaxOffsetNumber(page))
            elog(PANIC, "offnum out of range");
 
        itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offnum));
        blkno = BTreeTupleGetDownLink(itup);
 
        buf = _bt_relandgetbuf(rel, buf, blkno, BT_READ);
        page = BufferGetPage(buf);
        opaque = BTPageGetOpaque(page);
    }
 
    return buf;
}

References _bt_getroot(), _bt_gettrueroot(), _bt_relandgetbuf(), BT_READ, BTPageGetOpaque, BTPageOpaqueData::btpo_level, BTPageOpaqueData::btpo_next, BTreeTupleGetDownLink(), buf, BufferGetPage(), BufferIsValid(), elog, ereport, errcode(), errmsg_internal(), ERROR, fb(), InvalidBuffer, P_FIRSTDATAKEY, P_IGNORE, P_NONE, P_RIGHTMOST, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PANIC, and RelationGetRelationName.

Referenced by _bt_endpoint(), and _bt_insert_parent().

◆ _bt_getbuf()

Buffer _bt_getbuf	(	Relation	rel,
		BlockNumber	blkno,
		int	access
	)

extern

Definition at line 850 of file nbtpage.c.

{
    Buffer      buf;
 
    Assert(BlockNumberIsValid(blkno));
 
    /* Read an existing block of the relation */
    buf = ReadBuffer(rel, blkno);
    _bt_lockbuf(rel, buf, access);
    _bt_checkpage(rel, buf);
 
    return buf;
}

References _bt_checkpage(), _bt_lockbuf(), Assert, BlockNumberIsValid(), buf, and ReadBuffer().

Referenced by _bt_finish_split(), _bt_getroot(), _bt_getrootheight(), _bt_getstackbuf(), _bt_gettrueroot(), _bt_insertonpg(), _bt_killitems(), _bt_leftsib_splitflag(), _bt_lock_and_validate_left(), _bt_metaversion(), _bt_moveright(), _bt_newlevel(), _bt_pagedel(), _bt_readnextpage(), _bt_rightsib_halfdeadflag(), _bt_set_cleanup_info(), _bt_split(), _bt_unlink_halfdead_page(), and _bt_vacuum_needs_cleanup().

◆ _bt_getroot()

Buffer _bt_getroot	(	Relation	rel,
		Relation	heaprel,
		int	access
	)

extern

Definition at line 347 of file nbtpage.c.

{
    Buffer      metabuf;
    Buffer      rootbuf;
    Page        rootpage;
    BTPageOpaque rootopaque;
    BlockNumber rootblkno;
    uint32      rootlevel;
    BTMetaPageData *metad;
    XLogRecPtr  recptr;
 
    Assert(access == BT_READ || heaprel != NULL);
 
    /*
     * Try to use previously-cached metapage data to find the root.  This
     * normally saves one buffer access per index search, which is a very
     * helpful savings in bufmgr traffic and hence contention.
     */
    if (rel->rd_amcache != NULL)
    {
        metad = (BTMetaPageData *) rel->rd_amcache;
        /* We shouldn't have cached it if any of these fail */
        Assert(metad->btm_magic == BTREE_MAGIC);
        Assert(metad->btm_version >= BTREE_MIN_VERSION);
        Assert(metad->btm_version <= BTREE_VERSION);
        Assert(!metad->btm_allequalimage ||
               metad->btm_version > BTREE_NOVAC_VERSION);
        Assert(metad->btm_root != P_NONE);
 
        rootblkno = metad->btm_fastroot;
        Assert(rootblkno != P_NONE);
        rootlevel = metad->btm_fastlevel;
 
        rootbuf = _bt_getbuf(rel, rootblkno, BT_READ);
        rootpage = BufferGetPage(rootbuf);
        rootopaque = BTPageGetOpaque(rootpage);
 
        /*
         * Since the cache might be stale, we check the page more carefully
         * here than normal.  We *must* check that it's not deleted. If it's
         * not alone on its level, then we reject too --- this may be overly
         * paranoid but better safe than sorry.  Note we don't check P_ISROOT,
         * because that's not set in a "fast root".
         */
        if (!P_IGNORE(rootopaque) &&
            rootopaque->btpo_level == rootlevel &&
            P_LEFTMOST(rootopaque) &&
            P_RIGHTMOST(rootopaque))
        {
            /* OK, accept cached page as the root */
            return rootbuf;
        }
        _bt_relbuf(rel, rootbuf);
        /* Cache is stale, throw it away */
        if (rel->rd_amcache)
            pfree(rel->rd_amcache);
        rel->rd_amcache = NULL;
    }
 
    metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_READ);
    metad = _bt_getmeta(rel, metabuf);
 
    /* if no root page initialized yet, do it */
    if (metad->btm_root == P_NONE)
    {
        Page        metapg;
 
        /* If access = BT_READ, caller doesn't want us to create root yet */
        if (access == BT_READ)
        {
            _bt_relbuf(rel, metabuf);
            return InvalidBuffer;
        }
 
        /* trade in our read lock for a write lock */
        _bt_unlockbuf(rel, metabuf);
        _bt_lockbuf(rel, metabuf, BT_WRITE);
 
        /*
         * Race condition:  if someone else initialized the metadata between
         * the time we released the read lock and acquired the write lock, we
         * must avoid doing it again.
         */
        if (metad->btm_root != P_NONE)
        {
            /*
             * Metadata initialized by someone else.  In order to guarantee no
             * deadlocks, we have to release the metadata page and start all
             * over again.  (Is that really true? But it's hardly worth trying
             * to optimize this case.)
             */
            _bt_relbuf(rel, metabuf);
            return _bt_getroot(rel, heaprel, access);
        }
 
        /*
         * Get, initialize, write, and leave a lock of the appropriate type on
         * the new root page.  Since this is the first page in the tree, it's
         * a leaf as well as the root.
         */
        rootbuf = _bt_allocbuf(rel, heaprel);
        rootblkno = BufferGetBlockNumber(rootbuf);
        rootpage = BufferGetPage(rootbuf);
        rootopaque = BTPageGetOpaque(rootpage);
        rootopaque->btpo_prev = rootopaque->btpo_next = P_NONE;
        rootopaque->btpo_flags = (BTP_LEAF | BTP_ROOT);
        rootopaque->btpo_level = 0;
        rootopaque->btpo_cycleid = 0;
        /* Get raw page pointer for metapage */
        metapg = BufferGetPage(metabuf);
 
        /* NO ELOG(ERROR) till meta is updated */
        START_CRIT_SECTION();
 
        /* upgrade metapage if needed */
        if (metad->btm_version < BTREE_NOVAC_VERSION)
            _bt_upgrademetapage(metapg);
 
        metad->btm_root = rootblkno;
        metad->btm_level = 0;
        metad->btm_fastroot = rootblkno;
        metad->btm_fastlevel = 0;
        metad->btm_last_cleanup_num_delpages = 0;
        metad->btm_last_cleanup_num_heap_tuples = -1.0;
 
        MarkBufferDirty(rootbuf);
        MarkBufferDirty(metabuf);
 
        /* XLOG stuff */
        if (RelationNeedsWAL(rel))
        {
            xl_btree_newroot xlrec;
            xl_btree_metadata md;
 
            XLogBeginInsert();
            XLogRegisterBuffer(0, rootbuf, REGBUF_WILL_INIT);
            XLogRegisterBuffer(2, metabuf, REGBUF_WILL_INIT | REGBUF_STANDARD);
 
            Assert(metad->btm_version >= BTREE_NOVAC_VERSION);
            md.version = metad->btm_version;
            md.root = rootblkno;
            md.level = 0;
            md.fastroot = rootblkno;
            md.fastlevel = 0;
            md.last_cleanup_num_delpages = 0;
            md.allequalimage = metad->btm_allequalimage;
 
            XLogRegisterBufData(2, &md, sizeof(xl_btree_metadata));
 
            xlrec.rootblk = rootblkno;
            xlrec.level = 0;
 
            XLogRegisterData(&xlrec, SizeOfBtreeNewroot);
 
            recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_NEWROOT);
        }
        else
            recptr = XLogGetFakeLSN(rel);
 
        PageSetLSN(rootpage, recptr);
        PageSetLSN(metapg, recptr);
 
        END_CRIT_SECTION();
 
        /*
         * swap root write lock for read lock.  There is no danger of anyone
         * else accessing the new root page while it's unlocked, since no one
         * else knows where it is yet.
         */
        _bt_unlockbuf(rel, rootbuf);
        _bt_lockbuf(rel, rootbuf, BT_READ);
 
        /* okay, metadata is correct, release lock on it without caching */
        _bt_relbuf(rel, metabuf);
    }
    else
    {
        rootblkno = metad->btm_fastroot;
        Assert(rootblkno != P_NONE);
        rootlevel = metad->btm_fastlevel;
 
        /*
         * Cache the metapage data for next time
         */
        rel->rd_amcache = MemoryContextAlloc(rel->rd_indexcxt,
                                             sizeof(BTMetaPageData));
        memcpy(rel->rd_amcache, metad, sizeof(BTMetaPageData));
 
        /*
         * We are done with the metapage; arrange to release it via first
         * _bt_relandgetbuf call
         */
        rootbuf = metabuf;
 
        for (;;)
        {
            rootbuf = _bt_relandgetbuf(rel, rootbuf, rootblkno, BT_READ);
            rootpage = BufferGetPage(rootbuf);
            rootopaque = BTPageGetOpaque(rootpage);
 
            if (!P_IGNORE(rootopaque))
                break;
 
            /* it's dead, Jim.  step right one page */
            if (P_RIGHTMOST(rootopaque))
                elog(ERROR, "no live root page found in index \"%s\"",
                     RelationGetRelationName(rel));
            rootblkno = rootopaque->btpo_next;
        }
 
        if (rootopaque->btpo_level != rootlevel)
            elog(ERROR, "root page %u of index \"%s\" has level %u, expected %u",
                 rootblkno, RelationGetRelationName(rel),
                 rootopaque->btpo_level, rootlevel);
    }
 
    /*
     * By here, we have a pin and read lock on the root page, and no lock set
     * on the metadata page.  Return the root page's buffer.
     */
    return rootbuf;
}

References _bt_allocbuf(), _bt_getbuf(), _bt_getmeta(), _bt_getroot(), _bt_lockbuf(), _bt_relandgetbuf(), _bt_relbuf(), _bt_unlockbuf(), _bt_upgrademetapage(), xl_btree_metadata::allequalimage, Assert, BT_READ, BT_WRITE, BTP_LEAF, BTP_ROOT, BTPageGetOpaque, BTREE_MAGIC, BTREE_METAPAGE, BTREE_MIN_VERSION, BTREE_NOVAC_VERSION, BTREE_VERSION, BufferGetBlockNumber(), BufferGetPage(), elog, END_CRIT_SECTION, ERROR, xl_btree_metadata::fastlevel, xl_btree_metadata::fastroot, fb(), InvalidBuffer, xl_btree_metadata::last_cleanup_num_delpages, xl_btree_metadata::level, MarkBufferDirty(), memcpy(), MemoryContextAlloc(), P_IGNORE, P_LEFTMOST, P_NONE, P_RIGHTMOST, PageSetLSN(), pfree(), RelationData::rd_amcache, RelationData::rd_indexcxt, REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetRelationName, RelationNeedsWAL, xl_btree_metadata::root, SizeOfBtreeNewroot, START_CRIT_SECTION, xl_btree_metadata::version, XLOG_BTREE_NEWROOT, XLogBeginInsert(), XLogGetFakeLSN(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by _bt_get_endpoint(), _bt_getroot(), and _bt_search().

◆ _bt_getrootheight()

int _bt_getrootheight ( Relation rel )

extern

Definition at line 680 of file nbtpage.c.

{
    BTMetaPageData *metad;
 
    if (rel->rd_amcache == NULL)
    {
        Buffer      metabuf;
 
        metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_READ);
        metad = _bt_getmeta(rel, metabuf);
 
        /*
         * If there's no root page yet, _bt_getroot() doesn't expect a cache
         * to be made, so just stop here and report the index height is zero.
         * (XXX perhaps _bt_getroot() should be changed to allow this case.)
         */
        if (metad->btm_root == P_NONE)
        {
            _bt_relbuf(rel, metabuf);
            return 0;
        }
 
        /*
         * Cache the metapage data for next time
         */
        rel->rd_amcache = MemoryContextAlloc(rel->rd_indexcxt,
                                             sizeof(BTMetaPageData));
        memcpy(rel->rd_amcache, metad, sizeof(BTMetaPageData));
        _bt_relbuf(rel, metabuf);
    }
 
    /* Get cached page */
    metad = (BTMetaPageData *) rel->rd_amcache;
    /* We shouldn't have cached it if any of these fail */
    Assert(metad->btm_magic == BTREE_MAGIC);
    Assert(metad->btm_version >= BTREE_MIN_VERSION);
    Assert(metad->btm_version <= BTREE_VERSION);
    Assert(!metad->btm_allequalimage ||
           metad->btm_version > BTREE_NOVAC_VERSION);
    Assert(metad->btm_fastroot != P_NONE);
 
    return metad->btm_fastlevel;
}

References _bt_getbuf(), _bt_getmeta(), _bt_relbuf(), Assert, BT_READ, BTREE_MAGIC, BTREE_METAPAGE, BTREE_MIN_VERSION, BTREE_NOVAC_VERSION, BTREE_VERSION, fb(), memcpy(), MemoryContextAlloc(), P_NONE, RelationData::rd_amcache, and RelationData::rd_indexcxt.

Referenced by _bt_insertonpg(), and btgettreeheight().

◆ _bt_getstackbuf()

Buffer _bt_getstackbuf	(	Relation	rel,
		Relation	heaprel,
		BTStack	stack,
		BlockNumber	child
	)

extern

Definition at line 2351 of file nbtinsert.c.

{
    BlockNumber blkno;
    OffsetNumber start;
 
    blkno = stack->bts_blkno;
    start = stack->bts_offset;
 
    for (;;)
    {
        Buffer      buf;
        Page        page;
        BTPageOpaque opaque;
 
        buf = _bt_getbuf(rel, blkno, BT_WRITE);
        page = BufferGetPage(buf);
        opaque = BTPageGetOpaque(page);
 
        Assert(heaprel != NULL);
        if (P_INCOMPLETE_SPLIT(opaque))
        {
            _bt_finish_split(rel, heaprel, buf, stack->bts_parent);
            continue;
        }
 
        if (!P_IGNORE(opaque))
        {
            OffsetNumber offnum,
                        minoff,
                        maxoff;
            ItemId      itemid;
            IndexTuple  item;
 
            minoff = P_FIRSTDATAKEY(opaque);
            maxoff = PageGetMaxOffsetNumber(page);
 
            /*
             * start = InvalidOffsetNumber means "search the whole page". We
             * need this test anyway due to possibility that page has a high
             * key now when it didn't before.
             */
            if (start < minoff)
                start = minoff;
 
            /*
             * Need this check too, to guard against possibility that page
             * split since we visited it originally.
             */
            if (start > maxoff)
                start = OffsetNumberNext(maxoff);
 
            /*
             * These loops will check every item on the page --- but in an
             * order that's attuned to the probability of where it actually
             * is.  Scan to the right first, then to the left.
             */
            for (offnum = start;
                 offnum <= maxoff;
                 offnum = OffsetNumberNext(offnum))
            {
                itemid = PageGetItemId(page, offnum);
                item = (IndexTuple) PageGetItem(page, itemid);
 
                if (BTreeTupleGetDownLink(item) == child)
                {
                    /* Return accurate pointer to where link is now */
                    stack->bts_blkno = blkno;
                    stack->bts_offset = offnum;
                    return buf;
                }
            }
 
            for (offnum = OffsetNumberPrev(start);
                 offnum >= minoff;
                 offnum = OffsetNumberPrev(offnum))
            {
                itemid = PageGetItemId(page, offnum);
                item = (IndexTuple) PageGetItem(page, itemid);
 
                if (BTreeTupleGetDownLink(item) == child)
                {
                    /* Return accurate pointer to where link is now */
                    stack->bts_blkno = blkno;
                    stack->bts_offset = offnum;
                    return buf;
                }
            }
        }
 
        /*
         * The item we're looking for moved right at least one page.
         *
         * Lehman and Yao couple/chain locks when moving right here, which we
         * can avoid.  See nbtree/README.
         */
        if (P_RIGHTMOST(opaque))
        {
            _bt_relbuf(rel, buf);
            return InvalidBuffer;
        }
        blkno = opaque->btpo_next;
        start = InvalidOffsetNumber;
        _bt_relbuf(rel, buf);
    }
}

References _bt_finish_split(), _bt_getbuf(), _bt_relbuf(), Assert, BT_WRITE, BTPageGetOpaque, BTPageOpaqueData::btpo_next, BTreeTupleGetDownLink(), BTStackData::bts_blkno, BTStackData::bts_offset, BTStackData::bts_parent, buf, BufferGetPage(), fb(), InvalidBuffer, InvalidOffsetNumber, OffsetNumberNext, OffsetNumberPrev, P_FIRSTDATAKEY, P_IGNORE, P_INCOMPLETE_SPLIT, P_RIGHTMOST, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), and start.

Referenced by _bt_insert_parent(), and _bt_lock_subtree_parent().

◆ _bt_gettrueroot()

Buffer _bt_gettrueroot ( Relation rel )

extern

Definition at line 585 of file nbtpage.c.

{
    Buffer      metabuf;
    Page        metapg;
    BTPageOpaque metaopaque;
    Buffer      rootbuf;
    Page        rootpage;
    BTPageOpaque rootopaque;
    BlockNumber rootblkno;
    uint32      rootlevel;
    BTMetaPageData *metad;
 
    /*
     * We don't try to use cached metapage data here, since (a) this path is
     * not performance-critical, and (b) if we are here it suggests our cache
     * is out-of-date anyway.  In light of point (b), it's probably safest to
     * actively flush any cached metapage info.
     */
    if (rel->rd_amcache)
        pfree(rel->rd_amcache);
    rel->rd_amcache = NULL;
 
    metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_READ);
    metapg = BufferGetPage(metabuf);
    metaopaque = BTPageGetOpaque(metapg);
    metad = BTPageGetMeta(metapg);
 
    if (!P_ISMETA(metaopaque) ||
        metad->btm_magic != BTREE_MAGIC)
        ereport(ERROR,
                (errcode(ERRCODE_INDEX_CORRUPTED),
                 errmsg("index \"%s\" is not a btree",
                        RelationGetRelationName(rel))));
 
    if (metad->btm_version < BTREE_MIN_VERSION ||
        metad->btm_version > BTREE_VERSION)
        ereport(ERROR,
                (errcode(ERRCODE_INDEX_CORRUPTED),
                 errmsg("version mismatch in index \"%s\": file version %d, "
                        "current version %d, minimal supported version %d",
                        RelationGetRelationName(rel),
                        metad->btm_version, BTREE_VERSION, BTREE_MIN_VERSION)));
 
    /* if no root page initialized yet, fail */
    if (metad->btm_root == P_NONE)
    {
        _bt_relbuf(rel, metabuf);
        return InvalidBuffer;
    }
 
    rootblkno = metad->btm_root;
    rootlevel = metad->btm_level;
 
    /*
     * We are done with the metapage; arrange to release it via first
     * _bt_relandgetbuf call
     */
    rootbuf = metabuf;
 
    for (;;)
    {
        rootbuf = _bt_relandgetbuf(rel, rootbuf, rootblkno, BT_READ);
        rootpage = BufferGetPage(rootbuf);
        rootopaque = BTPageGetOpaque(rootpage);
 
        if (!P_IGNORE(rootopaque))
            break;
 
        /* it's dead, Jim.  step right one page */
        if (P_RIGHTMOST(rootopaque))
            elog(ERROR, "no live root page found in index \"%s\"",
                 RelationGetRelationName(rel));
        rootblkno = rootopaque->btpo_next;
    }
 
    if (rootopaque->btpo_level != rootlevel)
        elog(ERROR, "root page %u of index \"%s\" has level %u, expected %u",
             rootblkno, RelationGetRelationName(rel),
             rootopaque->btpo_level, rootlevel);
 
    return rootbuf;
}

References _bt_getbuf(), _bt_relandgetbuf(), _bt_relbuf(), BT_READ, BTPageGetMeta, BTPageGetOpaque, BTREE_MAGIC, BTREE_METAPAGE, BTREE_MIN_VERSION, BTREE_VERSION, BufferGetPage(), elog, ereport, errcode(), errmsg, ERROR, fb(), InvalidBuffer, P_IGNORE, P_ISMETA, P_NONE, P_RIGHTMOST, pfree(), RelationData::rd_amcache, and RelationGetRelationName.

Referenced by _bt_get_endpoint().

◆ _bt_initmetapage()

void _bt_initmetapage	(	Page	page,
		BlockNumber	rootbknum,
		uint32	level,
		bool	allequalimage
	)

extern

Definition at line 68 of file nbtpage.c.

{
    BTMetaPageData *metad;
    BTPageOpaque metaopaque;
 
    _bt_pageinit(page, BLCKSZ);
 
    metad = BTPageGetMeta(page);
    metad->btm_magic = BTREE_MAGIC;
    metad->btm_version = BTREE_VERSION;
    metad->btm_root = rootbknum;
    metad->btm_level = level;
    metad->btm_fastroot = rootbknum;
    metad->btm_fastlevel = level;
    metad->btm_last_cleanup_num_delpages = 0;
    metad->btm_last_cleanup_num_heap_tuples = -1.0;
    metad->btm_allequalimage = allequalimage;
 
    metaopaque = BTPageGetOpaque(page);
    metaopaque->btpo_flags = BTP_META;
 
    /*
     * Set pd_lower just past the end of the metadata.  This is essential,
     * because without doing so, metadata will be lost if xlog.c compresses
     * the page.
     */
    ((PageHeader) page)->pd_lower =
        ((char *) metad + sizeof(BTMetaPageData)) - (char *) page;
}

References _bt_pageinit(), BTP_META, BTPageGetMeta, BTPageGetOpaque, BTREE_MAGIC, BTREE_VERSION, and fb().

Referenced by _bt_uppershutdown(), and btbuildempty().

◆ _bt_keep_natts_fast()

int _bt_keep_natts_fast	(	Relation	rel,
		IndexTuple	lastleft,
		IndexTuple	firstright
	)

extern

Definition at line 911 of file nbtutils.c.

{
    TupleDesc   itupdesc = RelationGetDescr(rel);
    int         keysz = IndexRelationGetNumberOfKeyAttributes(rel);
    int         keepnatts;
 
    keepnatts = 1;
    for (int attnum = 1; attnum <= keysz; attnum++)
    {
        Datum       datum1,
                    datum2;
        bool        isNull1,
                    isNull2;
        CompactAttribute *att;
 
        datum1 = index_getattr(lastleft, attnum, itupdesc, &isNull1);
        datum2 = index_getattr(firstright, attnum, itupdesc, &isNull2);
        att = TupleDescCompactAttr(itupdesc, attnum - 1);
 
        if (isNull1 != isNull2)
            break;
 
        if (!isNull1 &&
            !datum_image_eq(datum1, datum2, att->attbyval, att->attlen))
            break;
 
        keepnatts++;
    }
 
    return keepnatts;
}

References CompactAttribute::attbyval, CompactAttribute::attlen, attnum, datum_image_eq(), fb(), index_getattr(), IndexRelationGetNumberOfKeyAttributes, RelationGetDescr, and TupleDescCompactAttr().

Referenced by _bt_afternewitemoff(), _bt_bottomupdel_pass(), _bt_dedup_pass(), _bt_do_singleval(), _bt_keep_natts(), _bt_load(), _bt_set_startikey(), _bt_split_penalty(), and _bt_strategy().

◆ _bt_killitems()

void _bt_killitems ( IndexScanDesc scan )

extern

Definition at line 191 of file nbtutils.c.

{
    Relation    rel = scan->indexRelation;
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
    Page        page;
    BTPageOpaque opaque;
    OffsetNumber minoff;
    OffsetNumber maxoff;
    int         numKilled = so->numKilled;
    bool        killedsomething = false;
    Buffer      buf;
 
    Assert(numKilled > 0);
    Assert(BTScanPosIsValid(so->currPos));
    Assert(scan->heapRelation != NULL); /* can't be a bitmap index scan */
 
    /* Always invalidate so->killedItems[] before leaving so->currPos */
    so->numKilled = 0;
 
    /*
     * We need to iterate through so->killedItems[] in leaf page order; the
     * loop below expects this (when marking posting list tuples, at least).
     * so->killedItems[] is now in whatever order the scan returned items in.
     * Scrollable cursor scans might have even saved the same item/TID twice.
     *
     * Sort and unique-ify so->killedItems[] to deal with all this.
     */
    if (numKilled > 1)
    {
        qsort(so->killedItems, numKilled, sizeof(int), _bt_compare_int);
        numKilled = qunique(so->killedItems, numKilled, sizeof(int),
                            _bt_compare_int);
    }
 
    if (!so->dropPin)
    {
        /*
         * We have held the pin on this page since we read the index tuples,
         * so all we need to do is lock it.  The pin will have prevented
         * concurrent VACUUMs from recycling any of the TIDs on the page.
         */
        Assert(BTScanPosIsPinned(so->currPos));
        buf = so->currPos.buf;
        _bt_lockbuf(rel, buf, BT_READ);
    }
    else
    {
        XLogRecPtr  latestlsn;
 
        Assert(!BTScanPosIsPinned(so->currPos));
        buf = _bt_getbuf(rel, so->currPos.currPage, BT_READ);
 
        latestlsn = BufferGetLSNAtomic(buf);
        Assert(so->currPos.lsn <= latestlsn);
        if (so->currPos.lsn != latestlsn)
        {
            /* Modified, give up on hinting */
            _bt_relbuf(rel, buf);
            return;
        }
 
        /* Unmodified, hinting is safe */
    }
 
    page = BufferGetPage(buf);
    opaque = BTPageGetOpaque(page);
    minoff = P_FIRSTDATAKEY(opaque);
    maxoff = PageGetMaxOffsetNumber(page);
 
    /* Iterate through so->killedItems[] in leaf page order */
    for (int i = 0; i < numKilled; i++)
    {
        int         itemIndex = so->killedItems[i];
        BTScanPosItem *kitem = &so->currPos.items[itemIndex];
        OffsetNumber offnum = kitem->indexOffset;
 
        Assert(itemIndex >= so->currPos.firstItem &&
               itemIndex <= so->currPos.lastItem);
        Assert(i == 0 ||
               offnum >= so->currPos.items[so->killedItems[i - 1]].indexOffset);
 
        if (offnum < minoff)
            continue;           /* pure paranoia */
        while (offnum <= maxoff)
        {
            ItemId      iid = PageGetItemId(page, offnum);
            IndexTuple  ituple = (IndexTuple) PageGetItem(page, iid);
            bool        killtuple = false;
 
            if (BTreeTupleIsPosting(ituple))
            {
                int         pi = i + 1;
                int         nposting = BTreeTupleGetNPosting(ituple);
                int         j;
 
                /*
                 * Note that the page may have been modified in almost any way
                 * since we first read it (in the !so->dropPin case), so it's
                 * possible that this posting list tuple wasn't a posting list
                 * tuple when we first encountered its heap TIDs.
                 */
                for (j = 0; j < nposting; j++)
                {
                    ItemPointer item = BTreeTupleGetPostingN(ituple, j);
 
                    if (!ItemPointerEquals(item, &kitem->heapTid))
                        break;  /* out of posting list loop */
 
                    /*
                     * kitem must have matching offnum when heap TIDs match,
                     * though only in the common case where the page can't
                     * have been concurrently modified
                     */
                    Assert(kitem->indexOffset == offnum || !so->dropPin);
 
                    /*
                     * Read-ahead to later kitems here.
                     *
                     * We rely on the assumption that not advancing kitem here
                     * will prevent us from considering the posting list tuple
                     * fully dead by not matching its next heap TID in next
                     * loop iteration.
                     *
                     * If, on the other hand, this is the final heap TID in
                     * the posting list tuple, then tuple gets killed
                     * regardless (i.e. we handle the case where the last
                     * kitem is also the last heap TID in the last index tuple
                     * correctly -- posting tuple still gets killed).
                     */
                    if (pi < numKilled)
                        kitem = &so->currPos.items[so->killedItems[pi++]];
                }
 
                /*
                 * Don't bother advancing the outermost loop's int iterator to
                 * avoid processing killed items that relate to the same
                 * offnum/posting list tuple.  This micro-optimization hardly
                 * seems worth it.  (Further iterations of the outermost loop
                 * will fail to match on this same posting list's first heap
                 * TID instead, so we'll advance to the next offnum/index
                 * tuple pretty quickly.)
                 */
                if (j == nposting)
                    killtuple = true;
            }
            else if (ItemPointerEquals(&ituple->t_tid, &kitem->heapTid))
                killtuple = true;
 
            /*
             * Mark index item as dead, if it isn't already.  Since this
             * happens while holding a buffer lock possibly in shared mode,
             * it's possible that multiple processes attempt to do this
             * simultaneously, leading to multiple full-page images being sent
             * to WAL (if wal_log_hints or data checksums are enabled), which
             * is undesirable.
             */
            if (killtuple && !ItemIdIsDead(iid))
            {
                if (!killedsomething)
                {
                    /*
                     * Use the hint bit infrastructure to check if we can
                     * update the page while just holding a share lock. If we
                     * are not allowed, there's no point continuing.
                     */
                    if (!BufferBeginSetHintBits(buf))
                        goto unlock_page;
                }
 
                /* found the item/all posting list items */
                ItemIdMarkDead(iid);
                killedsomething = true;
                break;          /* out of inner search loop */
            }
            offnum = OffsetNumberNext(offnum);
        }
    }
 
    /*
     * Since this can be redone later if needed, mark as dirty hint.
     *
     * Whenever we mark anything LP_DEAD, we also set the page's
     * BTP_HAS_GARBAGE flag, which is likewise just a hint.  (Note that we
     * only rely on the page-level flag in !heapkeyspace indexes.)
     */
    if (killedsomething)
    {
        opaque->btpo_flags |= BTP_HAS_GARBAGE;
        BufferFinishSetHintBits(buf, true, true);
    }
 
unlock_page:
    if (!so->dropPin)
        _bt_unlockbuf(rel, buf);
    else
        _bt_relbuf(rel, buf);
}

References _bt_compare_int(), _bt_getbuf(), _bt_lockbuf(), _bt_relbuf(), _bt_unlockbuf(), Assert, BT_READ, BTP_HAS_GARBAGE, BTPageGetOpaque, BTPageOpaqueData::btpo_flags, BTreeTupleGetNPosting(), BTreeTupleGetPostingN(), BTreeTupleIsPosting(), BTScanPosIsPinned, BTScanPosIsValid, buf, BufferBeginSetHintBits(), BufferFinishSetHintBits(), BufferGetLSNAtomic(), BufferGetPage(), fb(), IndexScanDescData::heapRelation, i, BTScanPosItem::indexOffset, IndexScanDescData::indexRelation, ItemIdIsDead, ItemIdMarkDead, ItemPointerEquals(), j, OffsetNumberNext, IndexScanDescData::opaque, P_FIRSTDATAKEY, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), qsort, and qunique().

Referenced by _bt_steppage(), btendscan(), btrescan(), and btrestrpos().

◆ _bt_lockbuf()

void _bt_lockbuf	(	Relation	rel,
		Buffer	buf,
		int	access
	)

extern

Definition at line 1067 of file nbtpage.c.

{
    /* LockBuffer() asserts that pin is held by this backend */
    LockBuffer(buf, access);
 
    /*
     * It doesn't matter that _bt_unlockbuf() won't get called in the event of
     * an nbtree error (e.g. a unique violation error).  That won't cause
     * Valgrind false positives.
     *
     * The nbtree client requests are superimposed on top of the bufmgr.c
     * buffer pin client requests.  In the event of an nbtree error the buffer
     * will certainly get marked as defined when the backend once again
     * acquires its first pin on the buffer. (Of course, if the backend never
     * touches the buffer again then it doesn't matter that it remains
     * non-accessible to Valgrind.)
     *
     * Note: When an IndexTuple C pointer gets computed using an ItemId read
     * from a page while a lock was held, the C pointer becomes unsafe to
     * dereference forever as soon as the lock is released.  Valgrind can only
     * detect cases where the pointer gets dereferenced with no _current_
     * lock/pin held, though.
     */
    if (!RelationUsesLocalBuffers(rel))
        VALGRIND_MAKE_MEM_DEFINED(BufferGetPage(buf), BLCKSZ);
}

References buf, BufferGetPage(), fb(), LockBuffer(), RelationUsesLocalBuffers, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by _bt_getbuf(), _bt_getroot(), _bt_killitems(), _bt_moveright(), _bt_pagedel(), _bt_relandgetbuf(), _bt_search(), _bt_set_cleanup_info(), _bt_unlink_halfdead_page(), and btvacuumpage().

◆ _bt_metaversion()

void _bt_metaversion	(	Relation	rel,
		bool *	heapkeyspace,
		bool *	allequalimage
	)

extern

Definition at line 744 of file nbtpage.c.

{
    BTMetaPageData *metad;
 
    if (rel->rd_amcache == NULL)
    {
        Buffer      metabuf;
 
        metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_READ);
        metad = _bt_getmeta(rel, metabuf);
 
        /*
         * If there's no root page yet, _bt_getroot() doesn't expect a cache
         * to be made, so just stop here.  (XXX perhaps _bt_getroot() should
         * be changed to allow this case.)
         */
        if (metad->btm_root == P_NONE)
        {
            *heapkeyspace = metad->btm_version > BTREE_NOVAC_VERSION;
            *allequalimage = metad->btm_allequalimage;
 
            _bt_relbuf(rel, metabuf);
            return;
        }
 
        /*
         * Cache the metapage data for next time
         *
         * An on-the-fly version upgrade performed by _bt_upgrademetapage()
         * can change the nbtree version for an index without invalidating any
         * local cache.  This is okay because it can only happen when moving
         * from version 2 to version 3, both of which are !heapkeyspace
         * versions.
         */
        rel->rd_amcache = MemoryContextAlloc(rel->rd_indexcxt,
                                             sizeof(BTMetaPageData));
        memcpy(rel->rd_amcache, metad, sizeof(BTMetaPageData));
        _bt_relbuf(rel, metabuf);
    }
 
    /* Get cached page */
    metad = (BTMetaPageData *) rel->rd_amcache;
    /* We shouldn't have cached it if any of these fail */
    Assert(metad->btm_magic == BTREE_MAGIC);
    Assert(metad->btm_version >= BTREE_MIN_VERSION);
    Assert(metad->btm_version <= BTREE_VERSION);
    Assert(!metad->btm_allequalimage ||
           metad->btm_version > BTREE_NOVAC_VERSION);
    Assert(metad->btm_fastroot != P_NONE);
 
    *heapkeyspace = metad->btm_version > BTREE_NOVAC_VERSION;
    *allequalimage = metad->btm_allequalimage;
}

References _bt_getbuf(), _bt_getmeta(), _bt_relbuf(), Assert, BT_READ, BTREE_MAGIC, BTREE_METAPAGE, BTREE_MIN_VERSION, BTREE_NOVAC_VERSION, BTREE_VERSION, fb(), memcpy(), MemoryContextAlloc(), P_NONE, RelationData::rd_amcache, and RelationData::rd_indexcxt.

Referenced by _bt_first(), _bt_mkscankey(), and bt_index_check_callback().

◆ _bt_mkscankey()

BTScanInsert _bt_mkscankey	(	Relation	rel,
		IndexTuple	itup
	)

extern

Definition at line 61 of file nbtutils.c.

{
    BTScanInsert key;
    ScanKey     skey;
    TupleDesc   itupdesc;
    int         indnkeyatts;
    int16      *indoption;
    int         tupnatts;
    int         i;
 
    itupdesc = RelationGetDescr(rel);
    indnkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
    indoption = rel->rd_indoption;
    tupnatts = itup ? BTreeTupleGetNAtts(itup, rel) : 0;
 
    Assert(tupnatts <= IndexRelationGetNumberOfAttributes(rel));
 
    /*
     * We'll execute search using scan key constructed on key columns.
     * Truncated attributes and non-key attributes are omitted from the final
     * scan key.
     */
    key = palloc(offsetof(BTScanInsertData, scankeys) +
                 sizeof(ScanKeyData) * indnkeyatts);
    if (itup)
        _bt_metaversion(rel, &key->heapkeyspace, &key->allequalimage);
    else
    {
        /* Utility statement callers can set these fields themselves */
        key->heapkeyspace = true;
        key->allequalimage = false;
    }
    key->anynullkeys = false;   /* initial assumption */
    key->nextkey = false;       /* usual case, required by btinsert */
    key->backward = false;      /* usual case, required by btinsert */
    key->keysz = Min(indnkeyatts, tupnatts);
    key->scantid = key->heapkeyspace && itup ?
        BTreeTupleGetHeapTID(itup) : NULL;
    skey = key->scankeys;
    for (i = 0; i < indnkeyatts; i++)
    {
        FmgrInfo   *procinfo;
        Datum       arg;
        bool        null;
        int         flags;
 
        /*
         * We can use the cached (default) support procs since no cross-type
         * comparison can be needed.
         */
        procinfo = index_getprocinfo(rel, i + 1, BTORDER_PROC);
 
        /*
         * Key arguments built from truncated attributes (or when caller
         * provides no tuple) are defensively represented as NULL values. They
         * should never be used.
         */
        if (i < tupnatts)
            arg = index_getattr(itup, i + 1, itupdesc, &null);
        else
        {
            arg = (Datum) 0;
            null = true;
        }
        flags = (null ? SK_ISNULL : 0) | (indoption[i] << SK_BT_INDOPTION_SHIFT);
        ScanKeyEntryInitializeWithInfo(&skey[i],
                                       flags,
                                       (AttrNumber) (i + 1),
                                       InvalidStrategy,
                                       InvalidOid,
                                       rel->rd_indcollation[i],
                                       procinfo,
                                       arg);
        /* Record if any key attribute is NULL (or truncated) */
        if (null)
            key->anynullkeys = true;
    }
 
    /*
     * In NULLS NOT DISTINCT mode, we pretend that there are no null keys, so
     * that full uniqueness check is done.
     */
    if (rel->rd_index->indnullsnotdistinct)
        key->anynullkeys = false;
 
    return key;
}

References _bt_metaversion(), arg, Assert, BTORDER_PROC, BTreeTupleGetHeapTID(), BTreeTupleGetNAtts, fb(), i, index_getattr(), index_getprocinfo(), IndexRelationGetNumberOfAttributes, IndexRelationGetNumberOfKeyAttributes, InvalidOid, InvalidStrategy, Min, palloc(), RelationData::rd_indcollation, RelationData::rd_index, RelationData::rd_indoption, RelationGetDescr, ScanKeyEntryInitializeWithInfo(), SK_BT_INDOPTION_SHIFT, and SK_ISNULL.

Referenced by _bt_doinsert(), _bt_leafbuild(), _bt_pagedel(), bt_mkscankey_pivotsearch(), bt_rootdescend(), tuplesort_begin_cluster(), and tuplesort_begin_index_btree().

◆ _bt_next()

bool _bt_next	(	IndexScanDesc	scan,
		ScanDirection	dir
	)

extern

Definition at line 1586 of file nbtsearch.c.

{
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
 
    Assert(BTScanPosIsValid(so->currPos));
 
    /*
     * Advance to next tuple on current page; or if there's no more, try to
     * step to the next page with data.
     */
    if (ScanDirectionIsForward(dir))
    {
        if (++so->currPos.itemIndex > so->currPos.lastItem)
        {
            if (!_bt_steppage(scan, dir))
                return false;
        }
    }
    else
    {
        if (--so->currPos.itemIndex < so->currPos.firstItem)
        {
            if (!_bt_steppage(scan, dir))
                return false;
        }
    }
 
    _bt_returnitem(scan, so);
    return true;
}

References _bt_returnitem(), _bt_steppage(), Assert, BTScanPosIsValid, fb(), IndexScanDescData::opaque, and ScanDirectionIsForward.

Referenced by btgetbitmap(), and btgettuple().

◆ _bt_pagedel()

void _bt_pagedel	(	Relation	rel,
		Buffer	leafbuf,
		BTVacState *	vstate
	)

extern

Definition at line 1832 of file nbtpage.c.

{
    BlockNumber rightsib;
    bool        rightsib_empty;
    Page        page;
    BTPageOpaque opaque;
 
    /*
     * Save original leafbuf block number from caller.  Only deleted blocks
     * that are <= scanblkno are added to bulk delete stat's pages_deleted
     * count.
     */
    BlockNumber scanblkno = BufferGetBlockNumber(leafbuf);
 
    /*
     * "stack" is a search stack leading (approximately) to the target page.
     * It is initially NULL, but when iterating, we keep it to avoid
     * duplicated search effort.
     *
     * Also, when "stack" is not NULL, we have already checked that the
     * current page is not the right half of an incomplete split, i.e. the
     * left sibling does not have its INCOMPLETE_SPLIT flag set, including
     * when the current target page is to the right of caller's initial page
     * (the scanblkno page).
     */
    BTStack     stack = NULL;
 
    for (;;)
    {
        page = BufferGetPage(leafbuf);
        opaque = BTPageGetOpaque(page);
 
        /*
         * Internal pages are never deleted directly, only as part of deleting
         * the whole subtree all the way down to leaf level.
         *
         * Also check for deleted pages here.  Caller never passes us a fully
         * deleted page.  Only VACUUM can delete pages, so there can't have
         * been a concurrent deletion.  Assume that we reached any deleted
         * page encountered here by following a sibling link, and that the
         * index is corrupt.
         */
        Assert(!P_ISDELETED(opaque));
        if (!P_ISLEAF(opaque) || P_ISDELETED(opaque))
        {
            /*
             * Pre-9.4 page deletion only marked internal pages as half-dead,
             * but now we only use that flag on leaf pages. The old algorithm
             * was never supposed to leave half-dead pages in the tree, it was
             * just a transient state, but it was nevertheless possible in
             * error scenarios. We don't know how to deal with them here. They
             * are harmless as far as searches are considered, but inserts
             * into the deleted keyspace could add out-of-order downlinks in
             * the upper levels. Log a notice, hopefully the admin will notice
             * and reindex.
             */
            if (P_ISHALFDEAD(opaque))
                ereport(LOG,
                        (errcode(ERRCODE_INDEX_CORRUPTED),
                         errmsg("index \"%s\" contains a half-dead internal page",
                                RelationGetRelationName(rel)),
                         errhint("This can be caused by an interrupted VACUUM in version 9.3 or older, before upgrade. Please REINDEX it.")));
 
            if (P_ISDELETED(opaque))
                ereport(LOG,
                        (errcode(ERRCODE_INDEX_CORRUPTED),
                         errmsg_internal("found deleted block %u while following right link from block %u in index \"%s\"",
                                         BufferGetBlockNumber(leafbuf),
                                         scanblkno,
                                         RelationGetRelationName(rel))));
 
            _bt_relbuf(rel, leafbuf);
            return;
        }
 
        /*
         * We can never delete rightmost pages nor root pages.  While at it,
         * check that page is empty, since it's possible that the leafbuf page
         * was empty a moment ago, but has since had some inserts.
         *
         * To keep the algorithm simple, we also never delete an incompletely
         * split page (they should be rare enough that this doesn't make any
         * meaningful difference to disk usage):
         *
         * The INCOMPLETE_SPLIT flag on the page tells us if the page is the
         * left half of an incomplete split, but ensuring that it's not the
         * right half is more complicated.  For that, we have to check that
         * the left sibling doesn't have its INCOMPLETE_SPLIT flag set using
         * _bt_leftsib_splitflag().  On the first iteration, we temporarily
         * release the lock on scanblkno/leafbuf, check the left sibling, and
         * construct a search stack to scanblkno.  On subsequent iterations,
         * we know we stepped right from a page that passed these tests, so
         * it's OK.
         */
        if (P_RIGHTMOST(opaque) || P_ISROOT(opaque) ||
            P_FIRSTDATAKEY(opaque) <= PageGetMaxOffsetNumber(page) ||
            P_INCOMPLETE_SPLIT(opaque))
        {
            /* Should never fail to delete a half-dead page */
            Assert(!P_ISHALFDEAD(opaque));
 
            _bt_relbuf(rel, leafbuf);
            return;
        }
 
        /*
         * First, remove downlink pointing to the page (or a parent of the
         * page, if we are going to delete a taller subtree), and mark the
         * leafbuf page half-dead
         */
        if (!P_ISHALFDEAD(opaque))
        {
            /*
             * We need an approximate pointer to the page's parent page.  We
             * use a variant of the standard search mechanism to search for
             * the page's high key; this will give us a link to either the
             * current parent or someplace to its left (if there are multiple
             * equal high keys, which is possible with !heapkeyspace indexes).
             *
             * Also check if this is the right-half of an incomplete split
             * (see comment above).
             */
            if (!stack)
            {
                BTScanInsert itup_key;
                ItemId      itemid;
                IndexTuple  targetkey;
                BlockNumber leftsib,
                            leafblkno;
                Buffer      sleafbuf;
 
                itemid = PageGetItemId(page, P_HIKEY);
                targetkey = CopyIndexTuple((IndexTuple) PageGetItem(page, itemid));
 
                leftsib = opaque->btpo_prev;
                leafblkno = BufferGetBlockNumber(leafbuf);
 
                /*
                 * To avoid deadlocks, we'd better drop the leaf page lock
                 * before going further.
                 */
                _bt_unlockbuf(rel, leafbuf);
 
                /*
                 * Check that the left sibling of leafbuf (if any) is not
                 * marked with INCOMPLETE_SPLIT flag before proceeding
                 */
                Assert(leafblkno == scanblkno);
                if (_bt_leftsib_splitflag(rel, leftsib, leafblkno))
                {
                    ReleaseBuffer(leafbuf);
                    return;
                }
 
                /*
                 * We need an insertion scan key, so build one.
                 *
                 * _bt_search searches for the leaf page that contains any
                 * matching non-pivot tuples, but we need it to "search" for
                 * the high key pivot from the page that we're set to delete.
                 * Compensate for the mismatch by having _bt_search locate the
                 * last position < equal-to-untruncated-prefix non-pivots.
                 */
                itup_key = _bt_mkscankey(rel, targetkey);
 
                /* Set up a BTLessStrategyNumber-like insertion scan key */
                itup_key->nextkey = false;
                itup_key->backward = true;
                stack = _bt_search(rel, NULL, itup_key, &sleafbuf, BT_READ, true);
                /* won't need a second lock or pin on leafbuf */
                _bt_relbuf(rel, sleafbuf);
 
                /*
                 * Re-lock the leaf page, and start over to use our stack
                 * within _bt_mark_page_halfdead.  We must do it that way
                 * because it's possible that leafbuf can no longer be
                 * deleted.  We need to recheck.
                 *
                 * Note: We can't simply hold on to the sleafbuf lock instead,
                 * because it's barely possible that sleafbuf is not the same
                 * page as leafbuf.  This happens when leafbuf split after our
                 * original lock was dropped, but before _bt_search finished
                 * its descent.  We rely on the assumption that we'll find
                 * leafbuf isn't safe to delete anymore in this scenario.
                 * (Page deletion can cope with the stack being to the left of
                 * leafbuf, but not to the right of leafbuf.)
                 */
                _bt_lockbuf(rel, leafbuf, BT_WRITE);
                continue;
            }
 
            /*
             * See if it's safe to delete the leaf page, and determine how
             * many parent/internal pages above the leaf level will be
             * deleted.  If it's safe then _bt_mark_page_halfdead will also
             * perform the first phase of deletion, which includes marking the
             * leafbuf page half-dead.
             */
            Assert(P_ISLEAF(opaque) && !P_IGNORE(opaque));
            if (!_bt_mark_page_halfdead(rel, vstate->info->heaprel, leafbuf,
                                        stack))
            {
                _bt_relbuf(rel, leafbuf);
                return;
            }
        }
        else
        {
            INJECTION_POINT("nbtree-finish-half-dead-page-vacuum", NULL);
        }
 
        /*
         * Then unlink it from its siblings.  Each call to
         * _bt_unlink_halfdead_page unlinks the topmost page from the subtree,
         * making it shallower.  Iterate until the leafbuf page is deleted.
         */
        rightsib_empty = false;
        Assert(P_ISLEAF(opaque) && P_ISHALFDEAD(opaque));
        while (P_ISHALFDEAD(opaque))
        {
            /* Check for interrupts in _bt_unlink_halfdead_page */
            if (!_bt_unlink_halfdead_page(rel, leafbuf, scanblkno,
                                          &rightsib_empty, vstate))
            {
                /*
                 * _bt_unlink_halfdead_page should never fail, since we
                 * established that deletion is generally safe in
                 * _bt_mark_page_halfdead -- index must be corrupt.
                 *
                 * Note that _bt_unlink_halfdead_page already released the
                 * lock and pin on leafbuf for us.
                 */
                Assert(false);
                return;
            }
        }
 
        Assert(P_ISLEAF(opaque) && P_ISDELETED(opaque));
 
        rightsib = opaque->btpo_next;
 
        _bt_relbuf(rel, leafbuf);
 
        /*
         * Check here, as calling loops will have locks held, preventing
         * interrupts from being processed.
         */
        CHECK_FOR_INTERRUPTS();
 
        /*
         * The page has now been deleted. If its right sibling is completely
         * empty, it's possible that the reason we haven't deleted it earlier
         * is that it was the rightmost child of the parent. Now that we
         * removed the downlink for this page, the right sibling might now be
         * the only child of the parent, and could be removed. It would be
         * picked up by the next vacuum anyway, but might as well try to
         * remove it now, so loop back to process the right sibling.
         *
         * Note: This relies on the assumption that _bt_getstackbuf() will be
         * able to reuse our original descent stack with a different child
         * block (provided that the child block is to the right of the
         * original leaf page reached by _bt_search()). It will even update
         * the descent stack each time we loop around, avoiding repeated work.
         */
        if (!rightsib_empty)
            break;
 
        leafbuf = _bt_getbuf(rel, rightsib, BT_WRITE);
    }
}

References _bt_getbuf(), _bt_leftsib_splitflag(), _bt_lockbuf(), _bt_mark_page_halfdead(), _bt_mkscankey(), _bt_relbuf(), _bt_search(), _bt_unlink_halfdead_page(), _bt_unlockbuf(), Assert, BTScanInsertData::backward, BT_READ, BT_WRITE, BTPageGetOpaque, BTPageOpaqueData::btpo_next, BTPageOpaqueData::btpo_prev, BufferGetBlockNumber(), BufferGetPage(), CHECK_FOR_INTERRUPTS, CopyIndexTuple(), ereport, errcode(), errhint(), errmsg, errmsg_internal(), fb(), INJECTION_POINT, LOG, BTScanInsertData::nextkey, P_FIRSTDATAKEY, P_HIKEY, P_IGNORE, P_INCOMPLETE_SPLIT, P_ISDELETED, P_ISHALFDEAD, P_ISLEAF, P_ISROOT, P_RIGHTMOST, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), RelationGetRelationName, and ReleaseBuffer().

Referenced by btvacuumpage().

◆ _bt_pageinit()

void _bt_pageinit	(	Page	page,
		Size	size
	)

extern

Definition at line 1157 of file nbtpage.c.

{
    PageInit(page, size, sizeof(BTPageOpaqueData));
}

References PageInit().

Referenced by _bt_allocbuf(), _bt_blnewpage(), _bt_initmetapage(), _bt_restore_meta(), _bt_split(), btree_xlog_mark_page_halfdead(), btree_xlog_newroot(), btree_xlog_split(), and btree_xlog_unlink_page().

◆ _bt_parallel_build_main()

void _bt_parallel_build_main	(	dsm_segment *	seg,
		shm_toc *	toc
	)

extern

Definition at line 1744 of file nbtsort.c.

{
    char       *sharedquery;
    BTSpool    *btspool;
    BTSpool    *btspool2;
    BTShared   *btshared;
    Sharedsort *sharedsort;
    Sharedsort *sharedsort2;
    Relation    heapRel;
    Relation    indexRel;
    LOCKMODE    heapLockmode;
    LOCKMODE    indexLockmode;
    WalUsage   *walusage;
    BufferUsage *bufferusage;
    int         sortmem;
 
#ifdef BTREE_BUILD_STATS
    if (log_btree_build_stats)
        ResetUsage();
#endif                          /* BTREE_BUILD_STATS */
 
    /*
     * The only possible status flag that can be set to the parallel worker is
     * PROC_IN_SAFE_IC.
     */
    Assert((MyProc->statusFlags == 0) ||
           (MyProc->statusFlags == PROC_IN_SAFE_IC));
 
    /* Set debug_query_string for individual workers first */
    sharedquery = shm_toc_lookup(toc, PARALLEL_KEY_QUERY_TEXT, true);
    debug_query_string = sharedquery;
 
    /* Report the query string from leader */
    pgstat_report_activity(STATE_RUNNING, debug_query_string);
 
    /* Look up nbtree shared state */
    btshared = shm_toc_lookup(toc, PARALLEL_KEY_BTREE_SHARED, false);
 
    /* Open relations using lock modes known to be obtained by index.c */
    if (!btshared->isconcurrent)
    {
        heapLockmode = ShareLock;
        indexLockmode = AccessExclusiveLock;
    }
    else
    {
        heapLockmode = ShareUpdateExclusiveLock;
        indexLockmode = RowExclusiveLock;
    }
 
    /* Track query ID */
    pgstat_report_query_id(btshared->queryid, false);
 
    /* Open relations within worker */
    heapRel = table_open(btshared->heaprelid, heapLockmode);
    indexRel = index_open(btshared->indexrelid, indexLockmode);
 
    /* Initialize worker's own spool */
    btspool = palloc0_object(BTSpool);
    btspool->heap = heapRel;
    btspool->index = indexRel;
    btspool->isunique = btshared->isunique;
    btspool->nulls_not_distinct = btshared->nulls_not_distinct;
 
    /* Look up shared state private to tuplesort.c */
    sharedsort = shm_toc_lookup(toc, PARALLEL_KEY_TUPLESORT, false);
    tuplesort_attach_shared(sharedsort, seg);
    if (!btshared->isunique)
    {
        btspool2 = NULL;
        sharedsort2 = NULL;
    }
    else
    {
        /* Allocate memory for worker's own private secondary spool */
        btspool2 = palloc0_object(BTSpool);
 
        /* Initialize worker's own secondary spool */
        btspool2->heap = btspool->heap;
        btspool2->index = btspool->index;
        btspool2->isunique = false;
        /* Look up shared state private to tuplesort.c */
        sharedsort2 = shm_toc_lookup(toc, PARALLEL_KEY_TUPLESORT_SPOOL2, false);
        tuplesort_attach_shared(sharedsort2, seg);
    }
 
    /* Prepare to track buffer usage during parallel execution */
    InstrStartParallelQuery();
 
    /* Perform sorting of spool, and possibly a spool2 */
    sortmem = maintenance_work_mem / btshared->scantuplesortstates;
    _bt_parallel_scan_and_sort(btspool, btspool2, btshared, sharedsort,
                               sharedsort2, sortmem, false);
 
    /* Report WAL/buffer usage during parallel execution */
    bufferusage = shm_toc_lookup(toc, PARALLEL_KEY_BUFFER_USAGE, false);
    walusage = shm_toc_lookup(toc, PARALLEL_KEY_WAL_USAGE, false);
    InstrEndParallelQuery(&bufferusage[ParallelWorkerNumber],
                          &walusage[ParallelWorkerNumber]);
 
#ifdef BTREE_BUILD_STATS
    if (log_btree_build_stats)
    {
        ShowUsage("BTREE BUILD (Worker Partial Spool) STATISTICS");
        ResetUsage();
    }
#endif                          /* BTREE_BUILD_STATS */
 
    index_close(indexRel, indexLockmode);
    table_close(heapRel, heapLockmode);
}

References _bt_parallel_scan_and_sort(), AccessExclusiveLock, Assert, debug_query_string, fb(), BTShared::heaprelid, index_close(), index_open(), BTShared::indexrelid, InstrEndParallelQuery(), InstrStartParallelQuery(), BTShared::isconcurrent, BTShared::isunique, log_btree_build_stats, maintenance_work_mem, MyProc, BTShared::nulls_not_distinct, palloc0_object, PARALLEL_KEY_BTREE_SHARED, PARALLEL_KEY_BUFFER_USAGE, PARALLEL_KEY_QUERY_TEXT, PARALLEL_KEY_TUPLESORT, PARALLEL_KEY_TUPLESORT_SPOOL2, PARALLEL_KEY_WAL_USAGE, ParallelWorkerNumber, pgstat_report_activity(), pgstat_report_query_id(), PROC_IN_SAFE_IC, BTShared::queryid, ResetUsage(), RowExclusiveLock, BTShared::scantuplesortstates, ShareLock, ShareUpdateExclusiveLock, shm_toc_lookup(), ShowUsage(), STATE_RUNNING, PGPROC::statusFlags, table_close(), table_open(), and tuplesort_attach_shared().

◆ _bt_parallel_done()

void _bt_parallel_done ( IndexScanDesc scan )

extern

Definition at line 1035 of file nbtree.c.

{
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
    ParallelIndexScanDesc parallel_scan = scan->parallel_scan;
    BTParallelScanDesc btscan;
    bool        status_changed = false;
 
    Assert(!BTScanPosIsValid(so->currPos));
 
    /* Do nothing, for non-parallel scans */
    if (parallel_scan == NULL)
        return;
 
    /*
     * Should not mark parallel scan done when there's still a pending
     * primitive index scan
     */
    if (so->needPrimScan)
        return;
 
    btscan = (BTParallelScanDesc) OffsetToPointer(parallel_scan,
                                                  parallel_scan->ps_offset_am);
 
    /*
     * Mark the parallel scan as done, unless some other process did so
     * already
     */
    LWLockAcquire(&btscan->btps_lock, LW_EXCLUSIVE);
    Assert(btscan->btps_pageStatus != BTPARALLEL_NEED_PRIMSCAN);
    if (btscan->btps_pageStatus != BTPARALLEL_DONE)
    {
        btscan->btps_pageStatus = BTPARALLEL_DONE;
        status_changed = true;
    }
    LWLockRelease(&btscan->btps_lock);
 
    /* wake up all the workers associated with this parallel scan */
    if (status_changed)
        ConditionVariableBroadcast(&btscan->btps_cv);
}

References Assert, BTPARALLEL_DONE, BTPARALLEL_NEED_PRIMSCAN, BTScanPosIsValid, ConditionVariableBroadcast(), fb(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), OffsetToPointer, IndexScanDescData::opaque, IndexScanDescData::parallel_scan, and ParallelIndexScanDescData::ps_offset_am.

Referenced by _bt_endpoint(), _bt_first(), _bt_parallel_seize(), _bt_readnextpage(), and _bt_start_prim_scan().

◆ _bt_parallel_primscan_schedule()

void _bt_parallel_primscan_schedule	(	IndexScanDesc	scan,
		BlockNumber	curr_page
	)

extern

Definition at line 1085 of file nbtree.c.

{
    Relation    rel = scan->indexRelation;
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
    ParallelIndexScanDesc parallel_scan = scan->parallel_scan;
    BTParallelScanDesc btscan;
 
    Assert(so->numArrayKeys);
 
    btscan = (BTParallelScanDesc) OffsetToPointer(parallel_scan,
                                                  parallel_scan->ps_offset_am);
 
    LWLockAcquire(&btscan->btps_lock, LW_EXCLUSIVE);
    if (btscan->btps_lastCurrPage == curr_page &&
        btscan->btps_pageStatus == BTPARALLEL_IDLE)
    {
        btscan->btps_nextScanPage = InvalidBlockNumber;
        btscan->btps_lastCurrPage = InvalidBlockNumber;
        btscan->btps_pageStatus = BTPARALLEL_NEED_PRIMSCAN;
 
        /* Serialize scan's current array keys */
        _bt_parallel_serialize_arrays(rel, btscan, so);
    }
    LWLockRelease(&btscan->btps_lock);
}

References _bt_parallel_serialize_arrays(), Assert, BTPARALLEL_IDLE, BTPARALLEL_NEED_PRIMSCAN, fb(), IndexScanDescData::indexRelation, InvalidBlockNumber, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), OffsetToPointer, IndexScanDescData::opaque, IndexScanDescData::parallel_scan, and ParallelIndexScanDescData::ps_offset_am.

Referenced by _bt_advance_array_keys(), and _bt_readpage().

◆ _bt_parallel_release()

void _bt_parallel_release	(	IndexScanDesc	scan,
		BlockNumber	next_scan_page,
		BlockNumber	curr_page
	)

extern

Definition at line 1008 of file nbtree.c.

{
    ParallelIndexScanDesc parallel_scan = scan->parallel_scan;
    BTParallelScanDesc btscan;
 
    Assert(BlockNumberIsValid(next_scan_page));
 
    btscan = (BTParallelScanDesc) OffsetToPointer(parallel_scan,
                                                  parallel_scan->ps_offset_am);
 
    LWLockAcquire(&btscan->btps_lock, LW_EXCLUSIVE);
    btscan->btps_nextScanPage = next_scan_page;
    btscan->btps_lastCurrPage = curr_page;
    btscan->btps_pageStatus = BTPARALLEL_IDLE;
    LWLockRelease(&btscan->btps_lock);
    ConditionVariableSignal(&btscan->btps_cv);
}

References Assert, BlockNumberIsValid(), BTPARALLEL_IDLE, ConditionVariableSignal(), fb(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), OffsetToPointer, IndexScanDescData::parallel_scan, and ParallelIndexScanDescData::ps_offset_am.

Referenced by _bt_readnextpage(), and _bt_readpage().

◆ _bt_parallel_seize()

bool _bt_parallel_seize	(	IndexScanDesc	scan,
		BlockNumber *	next_scan_page,
		BlockNumber *	last_curr_page,
		bool	first
	)

extern

Definition at line 870 of file nbtree.c.

{
    Relation    rel = scan->indexRelation;
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
    bool        exit_loop = false,
                status = true,
                endscan = false;
    ParallelIndexScanDesc parallel_scan = scan->parallel_scan;
    BTParallelScanDesc btscan;
 
    *next_scan_page = InvalidBlockNumber;
    *last_curr_page = InvalidBlockNumber;
 
    /*
     * Reset so->currPos, and initialize moreLeft/moreRight such that the next
     * call to _bt_readnextpage treats this backend similarly to a serial
     * backend that steps from *last_curr_page to *next_scan_page (unless this
     * backend's so->currPos is initialized by _bt_readfirstpage before then).
     */
    BTScanPosInvalidate(so->currPos);
    so->currPos.moreLeft = so->currPos.moreRight = true;
 
    if (first)
    {
        /*
         * Initialize array related state when called from _bt_first, assuming
         * that this will be the first primitive index scan for the scan
         */
        so->needPrimScan = false;
        so->scanBehind = false;
        so->oppositeDirCheck = false;
    }
    else
    {
        /*
         * Don't attempt to seize the scan when it requires another primitive
         * index scan, since caller's backend cannot start it right now
         */
        if (so->needPrimScan)
            return false;
    }
 
    btscan = (BTParallelScanDesc) OffsetToPointer(parallel_scan,
                                                  parallel_scan->ps_offset_am);
 
    while (1)
    {
        LWLockAcquire(&btscan->btps_lock, LW_EXCLUSIVE);
 
        if (btscan->btps_pageStatus == BTPARALLEL_DONE)
        {
            /* We're done with this parallel index scan */
            status = false;
        }
        else if (btscan->btps_pageStatus == BTPARALLEL_IDLE &&
                 btscan->btps_nextScanPage == P_NONE)
        {
            /* End this parallel index scan */
            status = false;
            endscan = true;
        }
        else if (btscan->btps_pageStatus == BTPARALLEL_NEED_PRIMSCAN)
        {
            Assert(so->numArrayKeys);
 
            if (first)
            {
                /* Can start scheduled primitive scan right away, so do so */
                btscan->btps_pageStatus = BTPARALLEL_ADVANCING;
 
                /* Restore scan's array keys from serialized values */
                _bt_parallel_restore_arrays(rel, btscan, so);
                exit_loop = true;
            }
            else
            {
                /*
                 * Don't attempt to seize the scan when it requires another
                 * primitive index scan, since caller's backend cannot start
                 * it right now
                 */
                status = false;
            }
 
            /*
             * Either way, update backend local state to indicate that a
             * pending primitive scan is required
             */
            so->needPrimScan = true;
            so->scanBehind = false;
            so->oppositeDirCheck = false;
        }
        else if (btscan->btps_pageStatus != BTPARALLEL_ADVANCING)
        {
            /*
             * We have successfully seized control of the scan for the purpose
             * of advancing it to a new page!
             */
            btscan->btps_pageStatus = BTPARALLEL_ADVANCING;
            Assert(btscan->btps_nextScanPage != P_NONE);
            *next_scan_page = btscan->btps_nextScanPage;
            *last_curr_page = btscan->btps_lastCurrPage;
            exit_loop = true;
        }
        LWLockRelease(&btscan->btps_lock);
        if (exit_loop || !status)
            break;
        ConditionVariableSleep(&btscan->btps_cv, WAIT_EVENT_BTREE_PAGE);
    }
    ConditionVariableCancelSleep();
 
    /* When the scan has reached the rightmost (or leftmost) page, end it */
    if (endscan)
        _bt_parallel_done(scan);
 
    return status;
}

References _bt_parallel_done(), _bt_parallel_restore_arrays(), Assert, BTPARALLEL_ADVANCING, BTPARALLEL_DONE, BTPARALLEL_IDLE, BTPARALLEL_NEED_PRIMSCAN, BTScanPosInvalidate, ConditionVariableCancelSleep(), ConditionVariableSleep(), fb(), IndexScanDescData::indexRelation, InvalidBlockNumber, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), OffsetToPointer, IndexScanDescData::opaque, P_NONE, IndexScanDescData::parallel_scan, and ParallelIndexScanDescData::ps_offset_am.

Referenced by _bt_first(), and _bt_readnextpage().

◆ _bt_pendingfsm_finalize()

void _bt_pendingfsm_finalize	(	Relation	rel,
		BTVacState *	vstate
	)

extern

Definition at line 3033 of file nbtpage.c.

{
    IndexBulkDeleteResult *stats = vstate->stats;
    Relation    heaprel = vstate->info->heaprel;
 
    Assert(stats->pages_newly_deleted >= vstate->npendingpages);
    Assert(heaprel != NULL);
 
    if (vstate->npendingpages == 0)
    {
        /* Just free memory when nothing to do */
        if (vstate->pendingpages)
            pfree(vstate->pendingpages);
 
        return;
    }
 
#ifdef DEBUG_BTREE_PENDING_FSM
 
    /*
     * Debugging aid: Sleep for 5 seconds to greatly increase the chances of
     * placing pending pages in the FSM.  Note that the optimization will
     * never be effective without some other backend concurrently consuming an
     * XID.
     */
    pg_usleep(5000000L);
#endif
 
    /*
     * Recompute VACUUM XID boundaries.
     *
     * We don't actually care about the oldest non-removable XID.  Computing
     * the oldest such XID has a useful side-effect that we rely on: it
     * forcibly updates the XID horizon state for this backend.  This step is
     * essential; GlobalVisCheckRemovableFullXid() will not reliably recognize
     * that it is now safe to recycle newly deleted pages without this step.
     */
    GetOldestNonRemovableTransactionId(heaprel);
 
    for (int i = 0; i < vstate->npendingpages; i++)
    {
        BlockNumber target = vstate->pendingpages[i].target;
        FullTransactionId safexid = vstate->pendingpages[i].safexid;
 
        /*
         * Do the equivalent of checking BTPageIsRecyclable(), but without
         * accessing the page again a second time.
         *
         * Give up on finding the first non-recyclable page -- all later pages
         * must be non-recyclable too, since _bt_pendingfsm_add() adds pages
         * to the array in safexid order.
         */
        if (!GlobalVisCheckRemovableFullXid(heaprel, safexid))
            break;
 
        RecordFreeIndexPage(rel, target);
        stats->pages_free++;
    }
 
    pfree(vstate->pendingpages);
}

References Assert, fb(), GetOldestNonRemovableTransactionId(), GlobalVisCheckRemovableFullXid(), i, IndexBulkDeleteResult::pages_free, IndexBulkDeleteResult::pages_newly_deleted, pfree(), pg_usleep(), and RecordFreeIndexPage().

Referenced by btvacuumscan().

◆ _bt_pendingfsm_init()

void _bt_pendingfsm_init	(	Relation	rel,
		BTVacState *	vstate,
		bool	cleanuponly
	)

extern

Definition at line 2991 of file nbtpage.c.

{
    Size        maxbufsize;
 
    /*
     * Don't bother with optimization in cleanup-only case -- we don't expect
     * any newly deleted pages.  Besides, cleanup-only calls to btvacuumscan()
     * can only take place because this optimization didn't work out during
     * the last VACUUM.
     */
    if (cleanuponly)
        return;
 
    /*
     * Cap maximum size of array so that we always respect work_mem.  Avoid
     * int overflow here.
     */
    vstate->bufsize = 256;
    maxbufsize = (work_mem * (Size) 1024) / sizeof(BTPendingFSM);
    maxbufsize = Min(maxbufsize, MaxAllocSize / sizeof(BTPendingFSM));
    /* BTVacState.maxbufsize has type int */
    maxbufsize = Min(maxbufsize, INT_MAX);
    /* Stay sane with small work_mem */
    maxbufsize = Max(maxbufsize, vstate->bufsize);
    vstate->maxbufsize = (int) maxbufsize;
 
    /* Allocate buffer, indicate that there are currently 0 pending pages */
    vstate->pendingpages = palloc_array(BTPendingFSM, vstate->bufsize);
    vstate->npendingpages = 0;
}

References fb(), Max, MaxAllocSize, Min, palloc_array, and work_mem.

Referenced by btvacuumscan().

◆ _bt_preprocess_keys()

void _bt_preprocess_keys ( IndexScanDesc scan )

extern

Definition at line 203 of file nbtpreprocesskeys.c.

{
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
    int         numberOfKeys = scan->numberOfKeys;
    int16      *indoption = scan->indexRelation->rd_indoption;
    int         new_numberOfKeys;
    int         numberOfEqualCols;
    ScanKey     inkeys;
    BTScanKeyPreproc xform[BTMaxStrategyNumber];
    bool        test_result,
                redundant_key_kept = false;
    AttrNumber  attno;
    ScanKey     arrayKeyData;
    int        *keyDataMap = NULL;
    int         arrayidx = 0;
 
    if (so->numberOfKeys > 0)
    {
        /*
         * Only need to do preprocessing once per btrescan, at most.  All
         * calls after the first are handled as no-ops.
         */
        return;
    }
 
    /* initialize result variables */
    so->qual_ok = true;
    so->numberOfKeys = 0;
 
    if (numberOfKeys < 1)
        return;                 /* done if qual-less scan */
 
    /* If any keys are SK_SEARCHARRAY type, set up array-key info */
    arrayKeyData = _bt_preprocess_array_keys(scan, &numberOfKeys);
    if (!so->qual_ok)
    {
        /* unmatchable array, so give up */
        return;
    }
 
    /*
     * Treat arrayKeyData[] (a partially preprocessed copy of scan->keyData[])
     * as our input if _bt_preprocess_array_keys just allocated it, else just
     * use scan->keyData[]
     */
    if (arrayKeyData)
    {
        inkeys = arrayKeyData;
 
        /* Also maintain keyDataMap for remapping so->orderProcs[] later */
        keyDataMap = MemoryContextAlloc(so->arrayContext,
                                        numberOfKeys * sizeof(int));
 
        /*
         * Also enlarge output array when it might otherwise not have room for
         * a skip array's scan key
         */
        if (numberOfKeys > scan->numberOfKeys)
            so->keyData = repalloc(so->keyData,
                                   numberOfKeys * sizeof(ScanKeyData));
    }
    else
        inkeys = scan->keyData;
 
    /* we check that input keys are correctly ordered */
    if (inkeys[0].sk_attno < 1)
        elog(ERROR, "btree index keys must be ordered by attribute");
 
    /* We can short-circuit most of the work if there's just one key */
    if (numberOfKeys == 1)
    {
        /* Apply indoption to scankey (might change sk_strategy!) */
        if (!_bt_fix_scankey_strategy(&inkeys[0], indoption))
            so->qual_ok = false;
        memcpy(&so->keyData[0], &inkeys[0], sizeof(ScanKeyData));
        so->numberOfKeys = 1;
        /* We can mark the qual as required if it's for first index col */
        if (inkeys[0].sk_attno == 1)
            _bt_mark_scankey_required(&so->keyData[0]);
        if (arrayKeyData)
        {
            /*
             * Don't call _bt_preprocess_array_keys_final in this fast path
             * (we'll miss out on the single value array transformation, but
             * that's not nearly as important when there's only one scan key)
             */
            Assert(so->keyData[0].sk_flags & SK_SEARCHARRAY);
            Assert(so->keyData[0].sk_strategy != BTEqualStrategyNumber ||
                   (so->arrayKeys[0].scan_key == 0 &&
                    !(so->keyData[0].sk_flags & SK_BT_SKIP) &&
                    OidIsValid(so->orderProcs[0].fn_oid)));
        }
 
        return;
    }
 
    /*
     * Otherwise, do the full set of pushups.
     */
    new_numberOfKeys = 0;
    numberOfEqualCols = 0;
 
    /*
     * Initialize for processing of keys for attr 1.
     *
     * xform[i] points to the currently best scan key of strategy type i+1; it
     * is NULL if we haven't yet found such a key for this attr.
     */
    attno = 1;
    memset(xform, 0, sizeof(xform));
 
    /*
     * Loop iterates from 0 to numberOfKeys inclusive; we use the last pass to
     * handle after-last-key processing.  Actual exit from the loop is at the
     * "break" statement below.
     */
    for (int i = 0;; i++)
    {
        ScanKey     inkey = inkeys + i;
        int         j;
 
        if (i < numberOfKeys)
        {
            /* Apply indoption to scankey (might change sk_strategy!) */
            if (!_bt_fix_scankey_strategy(inkey, indoption))
            {
                /* NULL can't be matched, so give up */
                so->qual_ok = false;
                return;
            }
        }
 
        /*
         * If we are at the end of the keys for a particular attr, finish up
         * processing and emit the cleaned-up keys.
         */
        if (i == numberOfKeys || inkey->sk_attno != attno)
        {
            int         priorNumberOfEqualCols = numberOfEqualCols;
 
            /* check input keys are correctly ordered */
            if (i < numberOfKeys && inkey->sk_attno < attno)
                elog(ERROR, "btree index keys must be ordered by attribute");
 
            /*
             * If = has been specified, all other keys can be eliminated as
             * redundant.  Note that this is no less true if the = key is
             * SEARCHARRAY; the only real difference is that the inequality
             * key _becomes_ redundant by making _bt_compare_scankey_args
             * eliminate the subset of elements that won't need to be matched
             * (with SAOP arrays and skip arrays alike).
             *
             * If we have a case like "key = 1 AND key > 2", we set qual_ok to
             * false and abandon further processing.  We'll do the same thing
             * given a case like "key IN (0, 1) AND key > 2".
             *
             * We also have to deal with the case of "key IS NULL", which is
             * unsatisfiable in combination with any other index condition. By
             * the time we get here, that's been classified as an equality
             * check, and we've rejected any combination of it with a regular
             * equality condition; but not with other types of conditions.
             */
            if (xform[BTEqualStrategyNumber - 1].inkey)
            {
                ScanKey     eq = xform[BTEqualStrategyNumber - 1].inkey;
                BTArrayKeyInfo *array = NULL;
                FmgrInfo   *orderproc = NULL;
 
                if (arrayKeyData && (eq->sk_flags & SK_SEARCHARRAY))
                {
                    int         eq_in_ikey,
                                eq_arrayidx;
 
                    eq_in_ikey = xform[BTEqualStrategyNumber - 1].inkeyi;
                    eq_arrayidx = xform[BTEqualStrategyNumber - 1].arrayidx;
                    array = &so->arrayKeys[eq_arrayidx - 1];
                    orderproc = so->orderProcs + eq_in_ikey;
 
                    Assert(array->scan_key == eq_in_ikey);
                    Assert(OidIsValid(orderproc->fn_oid));
                }
 
                for (j = BTMaxStrategyNumber; --j >= 0;)
                {
                    ScanKey     chk = xform[j].inkey;
 
                    if (!chk || j == (BTEqualStrategyNumber - 1))
                        continue;
 
                    if (eq->sk_flags & SK_SEARCHNULL)
                    {
                        /* IS NULL is contradictory to anything else */
                        so->qual_ok = false;
                        return;
                    }
 
                    if (_bt_compare_scankey_args(scan, chk, eq, chk,
                                                 array, orderproc,
                                                 &test_result))
                    {
                        if (!test_result)
                        {
                            /* keys proven mutually contradictory */
                            so->qual_ok = false;
                            return;
                        }
                        /* else discard the redundant non-equality key */
                        xform[j].inkey = NULL;
                        xform[j].inkeyi = -1;
                    }
                    else
                        redundant_key_kept = true;
                }
                /* track number of attrs for which we have "=" keys */
                numberOfEqualCols++;
            }
 
            /* try to keep only one of <, <= */
            if (xform[BTLessStrategyNumber - 1].inkey &&
                xform[BTLessEqualStrategyNumber - 1].inkey)
            {
                ScanKey     lt = xform[BTLessStrategyNumber - 1].inkey;
                ScanKey     le = xform[BTLessEqualStrategyNumber - 1].inkey;
 
                if (_bt_compare_scankey_args(scan, le, lt, le, NULL, NULL,
                                             &test_result))
                {
                    if (test_result)
                        xform[BTLessEqualStrategyNumber - 1].inkey = NULL;
                    else
                        xform[BTLessStrategyNumber - 1].inkey = NULL;
                }
                else
                    redundant_key_kept = true;
            }
 
            /* try to keep only one of >, >= */
            if (xform[BTGreaterStrategyNumber - 1].inkey &&
                xform[BTGreaterEqualStrategyNumber - 1].inkey)
            {
                ScanKey     gt = xform[BTGreaterStrategyNumber - 1].inkey;
                ScanKey     ge = xform[BTGreaterEqualStrategyNumber - 1].inkey;
 
                if (_bt_compare_scankey_args(scan, ge, gt, ge, NULL, NULL,
                                             &test_result))
                {
                    if (test_result)
                        xform[BTGreaterEqualStrategyNumber - 1].inkey = NULL;
                    else
                        xform[BTGreaterStrategyNumber - 1].inkey = NULL;
                }
                else
                    redundant_key_kept = true;
            }
 
            /*
             * Emit the cleaned-up keys into the so->keyData[] array, and then
             * mark them if they are required.  They are required (possibly
             * only in one direction) if all attrs before this one had "=".
             *
             * In practice we'll rarely output non-required scan keys here;
             * typically, _bt_preprocess_array_keys has already added "=" keys
             * sufficient to form an unbroken series of "=" constraints on all
             * attrs prior to the attr from the final scan->keyData[] key.
             */
            for (j = BTMaxStrategyNumber; --j >= 0;)
            {
                if (xform[j].inkey)
                {
                    ScanKey     outkey = &so->keyData[new_numberOfKeys++];
 
                    memcpy(outkey, xform[j].inkey, sizeof(ScanKeyData));
                    if (arrayKeyData)
                        keyDataMap[new_numberOfKeys - 1] = xform[j].inkeyi;
                    if (priorNumberOfEqualCols == attno - 1)
                        _bt_mark_scankey_required(outkey);
                }
            }
 
            /*
             * Exit loop here if done.
             */
            if (i == numberOfKeys)
                break;
 
            /* Re-initialize for new attno */
            attno = inkey->sk_attno;
            memset(xform, 0, sizeof(xform));
        }
 
        /* check strategy this key's operator corresponds to */
        j = inkey->sk_strategy - 1;
 
        if (inkey->sk_strategy == BTEqualStrategyNumber &&
            (inkey->sk_flags & SK_SEARCHARRAY))
        {
            /* must track how input scan keys map to arrays */
            Assert(arrayKeyData);
            arrayidx++;
        }
 
        /*
         * have we seen a scan key for this same attribute and using this same
         * operator strategy before now?
         */
        if (xform[j].inkey == NULL)
        {
            /* nope, so this scan key wins by default (at least for now) */
            xform[j].inkey = inkey;
            xform[j].inkeyi = i;
            xform[j].arrayidx = arrayidx;
        }
        else
        {
            FmgrInfo   *orderproc = NULL;
            BTArrayKeyInfo *array = NULL;
 
            /*
             * Seen one of these before, so keep only the more restrictive key
             * if possible
             */
            if (j == (BTEqualStrategyNumber - 1) && arrayKeyData)
            {
                /*
                 * Have to set up array keys
                 */
                if (inkey->sk_flags & SK_SEARCHARRAY)
                {
                    array = &so->arrayKeys[arrayidx - 1];
                    orderproc = so->orderProcs + i;
 
                    Assert(array->scan_key == i);
                    Assert(OidIsValid(orderproc->fn_oid));
                    Assert(!(inkey->sk_flags & SK_BT_SKIP));
                }
                else if (xform[j].inkey->sk_flags & SK_SEARCHARRAY)
                {
                    array = &so->arrayKeys[xform[j].arrayidx - 1];
                    orderproc = so->orderProcs + xform[j].inkeyi;
 
                    Assert(array->scan_key == xform[j].inkeyi);
                    Assert(OidIsValid(orderproc->fn_oid));
                    Assert(!(xform[j].inkey->sk_flags & SK_BT_SKIP));
                }
 
                /*
                 * Both scan keys might have arrays, in which case we'll
                 * arbitrarily pass only one of the arrays.  That won't
                 * matter, since _bt_compare_scankey_args is aware that two
                 * SEARCHARRAY scan keys mean that _bt_preprocess_array_keys
                 * failed to eliminate redundant arrays through array merging.
                 * _bt_compare_scankey_args just returns false when it sees
                 * this; it won't even try to examine either array.
                 */
            }
 
            if (_bt_compare_scankey_args(scan, inkey, inkey, xform[j].inkey,
                                         array, orderproc, &test_result))
            {
                /* Have all we need to determine redundancy */
                if (test_result)
                {
                    /*
                     * New key is more restrictive, and so replaces old key...
                     */
                    if (j != (BTEqualStrategyNumber - 1) ||
                        !(xform[j].inkey->sk_flags & SK_SEARCHARRAY))
                    {
                        xform[j].inkey = inkey;
                        xform[j].inkeyi = i;
                        xform[j].arrayidx = arrayidx;
                    }
                    else
                    {
                        /*
                         * ...unless we have to keep the old key because it's
                         * an array that rendered the new key redundant.  We
                         * need to make sure that we don't throw away an array
                         * scan key.  _bt_preprocess_array_keys_final expects
                         * us to keep all of the arrays that weren't already
                         * eliminated by _bt_preprocess_array_keys earlier on.
                         */
                        Assert(!(inkey->sk_flags & SK_SEARCHARRAY));
                    }
                }
                else if (j == (BTEqualStrategyNumber - 1))
                {
                    /* key == a && key == b, but a != b */
                    so->qual_ok = false;
                    return;
                }
                /* else old key is more restrictive, keep it */
            }
            else
            {
                /*
                 * We can't determine which key is more restrictive.  Push
                 * xform[j] directly to the output array, then set xform[j] to
                 * the new scan key.
                 *
                 * Note: We do things this way around so that our arrays are
                 * always in the same order as their corresponding scan keys.
                 * _bt_preprocess_array_keys_final expects this.
                 */
                ScanKey     outkey = &so->keyData[new_numberOfKeys++];
 
                memcpy(outkey, xform[j].inkey, sizeof(ScanKeyData));
                if (arrayKeyData)
                    keyDataMap[new_numberOfKeys - 1] = xform[j].inkeyi;
                if (numberOfEqualCols == attno - 1)
                    _bt_mark_scankey_required(outkey);
                xform[j].inkey = inkey;
                xform[j].inkeyi = i;
                xform[j].arrayidx = arrayidx;
                redundant_key_kept = true;
            }
        }
    }
 
    so->numberOfKeys = new_numberOfKeys;
 
    /*
     * Now that we've built a temporary mapping from so->keyData[] (output
     * scan keys) to arrayKeyData[] (our input scan keys), fix array->scan_key
     * references.  Also consolidate the so->orderProcs[] array such that it
     * can be subscripted using so->keyData[]-wise offsets.
     */
    if (arrayKeyData)
        _bt_preprocess_array_keys_final(scan, keyDataMap);
 
    /*
     * If there are remaining redundant inequality keys, we must make sure
     * that each index attribute has no more than one required >/>= key, and
     * no more than one required </<= key.  Attributes that have one or more
     * required = keys now must keep only one required key (the first = key).
     */
    if (unlikely(redundant_key_kept) && so->qual_ok)
        _bt_unmark_keys(scan, keyDataMap);
 
    /* Could pfree arrayKeyData/keyDataMap now, but not worth the cycles */
}

References _bt_compare_scankey_args(), _bt_fix_scankey_strategy(), _bt_mark_scankey_required(), _bt_preprocess_array_keys(), _bt_preprocess_array_keys_final(), _bt_unmark_keys(), Assert, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, BTMaxStrategyNumber, elog, ERROR, fb(), i, IndexScanDescData::indexRelation, j, IndexScanDescData::keyData, memcpy(), MemoryContextAlloc(), IndexScanDescData::numberOfKeys, OidIsValid, IndexScanDescData::opaque, RelationData::rd_indoption, repalloc(), BTArrayKeyInfo::scan_key, ScanKeyData::sk_attno, SK_BT_SKIP, ScanKeyData::sk_flags, SK_SEARCHARRAY, SK_SEARCHNULL, ScanKeyData::sk_strategy, and unlikely.

Referenced by _bt_first().

◆ _bt_readpage()

bool _bt_readpage	(	IndexScanDesc	scan,
		ScanDirection	dir,
		OffsetNumber	offnum,
		bool	firstpage
	)

extern

Definition at line 134 of file nbtreadpage.c.

{
    Relation    rel = scan->indexRelation;
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
    Page        page;
    BTPageOpaque opaque;
    OffsetNumber minoff;
    OffsetNumber maxoff;
    BTReadPageState pstate;
    bool        arrayKeys,
                ignore_killed_tuples = scan->ignore_killed_tuples;
    int         itemIndex,
                indnatts;
 
    /* save the page/buffer block number, along with its sibling links */
    page = BufferGetPage(so->currPos.buf);
    opaque = BTPageGetOpaque(page);
    so->currPos.currPage = BufferGetBlockNumber(so->currPos.buf);
    so->currPos.prevPage = opaque->btpo_prev;
    so->currPos.nextPage = opaque->btpo_next;
    /* delay setting so->currPos.lsn until _bt_drop_lock_and_maybe_pin */
    pstate.dir = so->currPos.dir = dir;
    so->currPos.nextTupleOffset = 0;
 
    /* either moreRight or moreLeft should be set now (may be unset later) */
    Assert(ScanDirectionIsForward(dir) ? so->currPos.moreRight :
           so->currPos.moreLeft);
    Assert(!P_IGNORE(opaque));
    Assert(BTScanPosIsPinned(so->currPos));
    Assert(!so->needPrimScan);
 
    /* initialize local variables */
    indnatts = IndexRelationGetNumberOfAttributes(rel);
    arrayKeys = so->numArrayKeys != 0;
    minoff = P_FIRSTDATAKEY(opaque);
    maxoff = PageGetMaxOffsetNumber(page);
 
    /* initialize page-level state that we'll pass to _bt_checkkeys */
    pstate.minoff = minoff;
    pstate.maxoff = maxoff;
    pstate.finaltup = NULL;
    pstate.page = page;
    pstate.firstpage = firstpage;
    pstate.forcenonrequired = false;
    pstate.startikey = 0;
    pstate.offnum = InvalidOffsetNumber;
    pstate.skip = InvalidOffsetNumber;
    pstate.continuescan = true; /* default assumption */
    pstate.rechecks = 0;
    pstate.targetdistance = 0;
    pstate.nskipadvances = 0;
 
    if (scan->parallel_scan)
    {
        /* allow next/prev page to be read by other worker without delay */
        if (ScanDirectionIsForward(dir))
            _bt_parallel_release(scan, so->currPos.nextPage,
                                 so->currPos.currPage);
        else
            _bt_parallel_release(scan, so->currPos.prevPage,
                                 so->currPos.currPage);
    }
 
    PredicateLockPage(rel, so->currPos.currPage, scan->xs_snapshot);
 
    if (ScanDirectionIsForward(dir))
    {
        /* SK_SEARCHARRAY forward scans must provide high key up front */
        if (arrayKeys)
        {
            if (!P_RIGHTMOST(opaque))
            {
                ItemId      iid = PageGetItemId(page, P_HIKEY);
 
                pstate.finaltup = (IndexTuple) PageGetItem(page, iid);
 
                if (unlikely(so->scanBehind) &&
                    !_bt_scanbehind_checkkeys(scan, dir, pstate.finaltup))
                {
                    /* Schedule another primitive index scan after all */
                    so->currPos.moreRight = false;
                    so->needPrimScan = true;
                    if (scan->parallel_scan)
                        _bt_parallel_primscan_schedule(scan,
                                                       so->currPos.currPage);
                    return false;
                }
            }
 
            so->scanBehind = so->oppositeDirCheck = false;  /* reset */
        }
 
        /*
         * Consider pstate.startikey optimization once the ongoing primitive
         * index scan has already read at least one page
         */
        if (!pstate.firstpage && minoff < maxoff)
            _bt_set_startikey(scan, &pstate);
 
        /* load items[] in ascending order */
        itemIndex = 0;
 
        offnum = Max(offnum, minoff);
 
        while (offnum <= maxoff)
        {
            ItemId      iid = PageGetItemId(page, offnum);
            IndexTuple  itup;
            bool        passes_quals;
 
            /*
             * If the scan specifies not to return killed tuples, then we
             * treat a killed tuple as not passing the qual
             */
            if (ignore_killed_tuples && ItemIdIsDead(iid))
            {
                offnum = OffsetNumberNext(offnum);
                continue;
            }
 
            itup = (IndexTuple) PageGetItem(page, iid);
            Assert(!BTreeTupleIsPivot(itup));
 
            pstate.offnum = offnum;
            passes_quals = _bt_checkkeys(scan, &pstate, arrayKeys,
                                         itup, indnatts);
 
            /*
             * Check if we need to skip ahead to a later tuple (only possible
             * when the scan uses array keys)
             */
            if (arrayKeys && OffsetNumberIsValid(pstate.skip))
            {
                Assert(!passes_quals && pstate.continuescan);
                Assert(offnum < pstate.skip);
                Assert(!pstate.forcenonrequired);
 
                offnum = pstate.skip;
                pstate.skip = InvalidOffsetNumber;
                continue;
            }
 
            if (passes_quals)
            {
                /* tuple passes all scan key conditions */
                if (!BTreeTupleIsPosting(itup))
                {
                    /* Remember it */
                    _bt_saveitem(so, itemIndex, offnum, itup);
                    itemIndex++;
                }
                else
                {
                    int         tupleOffset;
 
                    /* Set up posting list state (and remember first TID) */
                    tupleOffset =
                        _bt_setuppostingitems(so, itemIndex, offnum,
                                              BTreeTupleGetPostingN(itup, 0),
                                              itup);
                    itemIndex++;
 
                    /* Remember all later TIDs (must be at least one) */
                    for (int i = 1; i < BTreeTupleGetNPosting(itup); i++)
                    {
                        _bt_savepostingitem(so, itemIndex, offnum,
                                            BTreeTupleGetPostingN(itup, i),
                                            tupleOffset);
                        itemIndex++;
                    }
                }
            }
            /* When !continuescan, there can't be any more matches, so stop */
            if (!pstate.continuescan)
                break;
 
            offnum = OffsetNumberNext(offnum);
        }
 
        /*
         * We don't need to visit page to the right when the high key
         * indicates that no more matches will be found there.
         *
         * Checking the high key like this works out more often than you might
         * think.  Leaf page splits pick a split point between the two most
         * dissimilar tuples (this is weighed against the need to evenly share
         * free space).  Leaf pages with high key attribute values that can
         * only appear on non-pivot tuples on the right sibling page are
         * common.
         */
        if (pstate.continuescan && !so->scanBehind && !P_RIGHTMOST(opaque))
        {
            ItemId      iid = PageGetItemId(page, P_HIKEY);
            IndexTuple  itup = (IndexTuple) PageGetItem(page, iid);
            int         truncatt;
 
            /* Reset arrays, per _bt_set_startikey contract */
            if (pstate.forcenonrequired)
                _bt_start_array_keys(scan, dir);
            pstate.forcenonrequired = false;
            pstate.startikey = 0;   /* _bt_set_startikey ignores P_HIKEY */
 
            truncatt = BTreeTupleGetNAtts(itup, rel);
            _bt_checkkeys(scan, &pstate, arrayKeys, itup, truncatt);
        }
 
        if (!pstate.continuescan)
            so->currPos.moreRight = false;
 
        Assert(itemIndex <= MaxTIDsPerBTreePage);
        so->currPos.firstItem = 0;
        so->currPos.lastItem = itemIndex - 1;
        so->currPos.itemIndex = 0;
    }
    else
    {
        /* SK_SEARCHARRAY backward scans must provide final tuple up front */
        if (arrayKeys)
        {
            if (minoff <= maxoff && !P_LEFTMOST(opaque))
            {
                ItemId      iid = PageGetItemId(page, minoff);
 
                pstate.finaltup = (IndexTuple) PageGetItem(page, iid);
 
                if (unlikely(so->scanBehind) &&
                    !_bt_scanbehind_checkkeys(scan, dir, pstate.finaltup))
                {
                    /* Schedule another primitive index scan after all */
                    so->currPos.moreLeft = false;
                    so->needPrimScan = true;
                    if (scan->parallel_scan)
                        _bt_parallel_primscan_schedule(scan,
                                                       so->currPos.currPage);
                    return false;
                }
            }
 
            so->scanBehind = so->oppositeDirCheck = false;  /* reset */
        }
 
        /*
         * Consider pstate.startikey optimization once the ongoing primitive
         * index scan has already read at least one page
         */
        if (!pstate.firstpage && minoff < maxoff)
            _bt_set_startikey(scan, &pstate);
 
        /* load items[] in descending order */
        itemIndex = MaxTIDsPerBTreePage;
 
        offnum = Min(offnum, maxoff);
 
        while (offnum >= minoff)
        {
            ItemId      iid = PageGetItemId(page, offnum);
            IndexTuple  itup;
            bool        tuple_alive;
            bool        passes_quals;
 
            /*
             * If the scan specifies not to return killed tuples, then we
             * treat a killed tuple as not passing the qual.  Most of the
             * time, it's a win to not bother examining the tuple's index
             * keys, but just skip to the next tuple (previous, actually,
             * since we're scanning backwards).  However, if this is the first
             * tuple on the page, we do check the index keys, to prevent
             * uselessly advancing to the page to the left.  This is similar
             * to the high key optimization used by forward scans.
             */
            if (ignore_killed_tuples && ItemIdIsDead(iid))
            {
                if (offnum > minoff)
                {
                    offnum = OffsetNumberPrev(offnum);
                    continue;
                }
 
                tuple_alive = false;
            }
            else
                tuple_alive = true;
 
            itup = (IndexTuple) PageGetItem(page, iid);
            Assert(!BTreeTupleIsPivot(itup));
 
            pstate.offnum = offnum;
            if (arrayKeys && offnum == minoff && pstate.forcenonrequired)
            {
                /* Reset arrays, per _bt_set_startikey contract */
                pstate.forcenonrequired = false;
                pstate.startikey = 0;
                _bt_start_array_keys(scan, dir);
            }
            passes_quals = _bt_checkkeys(scan, &pstate, arrayKeys,
                                         itup, indnatts);
 
            if (arrayKeys && so->scanBehind)
            {
                /*
                 * Done scanning this page, but not done with the current
                 * primscan.
                 *
                 * Note: Forward scans don't check this explicitly, since they
                 * prefer to reuse pstate.skip for this instead.
                 */
                Assert(!passes_quals && pstate.continuescan);
                Assert(!pstate.forcenonrequired);
 
                break;
            }
 
            /*
             * Check if we need to skip ahead to a later tuple (only possible
             * when the scan uses array keys)
             */
            if (arrayKeys && OffsetNumberIsValid(pstate.skip))
            {
                Assert(!passes_quals && pstate.continuescan);
                Assert(offnum > pstate.skip);
                Assert(!pstate.forcenonrequired);
 
                offnum = pstate.skip;
                pstate.skip = InvalidOffsetNumber;
                continue;
            }
 
            if (passes_quals && tuple_alive)
            {
                /* tuple passes all scan key conditions */
                if (!BTreeTupleIsPosting(itup))
                {
                    /* Remember it */
                    itemIndex--;
                    _bt_saveitem(so, itemIndex, offnum, itup);
                }
                else
                {
                    uint16      nitems = BTreeTupleGetNPosting(itup);
                    int         tupleOffset;
 
                    /* Set up posting list state (and remember last TID) */
                    itemIndex--;
                    tupleOffset =
                        _bt_setuppostingitems(so, itemIndex, offnum,
                                              BTreeTupleGetPostingN(itup, nitems - 1),
                                              itup);
 
                    /* Remember all prior TIDs (must be at least one) */
                    for (int i = nitems - 2; i >= 0; i--)
                    {
                        itemIndex--;
                        _bt_savepostingitem(so, itemIndex, offnum,
                                            BTreeTupleGetPostingN(itup, i),
                                            tupleOffset);
                    }
                }
            }
            /* When !continuescan, there can't be any more matches, so stop */
            if (!pstate.continuescan)
                break;
 
            offnum = OffsetNumberPrev(offnum);
        }
 
        /*
         * We don't need to visit page to the left when no more matches will
         * be found there
         */
        if (!pstate.continuescan)
            so->currPos.moreLeft = false;
 
        Assert(itemIndex >= 0);
        so->currPos.firstItem = itemIndex;
        so->currPos.lastItem = MaxTIDsPerBTreePage - 1;
        so->currPos.itemIndex = MaxTIDsPerBTreePage - 1;
    }
 
    /*
     * If _bt_set_startikey told us to temporarily treat the scan's keys as
     * nonrequired (possible only during scans with array keys), there must be
     * no lasting consequences for the scan's array keys.  The scan's arrays
     * should now have exactly the same elements as they would have had if the
     * nonrequired behavior had never been used.  (In general, a scan's arrays
     * are expected to track its progress through the index's key space.)
     *
     * We are required (by _bt_set_startikey) to call _bt_checkkeys against
     * pstate.finaltup with pstate.forcenonrequired=false to allow the scan's
     * arrays to recover.  Assert that that step hasn't been missed.
     */
    Assert(!pstate.forcenonrequired);
 
    return (so->currPos.firstItem <= so->currPos.lastItem);
}

References _bt_checkkeys(), _bt_parallel_primscan_schedule(), _bt_parallel_release(), _bt_saveitem(), _bt_savepostingitem(), _bt_scanbehind_checkkeys(), _bt_set_startikey(), _bt_setuppostingitems(), _bt_start_array_keys(), Assert, BTPageGetOpaque, BTPageOpaqueData::btpo_next, BTPageOpaqueData::btpo_prev, BTreeTupleGetNAtts, BTreeTupleGetNPosting(), BTreeTupleGetPostingN(), BTreeTupleIsPivot(), BTreeTupleIsPosting(), BTScanPosIsPinned, BufferGetBlockNumber(), BufferGetPage(), BTReadPageState::continuescan, BTReadPageState::dir, fb(), BTReadPageState::finaltup, BTReadPageState::firstpage, BTReadPageState::forcenonrequired, i, IndexScanDescData::ignore_killed_tuples, IndexScanDescData::indexRelation, IndexRelationGetNumberOfAttributes, InvalidOffsetNumber, ItemIdIsDead, Max, BTReadPageState::maxoff, MaxTIDsPerBTreePage, Min, BTReadPageState::minoff, nitems, BTReadPageState::nskipadvances, BTReadPageState::offnum, OffsetNumberIsValid, OffsetNumberNext, OffsetNumberPrev, IndexScanDescData::opaque, P_FIRSTDATAKEY, P_HIKEY, P_IGNORE, P_LEFTMOST, P_RIGHTMOST, BTReadPageState::page, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), IndexScanDescData::parallel_scan, PredicateLockPage(), BTReadPageState::rechecks, ScanDirectionIsForward, BTReadPageState::skip, BTReadPageState::startikey, BTReadPageState::targetdistance, unlikely, and IndexScanDescData::xs_snapshot.

Referenced by _bt_readfirstpage(), and _bt_readnextpage().

◆ _bt_relandgetbuf()

Buffer _bt_relandgetbuf	(	Relation	rel,
		Buffer	obuf,
		BlockNumber	blkno,
		int	access
	)

extern

Definition at line 1008 of file nbtpage.c.

{
    Buffer      buf;
 
    Assert(BlockNumberIsValid(blkno));
    if (BufferIsValid(obuf))
    {
        if (BufferGetBlockNumber(obuf) == blkno)
        {
            /* trade in old lock mode for new lock */
            _bt_unlockbuf(rel, obuf);
            buf = obuf;
        }
        else
        {
            /* release lock and pin at once, that's a bit more efficient */
            _bt_relbuf(rel, obuf);
            buf = ReadBuffer(rel, blkno);
        }
    }
    else
        buf = ReadBuffer(rel, blkno);
 
    _bt_lockbuf(rel, buf, access);
    _bt_checkpage(rel, buf);
 
    return buf;
}

References _bt_checkpage(), _bt_lockbuf(), _bt_relbuf(), _bt_unlockbuf(), Assert, BlockNumberIsValid(), buf, BufferGetBlockNumber(), BufferIsValid(), fb(), and ReadBuffer().

Referenced by _bt_check_unique(), _bt_get_endpoint(), _bt_getroot(), _bt_gettrueroot(), _bt_lock_and_validate_left(), _bt_moveright(), _bt_search(), and _bt_stepright().

◆ _bt_relbuf()

void _bt_relbuf	(	Relation	rel,
		Buffer	buf
	)

extern

Definition at line 1044 of file nbtpage.c.

{
    /*
     * Buffer is pinned and locked, which means that it is expected to be
     * defined and addressable.  Check that proactively.
     */
    VALGRIND_CHECK_MEM_IS_DEFINED(BufferGetPage(buf), BLCKSZ);
    if (!RelationUsesLocalBuffers(rel))
        VALGRIND_MAKE_MEM_NOACCESS(BufferGetPage(buf), BLCKSZ);
 
    UnlockReleaseBuffer(buf);
}

References buf, BufferGetPage(), fb(), RelationUsesLocalBuffers, UnlockReleaseBuffer(), VALGRIND_CHECK_MEM_IS_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by _bt_allocbuf(), _bt_check_unique(), _bt_doinsert(), _bt_drop_lock_and_maybe_pin(), _bt_finish_split(), _bt_getroot(), _bt_getrootheight(), _bt_getstackbuf(), _bt_gettrueroot(), _bt_insert_parent(), _bt_insertonpg(), _bt_killitems(), _bt_leftsib_splitflag(), _bt_lock_and_validate_left(), _bt_lock_subtree_parent(), _bt_mark_page_halfdead(), _bt_metaversion(), _bt_moveright(), _bt_newlevel(), _bt_pagedel(), _bt_readnextpage(), _bt_relandgetbuf(), _bt_rightsib_halfdeadflag(), _bt_search_insert(), _bt_set_cleanup_info(), _bt_split(), _bt_stepright(), _bt_unlink_halfdead_page(), _bt_vacuum_needs_cleanup(), bt_rootdescend(), btvacuumpage(), and pgstat_btree_page().

◆ _bt_search()

BTStack _bt_search	(	Relation	rel,
		Relation	heaprel,
		BTScanInsert	key,
		Buffer *	bufP,
		int	access,
		bool	returnstack
	)

extern

Definition at line 100 of file nbtsearch.c.

{
    BTStack     stack_in = NULL;
    int         page_access = BT_READ;
 
    /* heaprel must be set whenever _bt_allocbuf is reachable */
    Assert(access == BT_READ || access == BT_WRITE);
    Assert(access == BT_READ || heaprel != NULL);
 
    /* Get the root page to start with */
    *bufP = _bt_getroot(rel, heaprel, access);
 
    /* If index is empty and access = BT_READ, no root page is created. */
    if (!BufferIsValid(*bufP))
        return (BTStack) NULL;
 
    /* Loop iterates once per level descended in the tree */
    for (;;)
    {
        Page        page;
        BTPageOpaque opaque;
        OffsetNumber offnum;
        ItemId      itemid;
        IndexTuple  itup;
        BlockNumber child;
        BTStack     new_stack;
 
        /*
         * Race -- the page we just grabbed may have split since we read its
         * downlink in its parent page (or the metapage).  If it has, we may
         * need to move right to its new sibling.  Do that.
         *
         * In write-mode, allow _bt_moveright to finish any incomplete splits
         * along the way.  Strictly speaking, we'd only need to finish an
         * incomplete split on the leaf page we're about to insert to, not on
         * any of the upper levels (internal pages with incomplete splits are
         * also taken care of in _bt_getstackbuf).  But this is a good
         * opportunity to finish splits of internal pages too.
         */
        *bufP = _bt_moveright(rel, heaprel, key, *bufP, (access == BT_WRITE),
                              stack_in, page_access);
 
        /* if this is a leaf page, we're done */
        page = BufferGetPage(*bufP);
        opaque = BTPageGetOpaque(page);
        if (P_ISLEAF(opaque))
            break;
 
        /*
         * Find the appropriate pivot tuple on this page.  Its downlink points
         * to the child page that we're about to descend to.
         */
        offnum = _bt_binsrch(rel, key, *bufP);
        itemid = PageGetItemId(page, offnum);
        itup = (IndexTuple) PageGetItem(page, itemid);
        Assert(BTreeTupleIsPivot(itup) || !key->heapkeyspace);
        child = BTreeTupleGetDownLink(itup);
 
        /*
         * We need to save the location of the pivot tuple we chose in a new
         * stack entry for this page/level.  If caller ends up splitting a
         * page one level down, it usually ends up inserting a new pivot
         * tuple/downlink immediately after the location recorded here.
         */
        if (returnstack)
        {
            new_stack = (BTStack) palloc_object(BTStackData);
            new_stack->bts_blkno = BufferGetBlockNumber(*bufP);
            new_stack->bts_offset = offnum;
            new_stack->bts_parent = stack_in;
            stack_in = new_stack;
        }
 
        /*
         * Page level 1 is lowest non-leaf page level prior to leaves.  So, if
         * we're on the level 1 and asked to lock leaf page in write mode,
         * then lock next page in write mode, because it must be a leaf.
         */
        if (opaque->btpo_level == 1 && access == BT_WRITE)
            page_access = BT_WRITE;
 
        /* drop the read lock on the page, then acquire one on its child */
        *bufP = _bt_relandgetbuf(rel, *bufP, child, page_access);
 
        /* okay, all set to move down a level */
    }
 
    /*
     * If we're asked to lock leaf in write mode, but didn't manage to, then
     * relock.  This should only happen when the root page is a leaf page (and
     * the only page in the index other than the metapage).
     */
    if (access == BT_WRITE && page_access == BT_READ)
    {
        /* trade in our read lock for a write lock */
        _bt_unlockbuf(rel, *bufP);
        _bt_lockbuf(rel, *bufP, BT_WRITE);
 
        /*
         * Race -- the leaf page may have split after we dropped the read lock
         * but before we acquired a write lock.  If it has, we may need to
         * move right to its new sibling.  Do that.
         */
        *bufP = _bt_moveright(rel, heaprel, key, *bufP, true, stack_in, BT_WRITE);
    }
 
    return stack_in;
}

References _bt_binsrch(), _bt_getroot(), _bt_lockbuf(), _bt_moveright(), _bt_relandgetbuf(), _bt_unlockbuf(), Assert, BT_READ, BT_WRITE, BTPageGetOpaque, BTPageOpaqueData::btpo_level, BTreeTupleGetDownLink(), BTreeTupleIsPivot(), BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), fb(), P_ISLEAF, PageGetItem(), PageGetItemId(), and palloc_object.

Referenced by _bt_first(), _bt_pagedel(), _bt_search_insert(), and bt_rootdescend().

◆ _bt_set_cleanup_info()

void _bt_set_cleanup_info	(	Relation	rel,
		BlockNumber	num_delpages
	)

extern

Definition at line 233 of file nbtpage.c.

{
    Buffer      metabuf;
    Page        metapg;
    BTMetaPageData *metad;
    XLogRecPtr  recptr;
 
    /*
     * On-disk compatibility note: The btm_last_cleanup_num_delpages metapage
     * field started out as a TransactionId field called btm_oldest_btpo_xact.
     * Both "versions" are just uint32 fields.  It was convenient to repurpose
     * the field when we began to use 64-bit XIDs in deleted pages.
     *
     * It's possible that a pg_upgrade'd database will contain an XID value in
     * what is now recognized as the metapage's btm_last_cleanup_num_delpages
     * field.  _bt_vacuum_needs_cleanup() may even believe that this value
     * indicates that there are lots of pages that it needs to recycle, when
     * in reality there are only one or two.  The worst that can happen is
     * that there will be a call to btvacuumscan a little earlier, which will
     * set btm_last_cleanup_num_delpages to a sane value when we're called.
     *
     * Note also that the metapage's btm_last_cleanup_num_heap_tuples field is
     * no longer used as of PostgreSQL 14.  We set it to -1.0 on rewrite, just
     * to be consistent.
     */
    metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_READ);
    metapg = BufferGetPage(metabuf);
    metad = BTPageGetMeta(metapg);
 
    /* Don't miss chance to upgrade index/metapage when BTREE_MIN_VERSION */
    if (metad->btm_version >= BTREE_NOVAC_VERSION &&
        metad->btm_last_cleanup_num_delpages == num_delpages)
    {
        /* Usually means index continues to have num_delpages of 0 */
        _bt_relbuf(rel, metabuf);
        return;
    }
 
    /* trade in our read lock for a write lock */
    _bt_unlockbuf(rel, metabuf);
    _bt_lockbuf(rel, metabuf, BT_WRITE);
 
    START_CRIT_SECTION();
 
    /* upgrade meta-page if needed */
    if (metad->btm_version < BTREE_NOVAC_VERSION)
        _bt_upgrademetapage(metapg);
 
    /* update cleanup-related information */
    metad->btm_last_cleanup_num_delpages = num_delpages;
    metad->btm_last_cleanup_num_heap_tuples = -1.0;
    MarkBufferDirty(metabuf);
 
    /* write wal record if needed */
    if (RelationNeedsWAL(rel))
    {
        xl_btree_metadata md;
 
        XLogBeginInsert();
        XLogRegisterBuffer(0, metabuf, REGBUF_WILL_INIT | REGBUF_STANDARD);
 
        Assert(metad->btm_version >= BTREE_NOVAC_VERSION);
        md.version = metad->btm_version;
        md.root = metad->btm_root;
        md.level = metad->btm_level;
        md.fastroot = metad->btm_fastroot;
        md.fastlevel = metad->btm_fastlevel;
        md.last_cleanup_num_delpages = num_delpages;
        md.allequalimage = metad->btm_allequalimage;
 
        XLogRegisterBufData(0, &md, sizeof(xl_btree_metadata));
 
        recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_META_CLEANUP);
    }
    else
        recptr = XLogGetFakeLSN(rel);
 
    PageSetLSN(metapg, recptr);
 
    END_CRIT_SECTION();
 
    _bt_relbuf(rel, metabuf);
}

References _bt_getbuf(), _bt_lockbuf(), _bt_relbuf(), _bt_unlockbuf(), _bt_upgrademetapage(), xl_btree_metadata::allequalimage, Assert, BT_READ, BT_WRITE, BTPageGetMeta, BTREE_METAPAGE, BTREE_NOVAC_VERSION, BufferGetPage(), END_CRIT_SECTION, xl_btree_metadata::fastlevel, xl_btree_metadata::fastroot, fb(), xl_btree_metadata::last_cleanup_num_delpages, xl_btree_metadata::level, MarkBufferDirty(), PageSetLSN(), REGBUF_STANDARD, REGBUF_WILL_INIT, RelationNeedsWAL, xl_btree_metadata::root, START_CRIT_SECTION, xl_btree_metadata::version, XLOG_BTREE_META_CLEANUP, XLogBeginInsert(), XLogGetFakeLSN(), XLogInsert(), XLogRegisterBufData(), and XLogRegisterBuffer().

Referenced by btvacuumcleanup().

◆ _bt_start_array_keys()

void _bt_start_array_keys	(	IndexScanDesc	scan,
		ScanDirection	dir
	)

extern

Definition at line 537 of file nbtreadpage.c.

{
    Relation    rel = scan->indexRelation;
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
 
    Assert(so->numArrayKeys);
    Assert(so->qual_ok);
 
    for (int i = 0; i < so->numArrayKeys; i++)
    {
        BTArrayKeyInfo *array = &so->arrayKeys[i];
        ScanKey     skey = &so->keyData[array->scan_key];
 
        Assert(skey->sk_flags & SK_SEARCHARRAY);
 
        _bt_array_set_low_or_high(rel, skey, array,
                                  ScanDirectionIsForward(dir));
    }
    so->scanBehind = so->oppositeDirCheck = false;  /* reset */
}

References _bt_array_set_low_or_high(), Assert, fb(), i, IndexScanDescData::indexRelation, IndexScanDescData::opaque, BTArrayKeyInfo::scan_key, ScanDirectionIsForward, and SK_SEARCHARRAY.

Referenced by _bt_advance_array_keys_increment(), _bt_first(), _bt_readpage(), and btrestrpos().

◆ _bt_start_vacuum()

BTCycleId _bt_start_vacuum ( Relation rel )

extern

Definition at line 473 of file nbtutils.c.

{
    BTCycleId   result;
    int         i;
    BTOneVacInfo *vac;
 
    LWLockAcquire(BtreeVacuumLock, LW_EXCLUSIVE);
 
    /*
     * Assign the next cycle ID, being careful to avoid zero as well as the
     * reserved high values.
     */
    result = ++(btvacinfo->cycle_ctr);
    if (result == 0 || result > MAX_BT_CYCLE_ID)
        result = btvacinfo->cycle_ctr = 1;
 
    /* Let's just make sure there's no entry already for this index */
    for (i = 0; i < btvacinfo->num_vacuums; i++)
    {
        vac = &btvacinfo->vacuums[i];
        if (vac->relid.relId == rel->rd_lockInfo.lockRelId.relId &&
            vac->relid.dbId == rel->rd_lockInfo.lockRelId.dbId)
        {
            /*
             * Unlike most places in the backend, we have to explicitly
             * release our LWLock before throwing an error.  This is because
             * we expect _bt_end_vacuum() to be called before transaction
             * abort cleanup can run to release LWLocks.
             */
            LWLockRelease(BtreeVacuumLock);
            elog(ERROR, "multiple active vacuums for index \"%s\"",
                 RelationGetRelationName(rel));
        }
    }
 
    /* OK, add an entry */
    if (btvacinfo->num_vacuums >= btvacinfo->max_vacuums)
    {
        LWLockRelease(BtreeVacuumLock);
        elog(ERROR, "out of btvacinfo slots");
    }
    vac = &btvacinfo->vacuums[btvacinfo->num_vacuums];
    vac->relid = rel->rd_lockInfo.lockRelId;
    vac->cycleid = result;
    btvacinfo->num_vacuums++;
 
    LWLockRelease(BtreeVacuumLock);
    return result;
}

References btvacinfo, BTVacInfo::cycle_ctr, BTOneVacInfo::cycleid, LockRelId::dbId, elog, ERROR, fb(), i, LockInfoData::lockRelId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), MAX_BT_CYCLE_ID, BTVacInfo::max_vacuums, BTVacInfo::num_vacuums, RelationData::rd_lockInfo, RelationGetRelationName, BTOneVacInfo::relid, LockRelId::relId, result, and BTVacInfo::vacuums.

Referenced by btbulkdelete().

◆ _bt_swap_posting()

IndexTuple _bt_swap_posting	(	IndexTuple	newitem,
		IndexTuple	oposting,
		int	postingoff
	)

extern

Definition at line 1022 of file nbtdedup.c.

{
    int         nhtids;
    char       *replacepos;
    char       *replaceposright;
    Size        nmovebytes;
    IndexTuple  nposting;
 
    nhtids = BTreeTupleGetNPosting(oposting);
    Assert(_bt_posting_valid(oposting));
 
    /*
     * The postingoff argument originated as a _bt_binsrch_posting() return
     * value.  It will be 0 in the event of corruption that makes a leaf page
     * contain a non-pivot tuple that's somehow identical to newitem (no two
     * non-pivot tuples should ever have the same TID).  This has been known
     * to happen in the field from time to time.
     *
     * Perform a basic sanity check to catch this case now.
     */
    if (!(postingoff > 0 && postingoff < nhtids))
        elog(ERROR, "posting list tuple with %d items cannot be split at offset %d",
             nhtids, postingoff);
 
    /*
     * Move item pointers in posting list to make a gap for the new item's
     * heap TID.  We shift TIDs one place to the right, losing original
     * rightmost TID. (nmovebytes must not include TIDs to the left of
     * postingoff, nor the existing rightmost/max TID that gets overwritten.)
     */
    nposting = CopyIndexTuple(oposting);
    replacepos = (char *) BTreeTupleGetPostingN(nposting, postingoff);
    replaceposright = (char *) BTreeTupleGetPostingN(nposting, postingoff + 1);
    nmovebytes = (nhtids - postingoff - 1) * sizeof(ItemPointerData);
    memmove(replaceposright, replacepos, nmovebytes);
 
    /* Fill the gap at postingoff with TID of new item (original new TID) */
    Assert(!BTreeTupleIsPivot(newitem) && !BTreeTupleIsPosting(newitem));
    ItemPointerCopy(&newitem->t_tid, (ItemPointer) replacepos);
 
    /* Now copy oposting's rightmost/max TID into new item (final new TID) */
    ItemPointerCopy(BTreeTupleGetMaxHeapTID(oposting), &newitem->t_tid);
 
    Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(nposting),
                              BTreeTupleGetHeapTID(newitem)) < 0);
    Assert(_bt_posting_valid(nposting));
 
    return nposting;
}

References Assert, BTreeTupleGetHeapTID(), BTreeTupleGetMaxHeapTID(), BTreeTupleGetNPosting(), BTreeTupleGetPostingN(), BTreeTupleIsPivot(), BTreeTupleIsPosting(), CopyIndexTuple(), elog, ERROR, fb(), ItemPointerCompare(), ItemPointerCopy(), and IndexTupleData::t_tid.

Referenced by _bt_insertonpg(), btree_xlog_insert(), and btree_xlog_split().

◆ _bt_truncate()

IndexTuple _bt_truncate	(	Relation	rel,
		IndexTuple	lastleft,
		IndexTuple	firstright,
		BTScanInsert	itup_key
	)

extern

Definition at line 692 of file nbtutils.c.

{
    TupleDesc   itupdesc = RelationGetDescr(rel);
    int16       nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
    int         keepnatts;
    IndexTuple  pivot;
    IndexTuple  tidpivot;
    ItemPointer pivotheaptid;
    Size        newsize;
 
    /*
     * We should only ever truncate non-pivot tuples from leaf pages.  It's
     * never okay to truncate when splitting an internal page.
     */
    Assert(!BTreeTupleIsPivot(lastleft) && !BTreeTupleIsPivot(firstright));
 
    /* Determine how many attributes must be kept in truncated tuple */
    keepnatts = _bt_keep_natts(rel, lastleft, firstright, itup_key);
 
#ifdef DEBUG_NO_TRUNCATE
    /* Force truncation to be ineffective for testing purposes */
    keepnatts = nkeyatts + 1;
#endif
 
    pivot = index_truncate_tuple(itupdesc, firstright,
                                 Min(keepnatts, nkeyatts));
 
    if (BTreeTupleIsPosting(pivot))
    {
        /*
         * index_truncate_tuple() just returns a straight copy of firstright
         * when it has no attributes to truncate.  When that happens, we may
         * need to truncate away a posting list here instead.
         */
        Assert(keepnatts == nkeyatts || keepnatts == nkeyatts + 1);
        Assert(IndexRelationGetNumberOfAttributes(rel) == nkeyatts);
        pivot->t_info &= ~INDEX_SIZE_MASK;
        pivot->t_info |= MAXALIGN(BTreeTupleGetPostingOffset(firstright));
    }
 
    /*
     * If there is a distinguishing key attribute within pivot tuple, we're
     * done
     */
    if (keepnatts <= nkeyatts)
    {
        BTreeTupleSetNAtts(pivot, keepnatts, false);
        return pivot;
    }
 
    /*
     * We have to store a heap TID in the new pivot tuple, since no non-TID
     * key attribute value in firstright distinguishes the right side of the
     * split from the left side.  nbtree conceptualizes this case as an
     * inability to truncate away any key attributes, since heap TID is
     * treated as just another key attribute (despite lacking a pg_attribute
     * entry).
     *
     * Use enlarged space that holds a copy of pivot.  We need the extra space
     * to store a heap TID at the end (using the special pivot tuple
     * representation).  Note that the original pivot already has firstright's
     * possible posting list/non-key attribute values removed at this point.
     */
    newsize = MAXALIGN(IndexTupleSize(pivot)) + MAXALIGN(sizeof(ItemPointerData));
    tidpivot = palloc0(newsize);
    memcpy(tidpivot, pivot, MAXALIGN(IndexTupleSize(pivot)));
    /* Cannot leak memory here */
    pfree(pivot);
 
    /*
     * Store all of firstright's key attribute values plus a tiebreaker heap
     * TID value in enlarged pivot tuple
     */
    tidpivot->t_info &= ~INDEX_SIZE_MASK;
    tidpivot->t_info |= newsize;
    BTreeTupleSetNAtts(tidpivot, nkeyatts, true);
    pivotheaptid = BTreeTupleGetHeapTID(tidpivot);
 
    /*
     * Lehman & Yao use lastleft as the leaf high key in all cases, but don't
     * consider suffix truncation.  It seems like a good idea to follow that
     * example in cases where no truncation takes place -- use lastleft's heap
     * TID.  (This is also the closest value to negative infinity that's
     * legally usable.)
     */
    ItemPointerCopy(BTreeTupleGetMaxHeapTID(lastleft), pivotheaptid);
 
    /*
     * We're done.  Assert() that heap TID invariants hold before returning.
     *
     * Lehman and Yao require that the downlink to the right page, which is to
     * be inserted into the parent page in the second phase of a page split be
     * a strict lower bound on items on the right page, and a non-strict upper
     * bound for items on the left page.  Assert that heap TIDs follow these
     * invariants, since a heap TID value is apparently needed as a
     * tiebreaker.
     */
#ifndef DEBUG_NO_TRUNCATE
    Assert(ItemPointerCompare(BTreeTupleGetMaxHeapTID(lastleft),
                              BTreeTupleGetHeapTID(firstright)) < 0);
    Assert(ItemPointerCompare(pivotheaptid,
                              BTreeTupleGetHeapTID(lastleft)) >= 0);
    Assert(ItemPointerCompare(pivotheaptid,
                              BTreeTupleGetHeapTID(firstright)) < 0);
#else
 
    /*
     * Those invariants aren't guaranteed to hold for lastleft + firstright
     * heap TID attribute values when they're considered here only because
     * DEBUG_NO_TRUNCATE is defined (a heap TID is probably not actually
     * needed as a tiebreaker).  DEBUG_NO_TRUNCATE must therefore use a heap
     * TID value that always works as a strict lower bound for items to the
     * right.  In particular, it must avoid using firstright's leading key
     * attribute values along with lastleft's heap TID value when lastleft's
     * TID happens to be greater than firstright's TID.
     */
    ItemPointerCopy(BTreeTupleGetHeapTID(firstright), pivotheaptid);
 
    /*
     * Pivot heap TID should never be fully equal to firstright.  Note that
     * the pivot heap TID will still end up equal to lastleft's heap TID when
     * that's the only usable value.
     */
    ItemPointerSetOffsetNumber(pivotheaptid,
                               OffsetNumberPrev(ItemPointerGetOffsetNumber(pivotheaptid)));
    Assert(ItemPointerCompare(pivotheaptid,
                              BTreeTupleGetHeapTID(firstright)) < 0);
#endif
 
    return tidpivot;
}

References _bt_keep_natts(), Assert, BTreeTupleGetHeapTID(), BTreeTupleGetMaxHeapTID(), BTreeTupleGetPostingOffset(), BTreeTupleIsPivot(), BTreeTupleIsPosting(), BTreeTupleSetNAtts(), fb(), index_truncate_tuple(), IndexRelationGetNumberOfAttributes, IndexRelationGetNumberOfKeyAttributes, IndexTupleSize(), ItemPointerCompare(), ItemPointerCopy(), ItemPointerGetOffsetNumber(), ItemPointerSetOffsetNumber(), MAXALIGN, memcpy(), Min, OffsetNumberPrev, palloc0(), pfree(), and RelationGetDescr.

Referenced by _bt_buildadd(), and _bt_split().

◆ _bt_unlockbuf()

void _bt_unlockbuf	(	Relation	rel,
		Buffer	buf
	)

extern

Definition at line 1098 of file nbtpage.c.

{
    /*
     * Buffer is pinned and locked, which means that it is expected to be
     * defined and addressable.  Check that proactively.
     */
    VALGRIND_CHECK_MEM_IS_DEFINED(BufferGetPage(buf), BLCKSZ);
 
    /* LockBuffer() asserts that pin is held by this backend */
    LockBuffer(buf, BUFFER_LOCK_UNLOCK);
 
    if (!RelationUsesLocalBuffers(rel))
        VALGRIND_MAKE_MEM_NOACCESS(BufferGetPage(buf), BLCKSZ);
}

References buf, BUFFER_LOCK_UNLOCK, BufferGetPage(), fb(), LockBuffer(), RelationUsesLocalBuffers, VALGRIND_CHECK_MEM_IS_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by _bt_drop_lock_and_maybe_pin(), _bt_getroot(), _bt_killitems(), _bt_moveright(), _bt_pagedel(), _bt_readfirstpage(), _bt_relandgetbuf(), _bt_search(), _bt_set_cleanup_info(), and _bt_unlink_halfdead_page().

◆ _bt_update_posting()

void _bt_update_posting ( BTVacuumPosting vacposting )

extern

Definition at line 924 of file nbtdedup.c.

{
    IndexTuple  origtuple = vacposting->itup;
    uint32      keysize,
                newsize;
    IndexTuple  itup;
    int         nhtids;
    int         ui,
                d;
    ItemPointer htids;
 
    nhtids = BTreeTupleGetNPosting(origtuple) - vacposting->ndeletedtids;
 
    Assert(_bt_posting_valid(origtuple));
    Assert(nhtids > 0 && nhtids < BTreeTupleGetNPosting(origtuple));
 
    /*
     * Determine final size of new tuple.
     *
     * This calculation needs to match the code used within _bt_form_posting()
     * for new posting list tuples.  We avoid calling _bt_form_posting() here
     * to save ourselves a second memory allocation for a htids workspace.
     */
    keysize = BTreeTupleGetPostingOffset(origtuple);
    if (nhtids > 1)
        newsize = MAXALIGN(keysize +
                           nhtids * sizeof(ItemPointerData));
    else
        newsize = keysize;
 
    Assert(newsize <= INDEX_SIZE_MASK);
    Assert(newsize == MAXALIGN(newsize));
 
    /* Allocate memory using palloc0() (matches index_form_tuple()) */
    itup = palloc0(newsize);
    memcpy(itup, origtuple, keysize);
    itup->t_info &= ~INDEX_SIZE_MASK;
    itup->t_info |= newsize;
 
    if (nhtids > 1)
    {
        /* Form posting list tuple */
        BTreeTupleSetPosting(itup, nhtids, keysize);
        htids = BTreeTupleGetPosting(itup);
    }
    else
    {
        /* Form standard non-pivot tuple */
        itup->t_info &= ~INDEX_ALT_TID_MASK;
        htids = &itup->t_tid;
    }
 
    ui = 0;
    d = 0;
    for (int i = 0; i < BTreeTupleGetNPosting(origtuple); i++)
    {
        if (d < vacposting->ndeletedtids && vacposting->deletetids[d] == i)
        {
            d++;
            continue;
        }
        htids[ui++] = *BTreeTupleGetPostingN(origtuple, i);
    }
    Assert(ui == nhtids);
    Assert(d == vacposting->ndeletedtids);
    Assert(nhtids == 1 || _bt_posting_valid(itup));
    Assert(nhtids > 1 || ItemPointerIsValid(&itup->t_tid));
 
    /* vacposting arg's itup will now point to updated version */
    vacposting->itup = itup;
}

References Assert, BTreeTupleGetNPosting(), BTreeTupleGetPosting(), BTreeTupleGetPostingN(), BTreeTupleGetPostingOffset(), BTreeTupleSetPosting(), fb(), i, INDEX_SIZE_MASK, ItemPointerIsValid(), MAXALIGN, memcpy(), palloc0(), IndexTupleData::t_info, and IndexTupleData::t_tid.

Referenced by _bt_delitems_update(), and btree_xlog_updates().

◆ _bt_upgradelockbufcleanup()

void _bt_upgradelockbufcleanup	(	Relation	rel,
		Buffer	buf
	)

extern

Definition at line 1137 of file nbtpage.c.

{
    /*
     * Buffer is pinned and locked, which means that it is expected to be
     * defined and addressable.  Check that proactively.
     */
    VALGRIND_CHECK_MEM_IS_DEFINED(BufferGetPage(buf), BLCKSZ);
 
    /* LockBuffer() asserts that pin is held by this backend */
    LockBuffer(buf, BUFFER_LOCK_UNLOCK);
    LockBufferForCleanup(buf);
}

References buf, BUFFER_LOCK_UNLOCK, BufferGetPage(), fb(), LockBuffer(), LockBufferForCleanup(), and VALGRIND_CHECK_MEM_IS_DEFINED.

Referenced by btvacuumpage().

◆ _bt_upgrademetapage()

void _bt_upgrademetapage ( Page page )

extern

Definition at line 108 of file nbtpage.c.

{
    BTMetaPageData *metad;
    BTPageOpaque metaopaque PG_USED_FOR_ASSERTS_ONLY;
 
    metad = BTPageGetMeta(page);
    metaopaque = BTPageGetOpaque(page);
 
    /* It must be really a meta page of upgradable version */
    Assert(metaopaque->btpo_flags & BTP_META);
    Assert(metad->btm_version < BTREE_NOVAC_VERSION);
    Assert(metad->btm_version >= BTREE_MIN_VERSION);
 
    /* Set version number and fill extra fields added into version 3 */
    metad->btm_version = BTREE_NOVAC_VERSION;
    metad->btm_last_cleanup_num_delpages = 0;
    metad->btm_last_cleanup_num_heap_tuples = -1.0;
    /* Only a REINDEX can set this field */
    Assert(!metad->btm_allequalimage);
    metad->btm_allequalimage = false;
 
    /* Adjust pd_lower (see _bt_initmetapage() for details) */
    ((PageHeader) page)->pd_lower =
        ((char *) metad + sizeof(BTMetaPageData)) - (char *) page;
}

References Assert, BTP_META, BTPageGetMeta, BTPageGetOpaque, BTREE_MIN_VERSION, BTREE_NOVAC_VERSION, fb(), and PG_USED_FOR_ASSERTS_ONLY.

Referenced by _bt_getroot(), _bt_insertonpg(), _bt_newlevel(), _bt_set_cleanup_info(), and _bt_unlink_halfdead_page().

◆ _bt_vacuum_cycleid()

BTCycleId _bt_vacuum_cycleid ( Relation rel )

extern

Definition at line 439 of file nbtutils.c.

{
    BTCycleId   result = 0;
    int         i;
 
    /* Share lock is enough since this is a read-only operation */
    LWLockAcquire(BtreeVacuumLock, LW_SHARED);
 
    for (i = 0; i < btvacinfo->num_vacuums; i++)
    {
        BTOneVacInfo *vac = &btvacinfo->vacuums[i];
 
        if (vac->relid.relId == rel->rd_lockInfo.lockRelId.relId &&
            vac->relid.dbId == rel->rd_lockInfo.lockRelId.dbId)
        {
            result = vac->cycleid;
            break;
        }
    }
 
    LWLockRelease(BtreeVacuumLock);
    return result;
}

References btvacinfo, BTOneVacInfo::cycleid, LockRelId::dbId, fb(), i, LockInfoData::lockRelId, LW_SHARED, LWLockAcquire(), LWLockRelease(), BTVacInfo::num_vacuums, RelationData::rd_lockInfo, BTOneVacInfo::relid, LockRelId::relId, result, and BTVacInfo::vacuums.

Referenced by _bt_split().

◆ _bt_vacuum_needs_cleanup()

bool _bt_vacuum_needs_cleanup ( Relation rel )

extern

Definition at line 180 of file nbtpage.c.

{
    Buffer      metabuf;
    Page        metapg;
    BTMetaPageData *metad;
    uint32      btm_version;
    BlockNumber prev_num_delpages;
 
    /*
     * Copy details from metapage to local variables quickly.
     *
     * Note that we deliberately avoid using cached version of metapage here.
     */
    metabuf = _bt_getbuf(rel, BTREE_METAPAGE, BT_READ);
    metapg = BufferGetPage(metabuf);
    metad = BTPageGetMeta(metapg);
    btm_version = metad->btm_version;
 
    if (btm_version < BTREE_NOVAC_VERSION)
    {
        /*
         * Metapage needs to be dynamically upgraded to store fields that are
         * only present when btm_version >= BTREE_NOVAC_VERSION
         */
        _bt_relbuf(rel, metabuf);
        return true;
    }
 
    prev_num_delpages = metad->btm_last_cleanup_num_delpages;
    _bt_relbuf(rel, metabuf);
 
    /*
     * Trigger cleanup in rare cases where prev_num_delpages exceeds 5% of the
     * total size of the index.  We can reasonably expect (though are not
     * guaranteed) to be able to recycle this many pages if we decide to do a
     * btvacuumscan call during the ongoing btvacuumcleanup.  For further
     * details see the nbtree/README section on placing deleted pages in the
     * FSM.
     */
    if (prev_num_delpages > 0 &&
        prev_num_delpages > RelationGetNumberOfBlocks(rel) / 20)
        return true;
 
    return false;
}

References _bt_getbuf(), _bt_relbuf(), BT_READ, BTPageGetMeta, BTREE_METAPAGE, BTREE_NOVAC_VERSION, BufferGetPage(), fb(), and RelationGetNumberOfBlocks.

Referenced by btvacuumcleanup().

◆ btadjustmembers()

void btadjustmembers	(	Oid	opfamilyoid,
		Oid	opclassoid,
		List *	operators,
		List *	functions
	)

extern

Definition at line 288 of file nbtvalidate.c.

{
    Oid         opcintype;
    ListCell   *lc;
 
    /*
     * Btree operators and comparison support functions are always "loose"
     * members of the opfamily if they are cross-type.  If they are not
     * cross-type, we prefer to tie them to the appropriate opclass ... but if
     * the user hasn't created one, we can't do that, and must fall back to
     * using the opfamily dependency.  (We mustn't force creation of an
     * opclass in such a case, as leaving an incomplete opclass laying about
     * would be bad.  Throwing an error is another undesirable alternative.)
     *
     * This behavior results in a bit of a dump/reload hazard, in that the
     * order of restoring objects could affect what dependencies we end up
     * with.  pg_dump's existing behavior will preserve the dependency choices
     * in most cases, but not if a cross-type operator has been bound tightly
     * into an opclass.  That's a mistake anyway, so silently "fixing" it
     * isn't awful.
     *
     * Optional support functions are always "loose" family members.
     *
     * To avoid repeated lookups, we remember the most recently used opclass's
     * input type.
     */
    if (OidIsValid(opclassoid))
    {
        /* During CREATE OPERATOR CLASS, need CCI to see the pg_opclass row */
        CommandCounterIncrement();
        opcintype = get_opclass_input_type(opclassoid);
    }
    else
        opcintype = InvalidOid;
 
    /*
     * We handle operators and support functions almost identically, so rather
     * than duplicate this code block, just join the lists.
     */
    foreach(lc, list_concat_copy(operators, functions))
    {
        OpFamilyMember *op = (OpFamilyMember *) lfirst(lc);
 
        if (op->is_func && op->number != BTORDER_PROC)
        {
            /* Optional support proc, so always a soft family dependency */
            op->ref_is_hard = false;
            op->ref_is_family = true;
            op->refobjid = opfamilyoid;
        }
        else if (op->lefttype != op->righttype)
        {
            /* Cross-type, so always a soft family dependency */
            op->ref_is_hard = false;
            op->ref_is_family = true;
            op->refobjid = opfamilyoid;
        }
        else
        {
            /* Not cross-type; is there a suitable opclass? */
            if (op->lefttype != opcintype)
            {
                /* Avoid repeating this expensive lookup, even if it fails */
                opcintype = op->lefttype;
                opclassoid = opclass_for_family_datatype(BTREE_AM_OID,
                                                         opfamilyoid,
                                                         opcintype);
            }
            if (OidIsValid(opclassoid))
            {
                /* Hard dependency on opclass */
                op->ref_is_hard = true;
                op->ref_is_family = false;
                op->refobjid = opclassoid;
            }
            else
            {
                /* We're stuck, so make a soft dependency on the opfamily */
                op->ref_is_hard = false;
                op->ref_is_family = true;
                op->refobjid = opfamilyoid;
            }
        }
    }
}

References BTORDER_PROC, CommandCounterIncrement(), fb(), functions, get_opclass_input_type(), InvalidOid, OpFamilyMember::is_func, OpFamilyMember::lefttype, lfirst, list_concat_copy(), OpFamilyMember::number, OidIsValid, opclass_for_family_datatype(), OpFamilyMember::ref_is_family, OpFamilyMember::ref_is_hard, OpFamilyMember::refobjid, and OpFamilyMember::righttype.

Referenced by bthandler().

◆ btbeginscan()

IndexScanDesc btbeginscan	(	Relation	rel,
		int	nkeys,
		int	norderbys
	)

extern

Definition at line 339 of file nbtree.c.

{
    IndexScanDesc scan;
    BTScanOpaque so;
 
    /* no order by operators allowed */
    Assert(norderbys == 0);
 
    /* get the scan */
    scan = RelationGetIndexScan(rel, nkeys, norderbys);
 
    /* allocate private workspace */
    so = palloc_object(BTScanOpaqueData);
    BTScanPosInvalidate(so->currPos);
    BTScanPosInvalidate(so->markPos);
    if (scan->numberOfKeys > 0)
        so->keyData = (ScanKey) palloc(scan->numberOfKeys * sizeof(ScanKeyData));
    else
        so->keyData = NULL;
 
    so->skipScan = false;
    so->needPrimScan = false;
    so->scanBehind = false;
    so->oppositeDirCheck = false;
    so->arrayKeys = NULL;
    so->orderProcs = NULL;
    so->arrayContext = NULL;
 
    so->killedItems = NULL;     /* until needed */
    so->numKilled = 0;
 
    /*
     * We don't know yet whether the scan will be index-only, so we do not
     * allocate the tuple workspace arrays until btrescan.  However, we set up
     * scan->xs_itupdesc whether we'll need it or not, since that's so cheap.
     */
    so->currTuples = so->markTuples = NULL;
 
    scan->xs_itupdesc = RelationGetDescr(rel);
 
    scan->opaque = so;
 
    return scan;
}

References Assert, BTScanPosInvalidate, fb(), IndexScanDescData::numberOfKeys, IndexScanDescData::opaque, palloc(), palloc_object, RelationGetDescr, RelationGetIndexScan(), and IndexScanDescData::xs_itupdesc.

Referenced by bthandler().

◆ btbuild()

IndexBuildResult * btbuild	(	Relation	heap,
		Relation	index,
		struct IndexInfo *	indexInfo
	)

extern

Definition at line 299 of file nbtsort.c.

{
    IndexBuildResult *result;
    BTBuildState buildstate;
    double      reltuples;
 
#ifdef BTREE_BUILD_STATS
    if (log_btree_build_stats)
        ResetUsage();
#endif                          /* BTREE_BUILD_STATS */
 
    buildstate.isunique = indexInfo->ii_Unique;
    buildstate.nulls_not_distinct = indexInfo->ii_NullsNotDistinct;
    buildstate.havedead = false;
    buildstate.heap = heap;
    buildstate.spool = NULL;
    buildstate.spool2 = NULL;
    buildstate.indtuples = 0;
    buildstate.btleader = NULL;
 
    /*
     * We expect to be called exactly once for any index relation. If that's
     * not the case, big trouble's what we have.
     */
    if (RelationGetNumberOfBlocks(index) != 0)
        elog(ERROR, "index \"%s\" already contains data",
             RelationGetRelationName(index));
 
    reltuples = _bt_spools_heapscan(heap, index, &buildstate, indexInfo);
 
    /*
     * Finish the build by (1) completing the sort of the spool file, (2)
     * inserting the sorted tuples into btree pages and (3) building the upper
     * levels.  Finally, it may also be necessary to end use of parallelism.
     */
    _bt_leafbuild(buildstate.spool, buildstate.spool2);
    _bt_spooldestroy(buildstate.spool);
    if (buildstate.spool2)
        _bt_spooldestroy(buildstate.spool2);
    if (buildstate.btleader)
        _bt_end_parallel(buildstate.btleader);
 
    result = palloc_object(IndexBuildResult);
 
    result->heap_tuples = reltuples;
    result->index_tuples = buildstate.indtuples;
 
#ifdef BTREE_BUILD_STATS
    if (log_btree_build_stats)
    {
        ShowUsage("BTREE BUILD STATS");
        ResetUsage();
    }
#endif                          /* BTREE_BUILD_STATS */
 
    return result;
}

References _bt_end_parallel(), _bt_leafbuild(), _bt_spooldestroy(), _bt_spools_heapscan(), elog, ERROR, fb(), IndexInfo::ii_NullsNotDistinct, IndexInfo::ii_Unique, log_btree_build_stats, palloc_object, RelationGetNumberOfBlocks, RelationGetRelationName, ResetUsage(), result, and ShowUsage().

Referenced by bthandler().

◆ btbuildempty()

void btbuildempty ( Relation index )

extern

Definition at line 183 of file nbtree.c.

{
    bool        allequalimage = _bt_allequalimage(index, false);
    BulkWriteState *bulkstate;
    BulkWriteBuffer metabuf;
 
    bulkstate = smgr_bulk_start_rel(index, INIT_FORKNUM);
 
    /* Construct metapage. */
    metabuf = smgr_bulk_get_buf(bulkstate);
    _bt_initmetapage((Page) metabuf, P_NONE, 0, allequalimage);
    smgr_bulk_write(bulkstate, BTREE_METAPAGE, metabuf, true);
 
    smgr_bulk_finish(bulkstate);
}

References _bt_allequalimage(), _bt_initmetapage(), BTREE_METAPAGE, fb(), INIT_FORKNUM, P_NONE, smgr_bulk_finish(), smgr_bulk_get_buf(), smgr_bulk_start_rel(), and smgr_bulk_write().

Referenced by bthandler().

◆ btbuildphasename()

char * btbuildphasename ( int64 phasenum )

extern

Definition at line 644 of file nbtutils.c.

{
    switch (phasenum)
    {
        case PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE:
            return "initializing";
        case PROGRESS_BTREE_PHASE_INDEXBUILD_TABLESCAN:
            return "scanning table";
        case PROGRESS_BTREE_PHASE_PERFORMSORT_1:
            return "sorting live tuples";
        case PROGRESS_BTREE_PHASE_PERFORMSORT_2:
            return "sorting dead tuples";
        case PROGRESS_BTREE_PHASE_LEAF_LOAD:
            return "loading tuples in tree";
        default:
            return NULL;
    }
}

References fb(), PROGRESS_BTREE_PHASE_INDEXBUILD_TABLESCAN, PROGRESS_BTREE_PHASE_LEAF_LOAD, PROGRESS_BTREE_PHASE_PERFORMSORT_1, PROGRESS_BTREE_PHASE_PERFORMSORT_2, and PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE.

Referenced by bthandler().

◆ btbulkdelete()

IndexBulkDeleteResult * btbulkdelete	(	IndexVacuumInfo *	info,
		IndexBulkDeleteResult *	stats,
		IndexBulkDeleteCallback	callback,
		void *	callback_state
	)

extern

Definition at line 1119 of file nbtree.c.

{
    Relation    rel = info->index;
    BTCycleId   cycleid;
 
    /* allocate stats if first time through, else re-use existing struct */
    if (stats == NULL)
        stats = palloc0_object(IndexBulkDeleteResult);
 
    /* Establish the vacuum cycle ID to use for this scan */
    /* The ENSURE stuff ensures we clean up shared memory on failure */
    PG_ENSURE_ERROR_CLEANUP(_bt_end_vacuum_callback, PointerGetDatum(rel));
    {
        cycleid = _bt_start_vacuum(rel);
 
        btvacuumscan(info, stats, callback, callback_state, cycleid);
    }
    PG_END_ENSURE_ERROR_CLEANUP(_bt_end_vacuum_callback, PointerGetDatum(rel));
    _bt_end_vacuum(rel);
 
    return stats;
}

References _bt_end_vacuum(), _bt_end_vacuum_callback(), _bt_start_vacuum(), btvacuumscan(), callback(), fb(), IndexVacuumInfo::index, palloc0_object, PG_END_ENSURE_ERROR_CLEANUP, PG_ENSURE_ERROR_CLEANUP, and PointerGetDatum().

Referenced by bthandler().

◆ btcanreturn()

bool btcanreturn	(	Relation	index,
		int	attno
	)

extern

Definition at line 1799 of file nbtree.c.

{
    return true;
}

Referenced by bthandler().

◆ btendscan()

void btendscan ( IndexScanDesc scan )

extern

Definition at line 455 of file nbtree.c.

{
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
 
    /* we aren't holding any read locks, but gotta drop the pins */
    if (BTScanPosIsValid(so->currPos))
    {
        /* Before leaving current page, deal with any killed items */
        if (so->numKilled > 0)
            _bt_killitems(scan);
        BTScanPosUnpinIfPinned(so->currPos);
    }
 
    so->markItemIndex = -1;
    BTScanPosUnpinIfPinned(so->markPos);
 
    /* No need to invalidate positions, the RAM is about to be freed. */
 
    /* Release storage */
    if (so->keyData != NULL)
        pfree(so->keyData);
    /* so->arrayKeys and so->orderProcs are in arrayContext */
    if (so->arrayContext != NULL)
        MemoryContextDelete(so->arrayContext);
    if (so->killedItems != NULL)
        pfree(so->killedItems);
    if (so->currTuples != NULL)
        pfree(so->currTuples);
    /* so->markTuples should not be pfree'd, see btrescan */
    pfree(so);
}

References _bt_killitems(), BTScanPosIsValid, BTScanPosUnpinIfPinned, fb(), MemoryContextDelete(), IndexScanDescData::opaque, and pfree().

Referenced by bthandler().

◆ btestimateparallelscan()

Size btestimateparallelscan	(	Relation	rel,
		int	nkeys,
		int	norderbys
	)

extern

Definition at line 575 of file nbtree.c.

{
    int16       nkeyatts = IndexRelationGetNumberOfKeyAttributes(rel);
    Size        estnbtreeshared,
                genericattrspace;
 
    /*
     * Pessimistically assume that every input scan key will be output with
     * its own SAOP array
     */
    estnbtreeshared = offsetof(BTParallelScanDescData, btps_arrElems) +
        sizeof(int) * nkeys;
 
    /* Single column indexes cannot possibly use a skip array */
    if (nkeyatts == 1)
        return estnbtreeshared;
 
    /*
     * Pessimistically assume that all attributes prior to the least
     * significant attribute require a skip array (and an associated key)
     */
    genericattrspace = datumEstimateSpace((Datum) 0, false, true,
                                          sizeof(Datum));
    for (int attnum = 1; attnum < nkeyatts; attnum++)
    {
        CompactAttribute *attr;
 
        /*
         * We make the conservative assumption that every index column will
         * also require a skip array.
         *
         * Every skip array must have space to store its scan key's sk_flags.
         */
        estnbtreeshared = add_size(estnbtreeshared, sizeof(int));
 
        /* Consider space required to store a datum of opclass input type */
        attr = TupleDescCompactAttr(rel->rd_att, attnum - 1);
        if (attr->attbyval)
        {
            /* This index attribute stores pass-by-value datums */
            Size        estfixed = datumEstimateSpace((Datum) 0, false,
                                                      true, attr->attlen);
 
            estnbtreeshared = add_size(estnbtreeshared, estfixed);
            continue;
        }
 
        /*
         * This index attribute stores pass-by-reference datums.
         *
         * Assume that serializing this array will use just as much space as a
         * pass-by-value datum, in addition to space for the largest possible
         * whole index tuple (this is not just a per-datum portion of the
         * largest possible tuple because that'd be almost as large anyway).
         *
         * This is quite conservative, but it's not clear how we could do much
         * better.  The executor requires an up-front storage request size
         * that reliably covers the scan's high watermark memory usage.  We
         * can't be sure of the real high watermark until the scan is over.
         */
        estnbtreeshared = add_size(estnbtreeshared, genericattrspace);
        estnbtreeshared = add_size(estnbtreeshared, BTMaxItemSize);
    }
 
    return estnbtreeshared;
}

References add_size(), CompactAttribute::attbyval, CompactAttribute::attlen, attnum, BTMaxItemSize, BTParallelScanDescData::btps_arrElems, datumEstimateSpace(), fb(), IndexRelationGetNumberOfKeyAttributes, RelationData::rd_att, and TupleDescCompactAttr().

Referenced by bthandler().

◆ btgetbitmap()

int64 btgetbitmap	(	IndexScanDesc	scan,
		TIDBitmap *	tbm
	)

extern

Definition at line 291 of file nbtree.c.

{
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
    int64       ntids = 0;
    ItemPointer heapTid;
 
    Assert(scan->heapRelation == NULL);
 
    /* Each loop iteration performs another primitive index scan */
    do
    {
        /* Fetch the first page & tuple */
        if (_bt_first(scan, ForwardScanDirection))
        {
            /* Save tuple ID, and continue scanning */
            heapTid = &scan->xs_heaptid;
            tbm_add_tuples(tbm, heapTid, 1, false);
            ntids++;
 
            for (;;)
            {
                /*
                 * Advance to next tuple within page.  This is the same as the
                 * easy case in _bt_next().
                 */
                if (++so->currPos.itemIndex > so->currPos.lastItem)
                {
                    /* let _bt_next do the heavy lifting */
                    if (!_bt_next(scan, ForwardScanDirection))
                        break;
                }
 
                /* Save tuple ID, and continue scanning */
                heapTid = &so->currPos.items[so->currPos.itemIndex].heapTid;
                tbm_add_tuples(tbm, heapTid, 1, false);
                ntids++;
            }
        }
        /* Now see if we need another primitive index scan */
    } while (so->numArrayKeys && _bt_start_prim_scan(scan));
 
    return ntids;
}

References _bt_first(), _bt_next(), _bt_start_prim_scan(), Assert, fb(), ForwardScanDirection, IndexScanDescData::heapRelation, IndexScanDescData::opaque, tbm_add_tuples(), and IndexScanDescData::xs_heaptid.

Referenced by bthandler().

◆ btgettreeheight()

int btgettreeheight ( Relation rel )

extern

Definition at line 1808 of file nbtree.c.

{
    return _bt_getrootheight(rel);
}

References _bt_getrootheight().

Referenced by bthandler().

◆ btgettuple()

bool btgettuple	(	IndexScanDesc	scan,
		ScanDirection	dir
	)

extern

Definition at line 230 of file nbtree.c.

{
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
    bool        res;
 
    Assert(scan->heapRelation != NULL);
 
    /* btree indexes are never lossy */
    scan->xs_recheck = false;
 
    /* Each loop iteration performs another primitive index scan */
    do
    {
        /*
         * If we've already initialized this scan, we can just advance it in
         * the appropriate direction.  If we haven't done so yet, we call
         * _bt_first() to get the first item in the scan.
         */
        if (!BTScanPosIsValid(so->currPos))
            res = _bt_first(scan, dir);
        else
        {
            /*
             * Check to see if we should kill the previously-fetched tuple.
             */
            if (scan->kill_prior_tuple)
            {
                /*
                 * Yes, remember it for later. (We'll deal with all such
                 * tuples at once right before leaving the index page.)  The
                 * test for numKilled overrun is not just paranoia: if the
                 * caller reverses direction in the indexscan then the same
                 * item might get entered multiple times. It's not worth
                 * trying to optimize that, so we don't detect it, but instead
                 * just forget any excess entries.
                 */
                if (so->killedItems == NULL)
                    so->killedItems = palloc_array(int, MaxTIDsPerBTreePage);
                if (so->numKilled < MaxTIDsPerBTreePage)
                    so->killedItems[so->numKilled++] = so->currPos.itemIndex;
            }
 
            /*
             * Now continue the scan.
             */
            res = _bt_next(scan, dir);
        }
 
        /* If we have a tuple, return it ... */
        if (res)
            break;
        /* ... otherwise see if we need another primitive index scan */
    } while (so->numArrayKeys && _bt_start_prim_scan(scan));
 
    return res;
}

References _bt_first(), _bt_next(), _bt_start_prim_scan(), Assert, BTScanPosIsValid, fb(), IndexScanDescData::heapRelation, IndexScanDescData::kill_prior_tuple, MaxTIDsPerBTreePage, IndexScanDescData::opaque, palloc_array, and IndexScanDescData::xs_recheck.

Referenced by bthandler().

◆ btinitparallelscan()

void btinitparallelscan ( void * target )

extern

Definition at line 811 of file nbtree.c.

{
    BTParallelScanDesc bt_target = (BTParallelScanDesc) target;
 
    LWLockInitialize(&bt_target->btps_lock,
                     LWTRANCHE_PARALLEL_BTREE_SCAN);
    bt_target->btps_nextScanPage = InvalidBlockNumber;
    bt_target->btps_lastCurrPage = InvalidBlockNumber;
    bt_target->btps_pageStatus = BTPARALLEL_NOT_INITIALIZED;
    ConditionVariableInit(&bt_target->btps_cv);
}

References BTPARALLEL_NOT_INITIALIZED, ConditionVariableInit(), fb(), InvalidBlockNumber, and LWLockInitialize().

Referenced by bthandler().

◆ btinsert()

bool btinsert	(	Relation	rel,
		Datum *	values,
		bool *	isnull,
		ItemPointer	ht_ctid,
		Relation	heapRel,
		IndexUniqueCheck	checkUnique,
		bool	indexUnchanged,
		struct IndexInfo *	indexInfo
	)

extern

Definition at line 206 of file nbtree.c.

{
    bool        result;
    IndexTuple  itup;
 
    /* generate an index tuple */
    itup = index_form_tuple(RelationGetDescr(rel), values, isnull);
    itup->t_tid = *ht_ctid;
 
    result = _bt_doinsert(rel, itup, checkUnique, indexUnchanged, heapRel);
 
    pfree(itup);
 
    return result;
}

References _bt_doinsert(), fb(), index_form_tuple(), pfree(), RelationGetDescr, result, IndexTupleData::t_tid, and values.

Referenced by bthandler().

◆ btmarkpos()

void btmarkpos ( IndexScanDesc scan )

extern

Definition at line 491 of file nbtree.c.

{
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
 
    /* There may be an old mark with a pin (but no lock). */
    BTScanPosUnpinIfPinned(so->markPos);
 
    /*
     * Just record the current itemIndex.  If we later step to next page
     * before releasing the marked position, _bt_steppage makes a full copy of
     * the currPos struct in markPos.  If (as often happens) the mark is moved
     * before we leave the page, we don't have to do that work.
     */
    if (BTScanPosIsValid(so->currPos))
        so->markItemIndex = so->currPos.itemIndex;
    else
    {
        BTScanPosInvalidate(so->markPos);
        so->markItemIndex = -1;
    }
}

References BTScanPosInvalidate, BTScanPosIsValid, BTScanPosUnpinIfPinned, fb(), and IndexScanDescData::opaque.

Referenced by bthandler().

◆ btoptions()

bytea * btoptions	(	Datum	reloptions,
		bool	validate
	)

extern

Definition at line 598 of file nbtutils.c.

{
    static const relopt_parse_elt tab[] = {
        {"fillfactor", RELOPT_TYPE_INT, offsetof(BTOptions, fillfactor)},
        {"vacuum_cleanup_index_scale_factor", RELOPT_TYPE_REAL,
        offsetof(BTOptions, vacuum_cleanup_index_scale_factor)},
        {"deduplicate_items", RELOPT_TYPE_BOOL,
        offsetof(BTOptions, deduplicate_items)}
    };
 
    return (bytea *) build_reloptions(reloptions, validate,
                                      RELOPT_KIND_BTREE,
                                      sizeof(BTOptions),
                                      tab, lengthof(tab));
}

References build_reloptions(), fb(), fillfactor, lengthof, RELOPT_KIND_BTREE, RELOPT_TYPE_BOOL, RELOPT_TYPE_INT, RELOPT_TYPE_REAL, and validate().

Referenced by bthandler().

◆ BTPageGetDeleteXid()

static FullTransactionId BTPageGetDeleteXid ( Page page )

inlinestatic

Definition at line 261 of file nbtree.h.

{
    BTPageOpaque opaque;
    BTDeletedPageData *contents;
 
    /* We only expect to be called with a deleted page */
    Assert(!PageIsNew(page));
    opaque = BTPageGetOpaque(page);
    Assert(P_ISDELETED(opaque));
 
    /* pg_upgrade'd deleted page -- must be safe to recycle now */
    if (!P_HAS_FULLXID(opaque))
        return FirstNormalFullTransactionId;
 
    /* Get safexid from deleted page */
    contents = ((BTDeletedPageData *) PageGetContents(page));
    return contents->safexid;
}

References Assert, BTPageGetOpaque, FirstNormalFullTransactionId, P_HAS_FULLXID, P_ISDELETED, PageGetContents(), PageIsNew(), and BTDeletedPageData::safexid.

Referenced by _bt_allocbuf(), BTPageIsRecyclable(), and GetBTPageStatistics().

◆ BTPageIsRecyclable()

static bool BTPageIsRecyclable	(	Page	page,
		Relation	heaprel
	)

inlinestatic

Definition at line 292 of file nbtree.h.

{
    BTPageOpaque opaque;
 
    Assert(!PageIsNew(page));
    Assert(heaprel != NULL);
 
    /* Recycling okay iff page is deleted and safexid is old enough */
    opaque = BTPageGetOpaque(page);
    if (P_ISDELETED(opaque))
    {
        FullTransactionId safexid = BTPageGetDeleteXid(page);
 
        /*
         * The page was deleted, but when? If it was just deleted, a scan
         * might have seen the downlink to it, and will read the page later.
         * As long as that can happen, we must keep the deleted page around as
         * a tombstone.
         *
         * For that check if the deletion XID could still be visible to
         * anyone. If not, then no scan that's still in progress could have
         * seen its downlink, and we can recycle it.
         */
        return GlobalVisCheckRemovableFullXid(heaprel, safexid);
    }
 
    return false;
}

References Assert, BTPageGetDeleteXid(), BTPageGetOpaque, fb(), GlobalVisCheckRemovableFullXid(), P_ISDELETED, and PageIsNew().

Referenced by _bt_allocbuf(), and btvacuumpage().

◆ BTPageSetDeleted()

static void BTPageSetDeleted	(	Page	page,
		FullTransactionId	safexid
	)

inlinestatic

Definition at line 240 of file nbtree.h.

{
    BTPageOpaque opaque;
    PageHeader  header;
    BTDeletedPageData *contents;
 
    opaque = BTPageGetOpaque(page);
    header = ((PageHeader) page);
 
    opaque->btpo_flags &= ~BTP_HALF_DEAD;
    opaque->btpo_flags |= BTP_DELETED | BTP_HAS_FULLXID;
    header->pd_lower = MAXALIGN(SizeOfPageHeaderData) +
        sizeof(BTDeletedPageData);
    header->pd_upper = header->pd_special;
 
    /* Set safexid in deleted page */
    contents = ((BTDeletedPageData *) PageGetContents(page));
    contents->safexid = safexid;
}

References BTP_DELETED, BTP_HAS_FULLXID, BTPageGetOpaque, BTPageOpaqueData::btpo_flags, fb(), MAXALIGN, PageGetContents(), PageHeaderData::pd_lower, PageHeaderData::pd_special, PageHeaderData::pd_upper, BTDeletedPageData::safexid, and SizeOfPageHeaderData.

Referenced by _bt_unlink_halfdead_page(), and btree_xlog_unlink_page().

◆ btparallelrescan()

void btparallelrescan ( IndexScanDesc scan )

extern

Definition at line 827 of file nbtree.c.

{
    BTParallelScanDesc btscan;
    ParallelIndexScanDesc parallel_scan = scan->parallel_scan;
 
    Assert(parallel_scan);
 
    btscan = (BTParallelScanDesc) OffsetToPointer(parallel_scan,
                                                  parallel_scan->ps_offset_am);
 
    /*
     * In theory, we don't need to acquire the LWLock here, because there
     * shouldn't be any other workers running at this point, but we do so for
     * consistency.
     */
    LWLockAcquire(&btscan->btps_lock, LW_EXCLUSIVE);
    btscan->btps_nextScanPage = InvalidBlockNumber;
    btscan->btps_lastCurrPage = InvalidBlockNumber;
    btscan->btps_pageStatus = BTPARALLEL_NOT_INITIALIZED;
    LWLockRelease(&btscan->btps_lock);
}

References Assert, BTPARALLEL_NOT_INITIALIZED, fb(), InvalidBlockNumber, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), OffsetToPointer, IndexScanDescData::parallel_scan, and ParallelIndexScanDescData::ps_offset_am.

Referenced by bthandler().

◆ btproperty()

bool btproperty	(	Oid	index_oid,
		int	attno,
		IndexAMProperty	prop,
		const char *	propname,
		bool *	res,
		bool *	isnull
	)

extern

Definition at line 621 of file nbtutils.c.

{
    switch (prop)
    {
        case AMPROP_RETURNABLE:
            /* answer only for columns, not AM or whole index */
            if (attno == 0)
                return false;
            /* otherwise, btree can always return data */
            *res = true;
            return true;
 
        default:
            return false;       /* punt to generic code */
    }
}

References AMPROP_RETURNABLE.

Referenced by bthandler().

◆ BTreeTupleGetDownLink()

static BlockNumber BTreeTupleGetDownLink ( IndexTuple pivot )

inlinestatic

Definition at line 557 of file nbtree.h.

{
    return ItemPointerGetBlockNumberNoCheck(&pivot->t_tid);
}

References fb(), and ItemPointerGetBlockNumberNoCheck().

Referenced by _bt_get_endpoint(), _bt_getstackbuf(), _bt_mark_page_halfdead(), _bt_search(), _bt_unlink_halfdead_page(), bt_check_level_from_leftmost(), bt_child_check(), bt_child_highkey_check(), bt_downlink_missing_check(), and btree_xlog_mark_page_halfdead().

◆ BTreeTupleGetHeapTID()

static ItemPointer BTreeTupleGetHeapTID ( IndexTuple itup )

inlinestatic

Definition at line 639 of file nbtree.h.

{
    if (BTreeTupleIsPivot(itup))
    {
        /* Pivot tuple heap TID representation? */
        if ((ItemPointerGetOffsetNumberNoCheck(&itup->t_tid) &
             BT_PIVOT_HEAP_TID_ATTR) != 0)
            return (ItemPointer) ((char *) itup + IndexTupleSize(itup) -
                                  sizeof(ItemPointerData));
 
        /* Heap TID attribute was truncated */
        return NULL;
    }
    else if (BTreeTupleIsPosting(itup))
        return BTreeTupleGetPosting(itup);
 
    return &itup->t_tid;
}

References BT_PIVOT_HEAP_TID_ATTR, BTreeTupleGetPosting(), BTreeTupleIsPivot(), BTreeTupleIsPosting(), fb(), IndexTupleSize(), ItemPointerGetOffsetNumberNoCheck(), and IndexTupleData::t_tid.

Referenced by _bt_bottomupdel_finish_pending(), _bt_check_natts(), _bt_check_third_page(), _bt_compare(), _bt_delitems_delete_check(), _bt_mkscankey(), _bt_swap_posting(), _bt_truncate(), bt_entry_unique_check(), bt_page_print_tuples(), bt_target_page_check(), BTreeTupleGetHeapTIDCareful(), and BTreeTupleGetPointsToTID().

◆ BTreeTupleGetMaxHeapTID()

static ItemPointer BTreeTupleGetMaxHeapTID ( IndexTuple itup )

inlinestatic

Definition at line 665 of file nbtree.h.

{
    Assert(!BTreeTupleIsPivot(itup));
 
    if (BTreeTupleIsPosting(itup))
    {
        uint16      nposting = BTreeTupleGetNPosting(itup);
 
        return BTreeTupleGetPostingN(itup, nposting - 1);
    }
 
    return &itup->t_tid;
}

References Assert, BTreeTupleGetNPosting(), BTreeTupleGetPostingN(), BTreeTupleIsPivot(), BTreeTupleIsPosting(), fb(), and IndexTupleData::t_tid.

Referenced by _bt_bottomupdel_finish_pending(), _bt_compare(), _bt_delitems_delete_check(), _bt_swap_posting(), _bt_truncate(), and bt_target_page_check().

◆ BTreeTupleGetNPosting()

static uint16 BTreeTupleGetNPosting ( IndexTuple posting )

inlinestatic

Definition at line 519 of file nbtree.h.

{
    OffsetNumber existing;
 
    Assert(BTreeTupleIsPosting(posting));
 
    existing = ItemPointerGetOffsetNumberNoCheck(&posting->t_tid);
    return (existing & BT_OFFSET_MASK);
}

References Assert, BT_OFFSET_MASK, BTreeTupleIsPosting(), fb(), and ItemPointerGetOffsetNumberNoCheck().

Referenced by _bt_binsrch_posting(), _bt_bottomupdel_finish_pending(), _bt_check_unique(), _bt_deadblocks(), _bt_dedup_save_htid(), _bt_dedup_start_pending(), _bt_delitems_delete_check(), _bt_killitems(), _bt_readpage(), _bt_simpledel_pass(), _bt_swap_posting(), _bt_update_posting(), bt_entry_unique_check(), bt_page_print_tuples(), bt_target_page_check(), BTreeTupleGetMaxHeapTID(), btreevacuumposting(), and btvacuumpage().

◆ BTreeTupleGetPosting()

static ItemPointer BTreeTupleGetPosting ( IndexTuple posting )

inlinestatic

Definition at line 538 of file nbtree.h.

{
    return (ItemPointer) ((char *) posting +
                          BTreeTupleGetPostingOffset(posting));
}

References BTreeTupleGetPostingOffset(), and fb().

Referenced by _bt_dedup_save_htid(), _bt_dedup_start_pending(), _bt_form_posting(), _bt_update_posting(), bt_page_print_tuples(), BTreeTupleGetHeapTID(), BTreeTupleGetPostingN(), and btreevacuumposting().

◆ BTreeTupleGetPostingN()

static ItemPointer BTreeTupleGetPostingN	(	IndexTuple	posting,
		int	n
	)

inlinestatic

Definition at line 545 of file nbtree.h.

{
    return BTreeTupleGetPosting(posting) + n;
}

References BTreeTupleGetPosting(), and fb().

Referenced by _bt_binsrch_posting(), _bt_bottomupdel_finish_pending(), _bt_check_unique(), _bt_deadblocks(), _bt_delitems_delete_check(), _bt_killitems(), _bt_readpage(), _bt_simpledel_pass(), _bt_swap_posting(), _bt_update_posting(), bt_entry_unique_check(), bt_posting_plain_tuple(), bt_target_page_check(), and BTreeTupleGetMaxHeapTID().

◆ BTreeTupleGetPostingOffset()

static uint32 BTreeTupleGetPostingOffset ( IndexTuple posting )

inlinestatic

Definition at line 530 of file nbtree.h.

{
    Assert(BTreeTupleIsPosting(posting));
 
    return ItemPointerGetBlockNumberNoCheck(&posting->t_tid);
}

References Assert, BTreeTupleIsPosting(), fb(), and ItemPointerGetBlockNumberNoCheck().

Referenced by _bt_dedup_start_pending(), _bt_form_posting(), _bt_recsplitloc(), _bt_setuppostingitems(), _bt_sort_dedup_finish_pending(), _bt_truncate(), _bt_update_posting(), bt_page_print_tuples(), and BTreeTupleGetPosting().

◆ BTreeTupleGetTopParent()

static BlockNumber BTreeTupleGetTopParent ( IndexTuple leafhikey )

inlinestatic

Definition at line 621 of file nbtree.h.

{
    return ItemPointerGetBlockNumberNoCheck(&leafhikey->t_tid);
}

References fb(), and ItemPointerGetBlockNumberNoCheck().

Referenced by _bt_unlink_halfdead_page(), and bt_downlink_missing_check().

◆ BTreeTupleIsPivot()

static bool BTreeTupleIsPivot ( IndexTuple itup )

inlinestatic

Definition at line 481 of file nbtree.h.

{
    if ((itup->t_info & INDEX_ALT_TID_MASK) == 0)
        return false;
    /* absence of BT_IS_POSTING in offset number indicates pivot tuple */
    if ((ItemPointerGetOffsetNumberNoCheck(&itup->t_tid) & BT_IS_POSTING) != 0)
        return false;
 
    return true;
}

References BT_IS_POSTING, INDEX_ALT_TID_MASK, ItemPointerGetOffsetNumberNoCheck(), IndexTupleData::t_info, and IndexTupleData::t_tid.

Referenced by _bt_check_compare(), _bt_check_natts(), _bt_check_rowcompare(), _bt_check_unique(), _bt_deadblocks(), _bt_dedup_save_htid(), _bt_dedup_start_pending(), _bt_form_posting(), _bt_readpage(), _bt_saveitem(), _bt_search(), _bt_swap_posting(), _bt_truncate(), bt_normalize_tuple(), bt_page_print_tuples(), BTreeTupleGetHeapTID(), BTreeTupleGetHeapTIDCareful(), BTreeTupleGetMaxHeapTID(), BTreeTupleGetPointsToTID(), BTreeTupleSetNAtts(), BTreeTupleSetPosting(), and btvacuumpage().

◆ BTreeTupleIsPosting()

static bool BTreeTupleIsPosting ( IndexTuple itup )

inlinestatic

Definition at line 493 of file nbtree.h.

{
    if ((itup->t_info & INDEX_ALT_TID_MASK) == 0)
        return false;
    /* presence of BT_IS_POSTING in offset number indicates posting tuple */
    if ((ItemPointerGetOffsetNumberNoCheck(&itup->t_tid) & BT_IS_POSTING) == 0)
        return false;
 
    return true;
}

References BT_IS_POSTING, INDEX_ALT_TID_MASK, ItemPointerGetOffsetNumberNoCheck(), IndexTupleData::t_info, and IndexTupleData::t_tid.

Referenced by _bt_afternewitemoff(), _bt_binsrch_posting(), _bt_bottomupdel_finish_pending(), _bt_check_natts(), _bt_check_unique(), _bt_compare(), _bt_deadblocks(), _bt_dedup_save_htid(), _bt_dedup_start_pending(), _bt_delitems_delete_check(), _bt_findsplitloc(), _bt_form_posting(), _bt_insertonpg(), _bt_killitems(), _bt_readpage(), _bt_recsplitloc(), _bt_saveitem(), _bt_setuppostingitems(), _bt_simpledel_pass(), _bt_split(), _bt_swap_posting(), _bt_truncate(), bt_entry_unique_check(), bt_normalize_tuple(), bt_page_print_tuples(), bt_posting_plain_tuple(), bt_target_page_check(), BTreeTupleGetHeapTID(), BTreeTupleGetMaxHeapTID(), BTreeTupleGetNPosting(), BTreeTupleGetPostingOffset(), and btvacuumpage().

◆ BTreeTupleSetDownLink()

static void BTreeTupleSetDownLink	(	IndexTuple	pivot,
		BlockNumber	blkno
	)

inlinestatic

Definition at line 563 of file nbtree.h.

{
    ItemPointerSetBlockNumber(&pivot->t_tid, blkno);
}

References fb(), and ItemPointerSetBlockNumber().

Referenced by _bt_buildadd(), _bt_insert_parent(), _bt_mark_page_halfdead(), _bt_newlevel(), _bt_uppershutdown(), and btree_xlog_mark_page_halfdead().

◆ BTreeTupleSetNAtts()

static void BTreeTupleSetNAtts	(	IndexTuple	itup,
		uint16	nkeyatts,
		bool	heaptid
	)

inlinestatic

Definition at line 596 of file nbtree.h.

{
    Assert(nkeyatts <= INDEX_MAX_KEYS);
    Assert((nkeyatts & BT_STATUS_OFFSET_MASK) == 0);
    Assert(!heaptid || nkeyatts > 0);
    Assert(!BTreeTupleIsPivot(itup) || nkeyatts == 0);
 
    itup->t_info |= INDEX_ALT_TID_MASK;
 
    if (heaptid)
        nkeyatts |= BT_PIVOT_HEAP_TID_ATTR;
 
    /* BT_IS_POSTING bit is deliberately unset here */
    ItemPointerSetOffsetNumber(&itup->t_tid, nkeyatts);
    Assert(BTreeTupleIsPivot(itup));
}

References Assert, BT_PIVOT_HEAP_TID_ATTR, BT_STATUS_OFFSET_MASK, BTreeTupleIsPivot(), fb(), INDEX_ALT_TID_MASK, INDEX_MAX_KEYS, ItemPointerSetOffsetNumber(), IndexTupleData::t_info, and IndexTupleData::t_tid.

Referenced by _bt_buildadd(), _bt_newlevel(), _bt_pgaddtup(), _bt_sortaddtup(), _bt_truncate(), and BTreeTupleSetTopParent().

◆ BTreeTupleSetPosting()

static void BTreeTupleSetPosting	(	IndexTuple	itup,
		uint16	nhtids,
		int	postingoffset
	)

inlinestatic

Definition at line 505 of file nbtree.h.

{
    Assert(nhtids > 1);
    Assert((nhtids & BT_STATUS_OFFSET_MASK) == 0);
    Assert((size_t) postingoffset == MAXALIGN(postingoffset));
    Assert(postingoffset < INDEX_SIZE_MASK);
    Assert(!BTreeTupleIsPivot(itup));
 
    itup->t_info |= INDEX_ALT_TID_MASK;
    ItemPointerSetOffsetNumber(&itup->t_tid, (nhtids | BT_IS_POSTING));
    ItemPointerSetBlockNumber(&itup->t_tid, postingoffset);
}

References Assert, BT_IS_POSTING, BT_STATUS_OFFSET_MASK, BTreeTupleIsPivot(), fb(), INDEX_ALT_TID_MASK, INDEX_SIZE_MASK, ItemPointerSetBlockNumber(), ItemPointerSetOffsetNumber(), MAXALIGN, IndexTupleData::t_info, and IndexTupleData::t_tid.

Referenced by _bt_form_posting(), and _bt_update_posting().

◆ BTreeTupleSetTopParent()

static void BTreeTupleSetTopParent	(	IndexTuple	leafhikey,
		BlockNumber	blkno
	)

inlinestatic

Definition at line 627 of file nbtree.h.

{
    ItemPointerSetBlockNumber(&leafhikey->t_tid, blkno);
    BTreeTupleSetNAtts(leafhikey, 0, false);
}

References BTreeTupleSetNAtts(), fb(), and ItemPointerSetBlockNumber().

Referenced by _bt_mark_page_halfdead(), _bt_unlink_halfdead_page(), btree_xlog_mark_page_halfdead(), and btree_xlog_unlink_page().

◆ btrescan()

void btrescan	(	IndexScanDesc	scan,
		ScanKey	scankey,
		int	nscankeys,
		ScanKey	orderbys,
		int	norderbys
	)

extern

Definition at line 388 of file nbtree.c.

{
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
 
    /* we aren't holding any read locks, but gotta drop the pins */
    if (BTScanPosIsValid(so->currPos))
    {
        /* Before leaving current page, deal with any killed items */
        if (so->numKilled > 0)
            _bt_killitems(scan);
        BTScanPosUnpinIfPinned(so->currPos);
        BTScanPosInvalidate(so->currPos);
    }
 
    /*
     * We prefer to eagerly drop leaf page pins before btgettuple returns.
     * This avoids making VACUUM wait to acquire a cleanup lock on the page.
     *
     * We cannot safely drop leaf page pins during index-only scans due to a
     * race condition involving VACUUM setting pages all-visible in the VM.
     * It's also unsafe for plain index scans that use a non-MVCC snapshot.
     *
     * Also opt out of dropping leaf page pins eagerly during bitmap scans.
     * Pins cannot be held for more than an instant during bitmap scans either
     * way, so we might as well avoid wasting cycles on acquiring page LSNs.
     *
     * See nbtree/README section on making concurrent TID recycling safe.
     *
     * Note: so->dropPin should never change across rescans.
     */
    so->dropPin = (!scan->xs_want_itup &&
                   IsMVCCLikeSnapshot(scan->xs_snapshot) &&
                   scan->heapRelation != NULL);
 
    so->markItemIndex = -1;
    so->needPrimScan = false;
    so->scanBehind = false;
    so->oppositeDirCheck = false;
    BTScanPosUnpinIfPinned(so->markPos);
    BTScanPosInvalidate(so->markPos);
 
    /*
     * Allocate tuple workspace arrays, if needed for an index-only scan and
     * not already done in a previous rescan call.  To save on palloc
     * overhead, both workspaces are allocated as one palloc block; only this
     * function and btendscan know that.
     */
    if (scan->xs_want_itup && so->currTuples == NULL)
    {
        so->currTuples = (char *) palloc(BLCKSZ * 2);
        so->markTuples = so->currTuples + BLCKSZ;
    }
 
    /*
     * Reset the scan keys
     */
    if (scankey && scan->numberOfKeys > 0)
        memcpy(scan->keyData, scankey, scan->numberOfKeys * sizeof(ScanKeyData));
    so->numberOfKeys = 0;       /* until _bt_preprocess_keys sets it */
    so->numArrayKeys = 0;       /* ditto */
}

References _bt_killitems(), BTScanPosInvalidate, BTScanPosIsValid, BTScanPosUnpinIfPinned, fb(), IndexScanDescData::heapRelation, IsMVCCLikeSnapshot, IndexScanDescData::keyData, memcpy(), IndexScanDescData::numberOfKeys, IndexScanDescData::opaque, palloc(), IndexScanDescData::xs_snapshot, and IndexScanDescData::xs_want_itup.

Referenced by bthandler().

◆ btrestrpos()

void btrestrpos ( IndexScanDesc scan )

extern

Definition at line 517 of file nbtree.c.

{
    BTScanOpaque so = (BTScanOpaque) scan->opaque;
 
    if (so->markItemIndex >= 0)
    {
        /*
         * The scan has never moved to a new page since the last mark.  Just
         * restore the itemIndex.
         *
         * NB: In this case we can't count on anything in so->markPos to be
         * accurate.
         */
        so->currPos.itemIndex = so->markItemIndex;
    }
    else
    {
        /*
         * The scan moved to a new page after last mark or restore, and we are
         * now restoring to the marked page.  We aren't holding any read
         * locks, but if we're still holding the pin for the current position,
         * we must drop it.
         */
        if (BTScanPosIsValid(so->currPos))
        {
            /* Before leaving current page, deal with any killed items */
            if (so->numKilled > 0)
                _bt_killitems(scan);
            BTScanPosUnpinIfPinned(so->currPos);
        }
 
        if (BTScanPosIsValid(so->markPos))
        {
            /* bump pin on mark buffer for assignment to current buffer */
            if (BTScanPosIsPinned(so->markPos))
                IncrBufferRefCount(so->markPos.buf);
            memcpy(&so->currPos, &so->markPos,
                   offsetof(BTScanPosData, items[1]) +
                   so->markPos.lastItem * sizeof(BTScanPosItem));
            if (so->currTuples)
                memcpy(so->currTuples, so->markTuples,
                       so->markPos.nextTupleOffset);
            /* Reset the scan's array keys (see _bt_steppage for why) */
            if (so->numArrayKeys)
            {
                _bt_start_array_keys(scan, so->currPos.dir);
                so->needPrimScan = false;
            }
        }
        else
            BTScanPosInvalidate(so->currPos);
    }
}

References _bt_killitems(), _bt_start_array_keys(), BTScanPosInvalidate, BTScanPosIsPinned, BTScanPosIsValid, BTScanPosUnpinIfPinned, fb(), IncrBufferRefCount(), items, memcpy(), and IndexScanDescData::opaque.

Referenced by bthandler().

◆ bttranslatecmptype()

StrategyNumber bttranslatecmptype	(	CompareType	cmptype,
		Oid	opfamily
	)

extern

Definition at line 1834 of file nbtree.c.

{
    switch (cmptype)
    {
        case COMPARE_LT:
            return BTLessStrategyNumber;
        case COMPARE_LE:
            return BTLessEqualStrategyNumber;
        case COMPARE_EQ:
            return BTEqualStrategyNumber;
        case COMPARE_GE:
            return BTGreaterEqualStrategyNumber;
        case COMPARE_GT:
            return BTGreaterStrategyNumber;
        default:
            return InvalidStrategy;
    }
}

References BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, COMPARE_EQ, COMPARE_GE, COMPARE_GT, COMPARE_LE, COMPARE_LT, and InvalidStrategy.

Referenced by bthandler().

◆ bttranslatestrategy()

CompareType bttranslatestrategy	(	StrategyNumber	strategy,
		Oid	opfamily
	)

extern

Definition at line 1814 of file nbtree.c.

{
    switch (strategy)
    {
        case BTLessStrategyNumber:
            return COMPARE_LT;
        case BTLessEqualStrategyNumber:
            return COMPARE_LE;
        case BTEqualStrategyNumber:
            return COMPARE_EQ;
        case BTGreaterEqualStrategyNumber:
            return COMPARE_GE;
        case BTGreaterStrategyNumber:
            return COMPARE_GT;
        default:
            return COMPARE_INVALID;
    }
}

References BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, COMPARE_EQ, COMPARE_GE, COMPARE_GT, COMPARE_INVALID, COMPARE_LE, and COMPARE_LT.

Referenced by bthandler().

◆ btvacuumcleanup()

IndexBulkDeleteResult * btvacuumcleanup	(	IndexVacuumInfo *	info,
		IndexBulkDeleteResult *	stats
	)

extern

Definition at line 1149 of file nbtree.c.

{
    BlockNumber num_delpages;
 
    /* No-op in ANALYZE ONLY mode */
    if (info->analyze_only)
        return stats;
 
    /*
     * If btbulkdelete was called, we need not do anything (we just maintain
     * the information used within _bt_vacuum_needs_cleanup() by calling
     * _bt_set_cleanup_info() below).
     *
     * If btbulkdelete was _not_ called, then we have a choice to make: we
     * must decide whether or not a btvacuumscan() call is needed now (i.e.
     * whether the ongoing VACUUM operation can entirely avoid a physical scan
     * of the index).  A call to _bt_vacuum_needs_cleanup() decides it for us
     * now.
     */
    if (stats == NULL)
    {
        /* Check if VACUUM operation can entirely avoid btvacuumscan() call */
        if (!_bt_vacuum_needs_cleanup(info->index))
            return NULL;
 
        /*
         * Since we aren't going to actually delete any leaf items, there's no
         * need to go through all the vacuum-cycle-ID pushups here.
         *
         * Posting list tuples are a source of inaccuracy for cleanup-only
         * scans.  btvacuumscan() will assume that the number of index tuples
         * from each page can be used as num_index_tuples, even though
         * num_index_tuples is supposed to represent the number of TIDs in the
         * index.  This naive approach can underestimate the number of tuples
         * in the index significantly.
         *
         * We handle the problem by making num_index_tuples an estimate in
         * cleanup-only case.
         */
        stats = palloc0_object(IndexBulkDeleteResult);
        btvacuumscan(info, stats, NULL, NULL, 0);
        stats->estimated_count = true;
    }
 
    /*
     * Maintain num_delpages value in metapage for _bt_vacuum_needs_cleanup().
     *
     * num_delpages is the number of deleted pages now in the index that were
     * not safe to place in the FSM to be recycled just yet.  num_delpages is
     * greater than 0 only when _bt_pagedel() actually deleted pages during
     * our call to btvacuumscan().  Even then, _bt_pendingfsm_finalize() must
     * have failed to place any newly deleted pages in the FSM just moments
     * ago.  (Actually, there are edge cases where recycling of the current
     * VACUUM's newly deleted pages does not even become safe by the time the
     * next VACUUM comes around.  See nbtree/README.)
     */
    Assert(stats->pages_deleted >= stats->pages_free);
    num_delpages = stats->pages_deleted - stats->pages_free;
    _bt_set_cleanup_info(info->index, num_delpages);
 
    /*
     * It's quite possible for us to be fooled by concurrent page splits into
     * double-counting some index tuples, so disbelieve any total that exceeds
     * the underlying heap's count ... if we know that accurately.  Otherwise
     * this might just make matters worse.
     */
    if (!info->estimated_count)
    {
        if (stats->num_index_tuples > info->num_heap_tuples)
            stats->num_index_tuples = info->num_heap_tuples;
    }
 
    return stats;
}

References _bt_set_cleanup_info(), _bt_vacuum_needs_cleanup(), IndexVacuumInfo::analyze_only, Assert, btvacuumscan(), IndexVacuumInfo::estimated_count, IndexBulkDeleteResult::estimated_count, fb(), IndexVacuumInfo::index, IndexVacuumInfo::num_heap_tuples, IndexBulkDeleteResult::num_index_tuples, IndexBulkDeleteResult::pages_deleted, IndexBulkDeleteResult::pages_free, and palloc0_object.

Referenced by bthandler().

◆ btvalidate()

bool btvalidate ( Oid opclassoid )

extern

Definition at line 40 of file nbtvalidate.c.

{
    bool        result = true;
    HeapTuple   classtup;
    Form_pg_opclass classform;
    Oid         opfamilyoid;
    Oid         opcintype;
    char       *opclassname;
    char       *opfamilyname;
    CatCList   *proclist,
               *oprlist;
    List       *grouplist;
    OpFamilyOpFuncGroup *opclassgroup;
    List       *familytypes;
    int         usefulgroups;
    int         i;
    ListCell   *lc;
 
    /* Fetch opclass information */
    classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassoid));
    if (!HeapTupleIsValid(classtup))
        elog(ERROR, "cache lookup failed for operator class %u", opclassoid);
    classform = (Form_pg_opclass) GETSTRUCT(classtup);
 
    opfamilyoid = classform->opcfamily;
    opcintype = classform->opcintype;
    opclassname = NameStr(classform->opcname);
 
    /* Fetch opfamily information */
    opfamilyname = get_opfamily_name(opfamilyoid, false);
 
    /* Fetch all operators and support functions of the opfamily */
    oprlist = SearchSysCacheList1(AMOPSTRATEGY, ObjectIdGetDatum(opfamilyoid));
    proclist = SearchSysCacheList1(AMPROCNUM, ObjectIdGetDatum(opfamilyoid));
 
    /* Check individual support functions */
    for (i = 0; i < proclist->n_members; i++)
    {
        HeapTuple   proctup = &proclist->members[i]->tuple;
        Form_pg_amproc procform = (Form_pg_amproc) GETSTRUCT(proctup);
        bool        ok;
 
        /* Check procedure numbers and function signatures */
        switch (procform->amprocnum)
        {
            case BTORDER_PROC:
                ok = check_amproc_signature(procform->amproc, INT4OID, true,
                                            2, 2, procform->amproclefttype,
                                            procform->amprocrighttype);
                break;
            case BTSORTSUPPORT_PROC:
                ok = check_amproc_signature(procform->amproc, VOIDOID, true,
                                            1, 1, INTERNALOID);
                break;
            case BTINRANGE_PROC:
                ok = check_amproc_signature(procform->amproc, BOOLOID, true,
                                            5, 5,
                                            procform->amproclefttype,
                                            procform->amproclefttype,
                                            procform->amprocrighttype,
                                            BOOLOID, BOOLOID);
                break;
            case BTEQUALIMAGE_PROC:
                ok = check_amproc_signature(procform->amproc, BOOLOID, true,
                                            1, 1, OIDOID);
                break;
            case BTOPTIONS_PROC:
                ok = check_amoptsproc_signature(procform->amproc);
                break;
            case BTSKIPSUPPORT_PROC:
                ok = check_amproc_signature(procform->amproc, VOIDOID, true,
                                            1, 1, INTERNALOID);
                break;
            default:
                ereport(INFO,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d",
                                opfamilyname, "btree",
                                format_procedure(procform->amproc),
                                procform->amprocnum)));
                result = false;
                continue;       /* don't want additional message */
        }
 
        if (!ok)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d",
                            opfamilyname, "btree",
                            format_procedure(procform->amproc),
                            procform->amprocnum)));
            result = false;
        }
    }
 
    /* Check individual operators */
    for (i = 0; i < oprlist->n_members; i++)
    {
        HeapTuple   oprtup = &oprlist->members[i]->tuple;
        Form_pg_amop oprform = (Form_pg_amop) GETSTRUCT(oprtup);
 
        /* Check that only allowed strategy numbers exist */
        if (oprform->amopstrategy < 1 ||
            oprform->amopstrategy > BTMaxStrategyNumber)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d",
                            opfamilyname, "btree",
                            format_operator(oprform->amopopr),
                            oprform->amopstrategy)));
            result = false;
        }
 
        /* btree doesn't support ORDER BY operators */
        if (oprform->amoppurpose != AMOP_SEARCH ||
            OidIsValid(oprform->amopsortfamily))
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s",
                            opfamilyname, "btree",
                            format_operator(oprform->amopopr))));
            result = false;
        }
 
        /* Check operator signature --- same for all btree strategies */
        if (!check_amop_signature(oprform->amopopr, BOOLOID,
                                  oprform->amoplefttype,
                                  oprform->amoprighttype))
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature",
                            opfamilyname, "btree",
                            format_operator(oprform->amopopr))));
            result = false;
        }
    }
 
    /* Now check for inconsistent groups of operators/functions */
    grouplist = identify_opfamily_groups(oprlist, proclist);
    usefulgroups = 0;
    opclassgroup = NULL;
    familytypes = NIL;
    foreach(lc, grouplist)
    {
        OpFamilyOpFuncGroup *thisgroup = (OpFamilyOpFuncGroup *) lfirst(lc);
 
        /*
         * It is possible for an in_range support function to have a RHS type
         * that is otherwise irrelevant to the opfamily --- for instance, SQL
         * requires the datetime_ops opclass to have range support with an
         * interval offset.  So, if this group appears to contain only an
         * in_range function, ignore it: it doesn't represent a pair of
         * supported types.
         */
        if (thisgroup->operatorset == 0 &&
            thisgroup->functionset == (1 << BTINRANGE_PROC))
            continue;
 
        /* Else count it as a relevant group */
        usefulgroups++;
 
        /* Remember the group exactly matching the test opclass */
        if (thisgroup->lefttype == opcintype &&
            thisgroup->righttype == opcintype)
            opclassgroup = thisgroup;
 
        /*
         * Identify all distinct data types handled in this opfamily.  This
         * implementation is O(N^2), but there aren't likely to be enough
         * types in the family for it to matter.
         */
        familytypes = list_append_unique_oid(familytypes, thisgroup->lefttype);
        familytypes = list_append_unique_oid(familytypes, thisgroup->righttype);
 
        /*
         * Complain if there seems to be an incomplete set of either operators
         * or support functions for this datatype pair.  The sortsupport,
         * in_range, and equalimage functions are considered optional.
         */
        if (thisgroup->operatorset !=
            ((1 << BTLessStrategyNumber) |
             (1 << BTLessEqualStrategyNumber) |
             (1 << BTEqualStrategyNumber) |
             (1 << BTGreaterEqualStrategyNumber) |
             (1 << BTGreaterStrategyNumber)))
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s is missing operator(s) for types %s and %s",
                            opfamilyname, "btree",
                            format_type_be(thisgroup->lefttype),
                            format_type_be(thisgroup->righttype))));
            result = false;
        }
        if ((thisgroup->functionset & (1 << BTORDER_PROC)) == 0)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s is missing support function for types %s and %s",
                            opfamilyname, "btree",
                            format_type_be(thisgroup->lefttype),
                            format_type_be(thisgroup->righttype))));
            result = false;
        }
    }
 
    /* Check that the originally-named opclass is supported */
    /* (if group is there, we already checked it adequately above) */
    if (!opclassgroup)
    {
        ereport(INFO,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("operator class \"%s\" of access method %s is missing operator(s)",
                        opclassname, "btree")));
        result = false;
    }
 
    /*
     * Complain if the opfamily doesn't have entries for all possible
     * combinations of its supported datatypes.  While missing cross-type
     * operators are not fatal, they do limit the planner's ability to derive
     * additional qual clauses from equivalence classes, so it seems
     * reasonable to insist that all built-in btree opfamilies be complete.
     */
    if (usefulgroups != (list_length(familytypes) * list_length(familytypes)))
    {
        ereport(INFO,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("operator family \"%s\" of access method %s is missing cross-type operator(s)",
                        opfamilyname, "btree")));
        result = false;
    }
 
    ReleaseCatCacheList(proclist);
    ReleaseCatCacheList(oprlist);
    ReleaseSysCache(classtup);
 
    return result;
}

References BTEQUALIMAGE_PROC, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTINRANGE_PROC, BTLessEqualStrategyNumber, BTLessStrategyNumber, BTMaxStrategyNumber, BTOPTIONS_PROC, BTORDER_PROC, BTSKIPSUPPORT_PROC, BTSORTSUPPORT_PROC, check_amop_signature(), check_amoptsproc_signature(), check_amproc_signature(), elog, ereport, errcode(), errmsg, ERROR, fb(), Form_pg_amop, Form_pg_amproc, Form_pg_opclass, format_operator(), format_procedure(), format_type_be(), get_opfamily_name(), GETSTRUCT(), HeapTupleIsValid, i, identify_opfamily_groups(), INFO, lfirst, list_append_unique_oid(), list_length(), NameStr, NIL, ObjectIdGetDatum(), OidIsValid, ReleaseCatCacheList(), ReleaseSysCache(), result, SearchSysCache1(), and SearchSysCacheList1.

Referenced by bthandler().

◆ StaticAssertDecl()

StaticAssertDecl	(	BT_OFFSET_MASK >=	INDEX_MAX_KEYS,
		"BT_OFFSET_MASK can't fit INDEX_MAX_KEYS"
	)

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ BT_IS_POSTING

◆ BT_OFFSET_MASK

◆ BT_PIVOT_HEAP_TID_ATTR

◆ BT_READ

◆ BT_STATUS_OFFSET_MASK

◆ BT_WRITE

◆ BTCommuteStrategyNumber

◆ BTEQUALIMAGE_PROC

◆ BTGetDeduplicateItems

◆ BTGetFillFactor

◆ BTGetTargetPageFreeSpace

◆ BTINRANGE_PROC

◆ BTMaxItemSize

◆ BTMaxItemSizeNoHeapTid

◆ BTNProcs

◆ BTOPTIONS_PROC

◆ BTORDER_PROC

◆ BTP_DELETED

◆ BTP_HALF_DEAD

◆ BTP_HAS_FULLXID

◆ BTP_HAS_GARBAGE

◆ BTP_INCOMPLETE_SPLIT

◆ BTP_LEAF

◆ BTP_META

◆ BTP_ROOT

◆ BTP_SPLIT_END

◆ BTPageGetMeta

◆ BTPageGetOpaque

◆ BTREE_DEFAULT_FILLFACTOR

◆ BTREE_MAGIC

◆ BTREE_METAPAGE

◆ BTREE_MIN_FILLFACTOR

◆ BTREE_MIN_VERSION

◆ BTREE_NONLEAF_FILLFACTOR

◆ BTREE_NOVAC_VERSION

◆ BTREE_SINGLEVAL_FILLFACTOR

◆ BTREE_VERSION

◆ BTreeTupleGetNAtts

◆ BTScanPosInvalidate

◆ BTScanPosIsPinned

◆ BTScanPosIsValid

◆ BTScanPosUnpin

◆ BTScanPosUnpinIfPinned

◆ BTSKIPSUPPORT_PROC

◆ BTSORTSUPPORT_PROC

◆ INDEX_ALT_TID_MASK

◆ MAX_BT_CYCLE_ID

◆ MaxTIDsPerBTreePage

◆ P_FIRSTDATAKEY

◆ P_FIRSTKEY

◆ P_HAS_FULLXID

◆ P_HAS_GARBAGE

◆ P_HIKEY

◆ P_IGNORE

◆ P_INCOMPLETE_SPLIT

◆ P_ISDELETED

◆ P_ISHALFDEAD

◆ P_ISLEAF

◆ P_ISMETA

◆ P_ISROOT

◆ P_LEFTMOST

◆ P_NONE

◆ P_RIGHTMOST

◆ PROGRESS_BTREE_PHASE_INDEXBUILD_TABLESCAN

◆ PROGRESS_BTREE_PHASE_LEAF_LOAD

◆ PROGRESS_BTREE_PHASE_PERFORMSORT_1

◆ PROGRESS_BTREE_PHASE_PERFORMSORT_2

◆ SK_BT_DESC

◆ SK_BT_INDOPTION_SHIFT

◆ SK_BT_MAXVAL

◆ SK_BT_MINVAL

◆ SK_BT_NEXT

◆ SK_BT_NULLS_FIRST

◆ SK_BT_PRIOR

◆ SK_BT_REQBKWD