#include "access/amapi.h"
#include "access/generic_xlog.h"
#include "access/itup.h"
#include "access/xlog.h"
#include "fmgr.h"
#include "nodes/pathnodes.h"

Include dependency graph for bloom.h:

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

Go to the source code of this file.

Data Structures
struct	BloomPageOpaqueData

struct	BloomOptions

struct	BloomMetaPageData

struct	BloomState

struct	BloomTuple

struct	BloomScanOpaqueData

Macros
#define	BLOOM_HASH_PROC 1

#define	BLOOM_OPTIONS_PROC 2

#define	BLOOM_NPROC 2

#define	BLOOM_EQUAL_STRATEGY 1

#define	BLOOM_NSTRATEGIES 1

#define	BLOOM_META (1<<0)

#define	BLOOM_DELETED (2<<0)

#define	BLOOM_PAGE_ID 0xFF83

#define	BloomPageGetOpaque(page) ((BloomPageOpaque) PageGetSpecialPointer(page))

#define	BloomPageGetMaxOffset(page) (BloomPageGetOpaque(page)->maxoff)

#define	BloomPageIsMeta(page) ((BloomPageGetOpaque(page)->flags & BLOOM_META) != 0)

#define	BloomPageIsDeleted(page) ((BloomPageGetOpaque(page)->flags & BLOOM_DELETED) != 0)

#define	BloomPageSetDeleted(page) (BloomPageGetOpaque(page)->flags \|= BLOOM_DELETED)

#define	BloomPageSetNonDeleted(page) (BloomPageGetOpaque(page)->flags &= ~BLOOM_DELETED)

#define	BloomPageGetData(page) ((BloomTuple *)PageGetContents(page))

#define	BloomPageGetTuple(state, page, offset)

#define	BloomPageGetNextTuple(state, tuple) ((BloomTuple )((char )(tuple) + (state)->sizeOfBloomTuple))

#define	BLOOM_METAPAGE_BLKNO (0)

#define	BLOOM_HEAD_BLKNO (1) /* first data page */

#define	SIGNWORDBITS ((int) (BITS_PER_BYTE * sizeof(BloomSignatureWord)))

#define	DEFAULT_BLOOM_LENGTH (5 * SIGNWORDBITS)

#define	MAX_BLOOM_LENGTH (256 * SIGNWORDBITS)

#define	DEFAULT_BLOOM_BITS 2

#define	MAX_BLOOM_BITS (MAX_BLOOM_LENGTH - 1)

#define	BLOOM_MAGICK_NUMBER (0xDBAC0DED)

#define	BloomMetaBlockN (sizeof(FreeBlockNumberArray) / sizeof(BlockNumber))

#define	BloomPageGetMeta(page) ((BloomMetaPageData *) PageGetContents(page))

#define	BloomPageGetFreeSpace(state, page)

#define	BLOOMTUPLEHDRSZ offsetof(BloomTuple, sign)

Typedefs
typedef struct BloomPageOpaqueData	BloomPageOpaqueData

typedef BloomPageOpaqueData *	BloomPageOpaque

typedef uint16	BloomSignatureWord

typedef struct BloomOptions	BloomOptions

typedef BlockNumber	FreeBlockNumberArray[MAXALIGN_DOWN(BLCKSZ - SizeOfPageHeaderData - MAXALIGN(sizeof(BloomPageOpaqueData)) - MAXALIGN(sizeof(uint16) *2+sizeof(uint32)+sizeof(BloomOptions)))/sizeof(BlockNumber)]

typedef struct BloomMetaPageData	BloomMetaPageData

typedef struct BloomState	BloomState

typedef struct BloomTuple	BloomTuple

typedef struct BloomScanOpaqueData	BloomScanOpaqueData

typedef BloomScanOpaqueData *	BloomScanOpaque

Functions
void	initBloomState (BloomState *state, Relation index)

void	BloomFillMetapage (Relation index, Page metaPage)

void	BloomInitMetapage (Relation index, ForkNumber forknum)

void	BloomInitPage (Page page, uint16 flags)

Buffer	BloomNewBuffer (Relation index)

void	signValue (BloomState state, BloomSignatureWord sign, Datum value, int attno)

BloomTuple *	BloomFormTuple (BloomState state, ItemPointer iptr, Datum values, bool *isnull)

bool	BloomPageAddItem (BloomState state, Page page, BloomTuple tuple)

bool	blvalidate (Oid opclassoid)

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

IndexScanDesc	blbeginscan (Relation r, int nkeys, int norderbys)

int64	blgetbitmap (IndexScanDesc scan, TIDBitmap *tbm)

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

void	blendscan (IndexScanDesc scan)

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

void	blbuildempty (Relation index)

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

IndexBulkDeleteResult *	blvacuumcleanup (IndexVacuumInfo info, IndexBulkDeleteResult stats)

bytea *	bloptions (Datum reloptions, bool validate)

void	blcostestimate (PlannerInfo root, IndexPath path, double loop_count, Cost indexStartupCost, Cost indexTotalCost, Selectivity indexSelectivity, double indexCorrelation, double *indexPages)

Macro Definition Documentation

◆ BLOOM_DELETED

#define BLOOM_DELETED (2<<0)

Definition at line 47 of file bloom.h.

◆ BLOOM_EQUAL_STRATEGY

#define BLOOM_EQUAL_STRATEGY 1

Definition at line 29 of file bloom.h.

◆ BLOOM_HASH_PROC

#define BLOOM_HASH_PROC 1

Definition at line 24 of file bloom.h.

◆ BLOOM_HEAD_BLKNO

#define BLOOM_HEAD_BLKNO (1) /* first data page */

Definition at line 79 of file bloom.h.

◆ BLOOM_MAGICK_NUMBER

#define BLOOM_MAGICK_NUMBER (0xDBAC0DED)

Definition at line 128 of file bloom.h.

◆ BLOOM_META

#define BLOOM_META (1<<0)

Definition at line 46 of file bloom.h.

◆ BLOOM_METAPAGE_BLKNO

#define BLOOM_METAPAGE_BLKNO (0)

Definition at line 78 of file bloom.h.

◆ BLOOM_NPROC

#define BLOOM_NPROC 2

Definition at line 26 of file bloom.h.

◆ BLOOM_NSTRATEGIES

#define BLOOM_NSTRATEGIES 1

Definition at line 30 of file bloom.h.

◆ BLOOM_OPTIONS_PROC

#define BLOOM_OPTIONS_PROC 2

Definition at line 25 of file bloom.h.

◆ BLOOM_PAGE_ID

#define BLOOM_PAGE_ID 0xFF83

Definition at line 57 of file bloom.h.

◆ BloomMetaBlockN

#define BloomMetaBlockN (sizeof(FreeBlockNumberArray) / sizeof(BlockNumber))

Definition at line 131 of file bloom.h.

◆ BloomPageGetData

#define BloomPageGetData ( page ) ((BloomTuple *)PageGetContents(page))

Definition at line 70 of file bloom.h.

◆ BloomPageGetFreeSpace

#define BloomPageGetFreeSpace	(	state,
		page
	)

Value:

    (BLCKSZ - MAXALIGN(SizeOfPageHeaderData) \
        - BloomPageGetMaxOffset(page) * (state)->sizeOfBloomTuple \
        - MAXALIGN(sizeof(BloomPageOpaqueData)))

Definition at line 149 of file bloom.h.

{
    ItemPointerData heapPtr;
    BloomSignatureWord sign[FLEXIBLE_ARRAY_MEMBER];
} BloomTuple;
 
#define BLOOMTUPLEHDRSZ offsetof(BloomTuple, sign)
 
/* Opaque data structure for bloom index scan */
typedef struct BloomScanOpaqueData
{
    BloomSignatureWord *sign;   /* Scan signature */
    BloomState  state;
} BloomScanOpaqueData;
 
typedef BloomScanOpaqueData *BloomScanOpaque;
 
/* blutils.c */
extern void initBloomState(BloomState *state, Relation index);
extern void BloomFillMetapage(Relation index, Page metaPage);
extern void BloomInitMetapage(Relation index, ForkNumber forknum);
extern void BloomInitPage(Page page, uint16 flags);
extern Buffer BloomNewBuffer(Relation index);
extern void signValue(BloomState *state, BloomSignatureWord *sign, Datum value, int attno);
extern BloomTuple *BloomFormTuple(BloomState *state, ItemPointer iptr, Datum *values, bool *isnull);
extern bool BloomPageAddItem(BloomState *state, Page page, BloomTuple *tuple);
 
/* blvalidate.c */
extern bool blvalidate(Oid opclassoid);
 
/* index access method interface functions */
extern bool blinsert(Relation index, Datum *values, bool *isnull,
                     ItemPointer ht_ctid, Relation heapRel,
                     IndexUniqueCheck checkUnique,
                     bool indexUnchanged,
                     struct IndexInfo *indexInfo);
extern IndexScanDesc blbeginscan(Relation r, int nkeys, int norderbys);
extern int64 blgetbitmap(IndexScanDesc scan, TIDBitmap *tbm);
extern void blrescan(IndexScanDesc scan, ScanKey scankey, int nscankeys,
                     ScanKey orderbys, int norderbys);
extern void blendscan(IndexScanDesc scan);
extern IndexBuildResult *blbuild(Relation heap, Relation index,
                                 struct IndexInfo *indexInfo);
extern void blbuildempty(Relation index);
extern IndexBulkDeleteResult *blbulkdelete(IndexVacuumInfo *info,
                                           IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback,
                                           void *callback_state);
extern IndexBulkDeleteResult *blvacuumcleanup(IndexVacuumInfo *info,
                                              IndexBulkDeleteResult *stats);
extern bytea *bloptions(Datum reloptions, bool validate);
extern void blcostestimate(PlannerInfo *root, IndexPath *path,
                           double loop_count, Cost *indexStartupCost,
                           Cost *indexTotalCost, Selectivity *indexSelectivity,
                           double *indexCorrelation, double *indexPages);
 
#endif

◆ BloomPageGetMaxOffset

#define BloomPageGetMaxOffset ( page ) (BloomPageGetOpaque(page)->maxoff)

Definition at line 61 of file bloom.h.

◆ BloomPageGetMeta

#define BloomPageGetMeta ( page ) ((BloomMetaPageData *) PageGetContents(page))

Definition at line 133 of file bloom.h.

◆ BloomPageGetNextTuple

#define BloomPageGetNextTuple	(	state,
		tuple
	)	((BloomTuple )((char )(tuple) + (state)->sizeOfBloomTuple))

Definition at line 74 of file bloom.h.

◆ BloomPageGetOpaque

#define BloomPageGetOpaque ( page ) ((BloomPageOpaque) PageGetSpecialPointer(page))

Definition at line 60 of file bloom.h.

◆ BloomPageGetTuple

#define BloomPageGetTuple	(	state,
		page,
		offset
	)

Value:

((BloomTuple *)(PageGetContents(page) \

+ (state)->sizeOfBloomTuple * ((offset) - 1)))

PageGetContents

static char * PageGetContents(Page page)

Definition bufpage.h:283

Definition at line 71 of file bloom.h.

◆ BloomPageIsDeleted

#define BloomPageIsDeleted ( page ) ((BloomPageGetOpaque(page)->flags & BLOOM_DELETED) != 0)

Definition at line 64 of file bloom.h.

◆ BloomPageIsMeta

#define BloomPageIsMeta ( page ) ((BloomPageGetOpaque(page)->flags & BLOOM_META) != 0)

Definition at line 62 of file bloom.h.

◆ BloomPageSetDeleted

#define BloomPageSetDeleted ( page ) (BloomPageGetOpaque(page)->flags |= BLOOM_DELETED)

Definition at line 66 of file bloom.h.

◆ BloomPageSetNonDeleted

#define BloomPageSetNonDeleted ( page ) (BloomPageGetOpaque(page)->flags &= ~BLOOM_DELETED)

Definition at line 68 of file bloom.h.

◆ BLOOMTUPLEHDRSZ

#define BLOOMTUPLEHDRSZ offsetof(BloomTuple, sign)

Definition at line 163 of file bloom.h.

◆ DEFAULT_BLOOM_BITS

#define DEFAULT_BLOOM_BITS 2

Definition at line 97 of file bloom.h.

◆ DEFAULT_BLOOM_LENGTH

#define DEFAULT_BLOOM_LENGTH (5 * SIGNWORDBITS)

Definition at line 91 of file bloom.h.

◆ MAX_BLOOM_BITS

#define MAX_BLOOM_BITS (MAX_BLOOM_LENGTH - 1)

Definition at line 98 of file bloom.h.

◆ MAX_BLOOM_LENGTH

#define MAX_BLOOM_LENGTH (256 * SIGNWORDBITS)

Definition at line 92 of file bloom.h.

◆ SIGNWORDBITS

#define SIGNWORDBITS ((int) (BITS_PER_BYTE * sizeof(BloomSignatureWord)))

Definition at line 86 of file bloom.h.

Typedef Documentation

◆ BloomMetaPageData

typedef struct BloomMetaPageData BloomMetaPageData

◆ BloomOptions

typedef struct BloomOptions BloomOptions

◆ BloomPageOpaque

typedef BloomPageOpaqueData* BloomPageOpaque

Definition at line 43 of file bloom.h.

◆ BloomPageOpaqueData

typedef struct BloomPageOpaqueData BloomPageOpaqueData

◆ BloomScanOpaque

typedef BloomScanOpaqueData* BloomScanOpaque

Definition at line 172 of file bloom.h.

◆ BloomScanOpaqueData

typedef struct BloomScanOpaqueData BloomScanOpaqueData

◆ BloomSignatureWord

typedef uint16 BloomSignatureWord

Definition at line 84 of file bloom.h.

◆ BloomState

typedef struct BloomState BloomState

◆ BloomTuple

typedef struct BloomTuple BloomTuple

◆ FreeBlockNumberArray

typedef BlockNumber FreeBlockNumberArray[MAXALIGN_DOWN(BLCKSZ - SizeOfPageHeaderData - MAXALIGN(sizeof(BloomPageOpaqueData)) - MAXALIGN(sizeof(uint16) *2+sizeof(uint32)+sizeof(BloomOptions)))/sizeof(BlockNumber)]

Definition at line 113 of file bloom.h.

Function Documentation

◆ blbeginscan()

IndexScanDesc blbeginscan	(	Relation	r,
		int	nkeys,
		int	norderbys
	)

extern

Definition at line 27 of file blscan.c.

{
    IndexScanDesc scan;
    BloomScanOpaque so;
 
    scan = RelationGetIndexScan(r, nkeys, norderbys);
 
    so = (BloomScanOpaque) palloc_object(BloomScanOpaqueData);
    initBloomState(&so->state, scan->indexRelation);
    so->sign = NULL;
 
    scan->opaque = so;
 
    return scan;
}

References fb(), IndexScanDescData::indexRelation, initBloomState(), IndexScanDescData::opaque, palloc_object, and RelationGetIndexScan().

Referenced by blhandler().

◆ blbuild()

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

extern

Definition at line 122 of file blinsert.c.

{
    IndexBuildResult *result;
    double      reltuples;
    BloomBuildState buildstate;
 
    if (RelationGetNumberOfBlocks(index) != 0)
        elog(ERROR, "index \"%s\" already contains data",
             RelationGetRelationName(index));
 
    /* Initialize the meta page */
    BloomInitMetapage(index, MAIN_FORKNUM);
 
    /* Initialize the bloom build state */
    memset(&buildstate, 0, sizeof(buildstate));
    initBloomState(&buildstate.blstate, index);
    buildstate.tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
                                              "Bloom build temporary context",
                                              ALLOCSET_DEFAULT_SIZES);
    initCachedPage(&buildstate);
 
    /* Do the heap scan */
    reltuples = table_index_build_scan(heap, index, indexInfo, true, true,
                                       bloomBuildCallback, &buildstate,
                                       NULL);
 
    /* Flush last page if needed (it will be, unless heap was empty) */
    if (buildstate.count > 0)
        flushCachedPage(index, &buildstate);
 
    MemoryContextDelete(buildstate.tmpCtx);
 
    result = palloc_object(IndexBuildResult);
    result->heap_tuples = reltuples;
    result->index_tuples = buildstate.indtuples;
 
    return result;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, bloomBuildCallback(), BloomInitMetapage(), CurrentMemoryContext, elog, ERROR, fb(), flushCachedPage(), IndexBuildResult::heap_tuples, IndexBuildResult::index_tuples, initBloomState(), initCachedPage(), MAIN_FORKNUM, MemoryContextDelete(), palloc_object, RelationGetNumberOfBlocks, RelationGetRelationName, and table_index_build_scan().

Referenced by blhandler().

◆ blbuildempty()

void blbuildempty ( Relation index )

extern

Definition at line 165 of file blinsert.c.

{
    /* Initialize the meta page */
    BloomInitMetapage(index, INIT_FORKNUM);
}

References BloomInitMetapage(), and INIT_FORKNUM.

Referenced by blhandler().

◆ blbulkdelete()

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

extern

Definition at line 31 of file blvacuum.c.

{
    Relation    index = info->index;
    BlockNumber blkno,
                npages;
    FreeBlockNumberArray notFullPage;
    int         countPage = 0;
    BloomState  state;
    Buffer      buffer;
    Page        page;
    BloomMetaPageData *metaData;
    GenericXLogState *gxlogState;
    BlockRangeReadStreamPrivate p;
    ReadStream *stream;
 
    if (stats == NULL)
        stats = palloc0_object(IndexBulkDeleteResult);
 
    initBloomState(&state, index);
 
    /*
     * Iterate over the pages. We don't care about concurrently added pages,
     * they can't contain tuples to delete.
     */
    npages = RelationGetNumberOfBlocks(index);
 
    /* Scan all blocks except the metapage using streaming reads */
    p.current_blocknum = BLOOM_HEAD_BLKNO;
    p.last_exclusive = npages;
 
    /*
     * It is safe to use batchmode as block_range_read_stream_cb takes no
     * locks.
     */
    stream = read_stream_begin_relation(READ_STREAM_MAINTENANCE |
                                        READ_STREAM_FULL |
                                        READ_STREAM_USE_BATCHING,
                                        info->strategy,
                                        index,
                                        MAIN_FORKNUM,
                                        block_range_read_stream_cb,
                                        &p,
                                        0);
 
    for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
    {
        BloomTuple *itup,
                   *itupPtr,
                   *itupEnd;
 
        vacuum_delay_point(false);
 
        buffer = read_stream_next_buffer(stream, NULL);
 
        LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
        gxlogState = GenericXLogStart(index);
        page = GenericXLogRegisterBuffer(gxlogState, buffer, 0);
 
        /* Ignore empty/deleted pages until blvacuumcleanup() */
        if (PageIsNew(page) || BloomPageIsDeleted(page))
        {
            UnlockReleaseBuffer(buffer);
            GenericXLogAbort(gxlogState);
            continue;
        }
 
        /*
         * Iterate over the tuples.  itup points to current tuple being
         * scanned, itupPtr points to where to save next non-deleted tuple.
         */
        itup = itupPtr = BloomPageGetTuple(&state, page, FirstOffsetNumber);
        itupEnd = BloomPageGetTuple(&state, page,
                                    OffsetNumberNext(BloomPageGetMaxOffset(page)));
        while (itup < itupEnd)
        {
            /* Do we have to delete this tuple? */
            if (callback(&itup->heapPtr, callback_state))
            {
                /* Yes; adjust count of tuples that will be left on page */
                BloomPageGetOpaque(page)->maxoff--;
                stats->tuples_removed += 1;
            }
            else
            {
                /* No; copy it to itupPtr++, but skip copy if not needed */
                if (itupPtr != itup)
                    memmove(itupPtr, itup, state.sizeOfBloomTuple);
                itupPtr = BloomPageGetNextTuple(&state, itupPtr);
            }
 
            itup = BloomPageGetNextTuple(&state, itup);
        }
 
        /* Assert that we counted correctly */
        Assert(itupPtr == BloomPageGetTuple(&state, page,
                                            OffsetNumberNext(BloomPageGetMaxOffset(page))));
 
        /*
         * Add page to new notFullPage list if we will not mark page as
         * deleted and there is free space on it
         */
        if (BloomPageGetMaxOffset(page) != 0 &&
            BloomPageGetFreeSpace(&state, page) >= state.sizeOfBloomTuple &&
            countPage < BloomMetaBlockN)
            notFullPage[countPage++] = blkno;
 
        /* Did we delete something? */
        if (itupPtr != itup)
        {
            /* Is it empty page now? */
            if (BloomPageGetMaxOffset(page) == 0)
                BloomPageSetDeleted(page);
            /* Adjust pd_lower */
            ((PageHeader) page)->pd_lower = (char *) itupPtr - page;
            /* Finish WAL-logging */
            GenericXLogFinish(gxlogState);
        }
        else
        {
            /* Didn't change anything: abort WAL-logging */
            GenericXLogAbort(gxlogState);
        }
        UnlockReleaseBuffer(buffer);
    }
 
    Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
    read_stream_end(stream);
 
    /*
     * Update the metapage's notFullPage list with whatever we found.  Our
     * info could already be out of date at this point, but blinsert() will
     * cope if so.
     */
    buffer = ReadBuffer(index, BLOOM_METAPAGE_BLKNO);
    LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 
    gxlogState = GenericXLogStart(index);
    page = GenericXLogRegisterBuffer(gxlogState, buffer, 0);
 
    metaData = BloomPageGetMeta(page);
    memcpy(metaData->notFullPage, notFullPage, sizeof(BlockNumber) * countPage);
    metaData->nStart = 0;
    metaData->nEnd = countPage;
 
    GenericXLogFinish(gxlogState);
    UnlockReleaseBuffer(buffer);
 
    return stats;
}

References Assert, block_range_read_stream_cb(), BLOOM_HEAD_BLKNO, BLOOM_METAPAGE_BLKNO, BloomMetaBlockN, BloomPageGetFreeSpace, BloomPageGetMaxOffset, BloomPageGetMeta, BloomPageGetNextTuple, BloomPageGetOpaque, BloomPageGetTuple, BloomPageIsDeleted, BloomPageSetDeleted, BUFFER_LOCK_EXCLUSIVE, callback(), BlockRangeReadStreamPrivate::current_blocknum, fb(), FirstOffsetNumber, GenericXLogAbort(), GenericXLogFinish(), GenericXLogRegisterBuffer(), GenericXLogStart(), BloomTuple::heapPtr, IndexVacuumInfo::index, initBloomState(), InvalidBuffer, BlockRangeReadStreamPrivate::last_exclusive, LockBuffer(), MAIN_FORKNUM, OffsetNumberNext, PageIsNew(), palloc0_object, read_stream_begin_relation(), read_stream_end(), READ_STREAM_FULL, READ_STREAM_MAINTENANCE, read_stream_next_buffer(), READ_STREAM_USE_BATCHING, ReadBuffer(), RelationGetNumberOfBlocks, IndexVacuumInfo::strategy, IndexBulkDeleteResult::tuples_removed, UnlockReleaseBuffer(), and vacuum_delay_point().

Referenced by blhandler().

◆ blcostestimate()

void blcostestimate	(	PlannerInfo *	root,
		IndexPath *	path,
		double	loop_count,
		Cost *	indexStartupCost,
		Cost *	indexTotalCost,
		Selectivity *	indexSelectivity,
		double *	indexCorrelation,
		double *	indexPages
	)

extern

Definition at line 22 of file blcost.c.

{
    IndexOptInfo *index = path->indexinfo;
    GenericCosts costs = {0};
 
    /* We have to visit all index tuples anyway */
    costs.numIndexTuples = index->tuples;
 
    /* As in btcostestimate, count only the metapage as non-leaf */
    costs.numNonLeafPages = 1;
 
    /* Use generic estimate */
    genericcostestimate(root, path, loop_count, &costs);
 
    *indexStartupCost = costs.indexStartupCost;
    *indexTotalCost = costs.indexTotalCost;
    *indexSelectivity = costs.indexSelectivity;
    *indexCorrelation = costs.indexCorrelation;
    *indexPages = costs.numIndexPages;
}

References fb(), genericcostestimate(), GenericCosts::indexCorrelation, IndexPath::indexinfo, GenericCosts::indexSelectivity, GenericCosts::indexStartupCost, GenericCosts::indexTotalCost, GenericCosts::numIndexPages, GenericCosts::numIndexTuples, GenericCosts::numNonLeafPages, and root.

Referenced by blhandler().

◆ blendscan()

void blendscan ( IndexScanDesc scan )

extern

Definition at line 64 of file blscan.c.

{
    BloomScanOpaque so = (BloomScanOpaque) scan->opaque;
 
    if (so->sign)
        pfree(so->sign);
    so->sign = NULL;
}

References fb(), IndexScanDescData::opaque, and pfree().

Referenced by blhandler().

◆ blgetbitmap()

int64 blgetbitmap	(	IndexScanDesc	scan,
		TIDBitmap *	tbm
	)

extern

Definition at line 77 of file blscan.c.

{
    int64       ntids = 0;
    BlockNumber blkno,
                npages;
    int         i;
    BufferAccessStrategy bas;
    BloomScanOpaque so = (BloomScanOpaque) scan->opaque;
    BlockRangeReadStreamPrivate p;
    ReadStream *stream;
 
    if (so->sign == NULL)
    {
        /* New search: have to calculate search signature */
        ScanKey     skey = scan->keyData;
 
        so->sign = palloc0_array(BloomSignatureWord, so->state.opts.bloomLength);
 
        for (i = 0; i < scan->numberOfKeys; i++)
        {
            /*
             * Assume bloom-indexable operators to be strict, so nothing could
             * be found for NULL key.
             */
            if (skey->sk_flags & SK_ISNULL)
            {
                pfree(so->sign);
                so->sign = NULL;
                return 0;
            }
 
            /* Add next value to the signature */
            signValue(&so->state, so->sign, skey->sk_argument,
                      skey->sk_attno - 1);
 
            skey++;
        }
    }
 
    /*
     * We're going to read the whole index. This is why we use appropriate
     * buffer access strategy.
     */
    bas = GetAccessStrategy(BAS_BULKREAD);
    npages = RelationGetNumberOfBlocks(scan->indexRelation);
    pgstat_count_index_scan(scan->indexRelation);
    if (scan->instrument)
        scan->instrument->nsearches++;
 
    /* Scan all blocks except the metapage using streaming reads */
    p.current_blocknum = BLOOM_HEAD_BLKNO;
    p.last_exclusive = npages;
 
    /*
     * It is safe to use batchmode as block_range_read_stream_cb takes no
     * locks.
     */
    stream = read_stream_begin_relation(READ_STREAM_FULL |
                                        READ_STREAM_USE_BATCHING,
                                        bas,
                                        scan->indexRelation,
                                        MAIN_FORKNUM,
                                        block_range_read_stream_cb,
                                        &p,
                                        0);
 
    for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
    {
        Buffer      buffer;
        Page        page;
 
        buffer = read_stream_next_buffer(stream, NULL);
        LockBuffer(buffer, BUFFER_LOCK_SHARE);
        page = BufferGetPage(buffer);
 
        if (!PageIsNew(page) && !BloomPageIsDeleted(page))
        {
            OffsetNumber offset,
                        maxOffset = BloomPageGetMaxOffset(page);
 
            for (offset = 1; offset <= maxOffset; offset++)
            {
                BloomTuple *itup = BloomPageGetTuple(&so->state, page, offset);
                bool        res = true;
 
                /* Check index signature with scan signature */
                for (i = 0; i < so->state.opts.bloomLength; i++)
                {
                    if ((itup->sign[i] & so->sign[i]) != so->sign[i])
                    {
                        res = false;
                        break;
                    }
                }
 
                /* Add matching tuples to bitmap */
                if (res)
                {
                    tbm_add_tuples(tbm, &itup->heapPtr, 1, true);
                    ntids++;
                }
            }
        }
 
        UnlockReleaseBuffer(buffer);
        CHECK_FOR_INTERRUPTS();
    }
 
    Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
    read_stream_end(stream);
    FreeAccessStrategy(bas);
 
    return ntids;
}

References Assert, BAS_BULKREAD, block_range_read_stream_cb(), BLOOM_HEAD_BLKNO, BloomPageGetMaxOffset, BloomPageGetTuple, BloomPageIsDeleted, BUFFER_LOCK_SHARE, BufferGetPage(), CHECK_FOR_INTERRUPTS, BlockRangeReadStreamPrivate::current_blocknum, fb(), FreeAccessStrategy(), GetAccessStrategy(), BloomTuple::heapPtr, i, IndexScanDescData::indexRelation, IndexScanDescData::instrument, InvalidBuffer, IndexScanDescData::keyData, BlockRangeReadStreamPrivate::last_exclusive, LockBuffer(), MAIN_FORKNUM, IndexScanInstrumentation::nsearches, IndexScanDescData::numberOfKeys, IndexScanDescData::opaque, PageIsNew(), palloc0_array, pfree(), pgstat_count_index_scan, read_stream_begin_relation(), read_stream_end(), READ_STREAM_FULL, read_stream_next_buffer(), READ_STREAM_USE_BATCHING, RelationGetNumberOfBlocks, BloomTuple::sign, signValue(), SK_ISNULL, tbm_add_tuples(), and UnlockReleaseBuffer().

Referenced by blhandler().

◆ blinsert()

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

extern

Definition at line 175 of file blinsert.c.

{
    BloomState  blstate;
    BloomTuple *itup;
    MemoryContext oldCtx;
    MemoryContext insertCtx;
    BloomMetaPageData *metaData;
    Buffer      buffer,
                metaBuffer;
    Page        page,
                metaPage;
    BlockNumber blkno = InvalidBlockNumber;
    OffsetNumber nStart;
    GenericXLogState *state;
 
    insertCtx = AllocSetContextCreate(CurrentMemoryContext,
                                      "Bloom insert temporary context",
                                      ALLOCSET_DEFAULT_SIZES);
 
    oldCtx = MemoryContextSwitchTo(insertCtx);
 
    initBloomState(&blstate, index);
    itup = BloomFormTuple(&blstate, ht_ctid, values, isnull);
 
    /*
     * At first, try to insert new tuple to the first page in notFullPage
     * array.  If successful, we don't need to modify the meta page.
     */
    metaBuffer = ReadBuffer(index, BLOOM_METAPAGE_BLKNO);
    LockBuffer(metaBuffer, BUFFER_LOCK_SHARE);
    metaData = BloomPageGetMeta(BufferGetPage(metaBuffer));
 
    if (metaData->nEnd > metaData->nStart)
    {
        blkno = metaData->notFullPage[metaData->nStart];
        Assert(blkno != InvalidBlockNumber);
 
        /* Don't hold metabuffer lock while doing insert */
        LockBuffer(metaBuffer, BUFFER_LOCK_UNLOCK);
 
        buffer = ReadBuffer(index, blkno);
        LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 
        state = GenericXLogStart(index);
        page = GenericXLogRegisterBuffer(state, buffer, 0);
 
        /*
         * We might have found a page that was recently deleted by VACUUM.  If
         * so, we can reuse it, but we must reinitialize it.
         */
        if (PageIsNew(page) || BloomPageIsDeleted(page))
            BloomInitPage(page, 0);
 
        if (BloomPageAddItem(&blstate, page, itup))
        {
            /* Success!  Apply the change, clean up, and exit */
            GenericXLogFinish(state);
            UnlockReleaseBuffer(buffer);
            ReleaseBuffer(metaBuffer);
            MemoryContextSwitchTo(oldCtx);
            MemoryContextDelete(insertCtx);
            return false;
        }
 
        /* Didn't fit, must try other pages */
        GenericXLogAbort(state);
        UnlockReleaseBuffer(buffer);
    }
    else
    {
        /* No entries in notFullPage */
        LockBuffer(metaBuffer, BUFFER_LOCK_UNLOCK);
    }
 
    /*
     * Try other pages in notFullPage array.  We will have to change nStart in
     * metapage.  Thus, grab exclusive lock on metapage.
     */
    LockBuffer(metaBuffer, BUFFER_LOCK_EXCLUSIVE);
 
    /* nStart might have changed while we didn't have lock */
    nStart = metaData->nStart;
 
    /* Skip first page if we already tried it above */
    if (nStart < metaData->nEnd &&
        blkno == metaData->notFullPage[nStart])
        nStart++;
 
    /*
     * This loop iterates for each page we try from the notFullPage array, and
     * will also initialize a GenericXLogState for the fallback case of having
     * to allocate a new page.
     */
    for (;;)
    {
        state = GenericXLogStart(index);
 
        /* get modifiable copy of metapage */
        metaPage = GenericXLogRegisterBuffer(state, metaBuffer, 0);
        metaData = BloomPageGetMeta(metaPage);
 
        if (nStart >= metaData->nEnd)
            break;              /* no more entries in notFullPage array */
 
        blkno = metaData->notFullPage[nStart];
        Assert(blkno != InvalidBlockNumber);
 
        buffer = ReadBuffer(index, blkno);
        LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
        page = GenericXLogRegisterBuffer(state, buffer, 0);
 
        /* Basically same logic as above */
        if (PageIsNew(page) || BloomPageIsDeleted(page))
            BloomInitPage(page, 0);
 
        if (BloomPageAddItem(&blstate, page, itup))
        {
            /* Success!  Apply the changes, clean up, and exit */
            metaData->nStart = nStart;
            GenericXLogFinish(state);
            UnlockReleaseBuffer(buffer);
            UnlockReleaseBuffer(metaBuffer);
            MemoryContextSwitchTo(oldCtx);
            MemoryContextDelete(insertCtx);
            return false;
        }
 
        /* Didn't fit, must try other pages */
        GenericXLogAbort(state);
        UnlockReleaseBuffer(buffer);
        nStart++;
    }
 
    /*
     * Didn't find place to insert in notFullPage array.  Allocate new page.
     * (XXX is it good to do this while holding ex-lock on the metapage??)
     */
    buffer = BloomNewBuffer(index);
 
    page = GenericXLogRegisterBuffer(state, buffer, GENERIC_XLOG_FULL_IMAGE);
    BloomInitPage(page, 0);
 
    if (!BloomPageAddItem(&blstate, page, itup))
    {
        /* We shouldn't be here since we're inserting to an empty page */
        elog(ERROR, "could not add new bloom tuple to empty page");
    }
 
    /* Reset notFullPage array to contain just this new page */
    metaData->nStart = 0;
    metaData->nEnd = 1;
    metaData->notFullPage[0] = BufferGetBlockNumber(buffer);
 
    /* Apply the changes, clean up, and exit */
    GenericXLogFinish(state);
 
    UnlockReleaseBuffer(buffer);
    UnlockReleaseBuffer(metaBuffer);
 
    MemoryContextSwitchTo(oldCtx);
    MemoryContextDelete(insertCtx);
 
    return false;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, BLOOM_METAPAGE_BLKNO, BloomFormTuple(), BloomInitPage(), BloomNewBuffer(), BloomPageAddItem(), BloomPageGetMeta, BloomPageIsDeleted, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), CurrentMemoryContext, elog, ERROR, fb(), GENERIC_XLOG_FULL_IMAGE, GenericXLogAbort(), GenericXLogFinish(), GenericXLogRegisterBuffer(), GenericXLogStart(), initBloomState(), InvalidBlockNumber, LockBuffer(), MemoryContextDelete(), MemoryContextSwitchTo(), PageIsNew(), ReadBuffer(), ReleaseBuffer(), UnlockReleaseBuffer(), and values.

Referenced by blhandler().

◆ BloomFillMetapage()

void BloomFillMetapage	(	Relation	index,
		Page	metaPage
	)

extern

Definition at line 420 of file blutils.c.

{
    BloomOptions *opts;
    BloomMetaPageData *metadata;
 
    /*
     * Choose the index's options.  If reloptions have been assigned, use
     * those, otherwise create default options.
     */
    opts = (BloomOptions *) index->rd_options;
    if (!opts)
        opts = makeDefaultBloomOptions();
 
    /*
     * Initialize contents of meta page, including a copy of the options,
     * which are now frozen for the life of the index.
     */
    BloomInitPage(metaPage, BLOOM_META);
    metadata = BloomPageGetMeta(metaPage);
    memset(metadata, 0, sizeof(BloomMetaPageData));
    metadata->magickNumber = BLOOM_MAGICK_NUMBER;
    metadata->opts = *opts;
    ((PageHeader) metaPage)->pd_lower += sizeof(BloomMetaPageData);
 
    /* If this fails, probably FreeBlockNumberArray size calc is wrong: */
    Assert(((PageHeader) metaPage)->pd_lower <= ((PageHeader) metaPage)->pd_upper);
}

References Assert, BLOOM_MAGICK_NUMBER, BLOOM_META, BloomInitPage(), BloomPageGetMeta, fb(), BloomMetaPageData::magickNumber, makeDefaultBloomOptions(), BloomMetaPageData::opts, and opts.

Referenced by BloomInitMetapage().

◆ BloomFormTuple()

BloomTuple * BloomFormTuple	(	BloomState *	state,
		ItemPointer	iptr,
		Datum *	values,
		bool *	isnull
	)

extern

Definition at line 299 of file blutils.c.

{
    int         i;
    BloomTuple *res = (BloomTuple *) palloc0(state->sizeOfBloomTuple);
 
    res->heapPtr = *iptr;
 
    /* Blooming each column */
    for (i = 0; i < state->nColumns; i++)
    {
        /* skip nulls */
        if (isnull[i])
            continue;
 
        signValue(state, res->sign, values[i], i);
    }
 
    return res;
}

References BloomTuple::heapPtr, i, palloc0(), BloomTuple::sign, signValue(), and values.

Referenced by blinsert(), and bloomBuildCallback().

◆ BloomInitMetapage()

void BloomInitMetapage	(	Relation	index,
		ForkNumber	forknum
	)

extern

Definition at line 452 of file blutils.c.

{
    Buffer      metaBuffer;
    Page        metaPage;
    GenericXLogState *state;
 
    /*
     * Make a new page; since it is first page it should be associated with
     * block number 0 (BLOOM_METAPAGE_BLKNO).  No need to hold the extension
     * lock because there cannot be concurrent inserters yet.
     */
    metaBuffer = ReadBufferExtended(index, forknum, P_NEW, RBM_NORMAL, NULL);
    LockBuffer(metaBuffer, BUFFER_LOCK_EXCLUSIVE);
    Assert(BufferGetBlockNumber(metaBuffer) == BLOOM_METAPAGE_BLKNO);
 
    /* Initialize contents of meta page */
    state = GenericXLogStart(index);
    metaPage = GenericXLogRegisterBuffer(state, metaBuffer,
                                         GENERIC_XLOG_FULL_IMAGE);
    BloomFillMetapage(index, metaPage);
    GenericXLogFinish(state);
 
    UnlockReleaseBuffer(metaBuffer);
}

References Assert, BLOOM_METAPAGE_BLKNO, BloomFillMetapage(), BUFFER_LOCK_EXCLUSIVE, BufferGetBlockNumber(), fb(), GENERIC_XLOG_FULL_IMAGE, GenericXLogFinish(), GenericXLogRegisterBuffer(), GenericXLogStart(), LockBuffer(), P_NEW, RBM_NORMAL, ReadBufferExtended(), and UnlockReleaseBuffer().

Referenced by blbuild(), and blbuildempty().

◆ BloomInitPage()

void BloomInitPage	(	Page	page,
		uint16	flags
	)

extern

Definition at line 405 of file blutils.c.

{
    BloomPageOpaque opaque;
 
    PageInit(page, BLCKSZ, sizeof(BloomPageOpaqueData));
 
    opaque = BloomPageGetOpaque(page);
    opaque->flags = flags;
    opaque->bloom_page_id = BLOOM_PAGE_ID;
}

References BloomPageOpaqueData::bloom_page_id, BLOOM_PAGE_ID, BloomPageGetOpaque, fb(), BloomPageOpaqueData::flags, and PageInit().

Referenced by blinsert(), BloomFillMetapage(), and initCachedPage().

◆ BloomNewBuffer()

Buffer BloomNewBuffer ( Relation index )

extern

Definition at line 359 of file blutils.c.

{
    Buffer      buffer;
 
    /* First, try to get a page from FSM */
    for (;;)
    {
        BlockNumber blkno = GetFreeIndexPage(index);
 
        if (blkno == InvalidBlockNumber)
            break;
 
        buffer = ReadBuffer(index, blkno);
 
        /*
         * We have to guard against the possibility that someone else already
         * recycled this page; the buffer may be locked if so.
         */
        if (ConditionalLockBuffer(buffer))
        {
            Page        page = BufferGetPage(buffer);
 
            if (PageIsNew(page))
                return buffer;  /* OK to use, if never initialized */
 
            if (BloomPageIsDeleted(page))
                return buffer;  /* OK to use */
 
            LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
        }
 
        /* Can't use it, so release buffer and try again */
        ReleaseBuffer(buffer);
    }
 
    /* Must extend the file */
    buffer = ExtendBufferedRel(BMR_REL(index), MAIN_FORKNUM, NULL,
                               EB_LOCK_FIRST);
 
    return buffer;
}

References BloomPageIsDeleted, BMR_REL, BUFFER_LOCK_UNLOCK, BufferGetPage(), ConditionalLockBuffer(), EB_LOCK_FIRST, ExtendBufferedRel(), fb(), GetFreeIndexPage(), InvalidBlockNumber, LockBuffer(), MAIN_FORKNUM, PageIsNew(), ReadBuffer(), and ReleaseBuffer().

Referenced by blinsert(), and flushCachedPage().

◆ BloomPageAddItem()

bool BloomPageAddItem	(	BloomState *	state,
		Page	page,
		BloomTuple *	tuple
	)

extern

Definition at line 324 of file blutils.c.

{
    BloomTuple *itup;
    BloomPageOpaque opaque;
    char       *ptr;
 
    /* We shouldn't be pointed to an invalid page */
    Assert(!PageIsNew(page) && !BloomPageIsDeleted(page));
 
    /* Does new tuple fit on the page? */
    if (BloomPageGetFreeSpace(state, page) < state->sizeOfBloomTuple)
        return false;
 
    /* Copy new tuple to the end of page */
    opaque = BloomPageGetOpaque(page);
    itup = BloomPageGetTuple(state, page, opaque->maxoff + 1);
    memcpy(itup, tuple, state->sizeOfBloomTuple);
 
    /* Adjust maxoff and pd_lower */
    opaque->maxoff++;
    ptr = (char *) BloomPageGetTuple(state, page, opaque->maxoff + 1);
    ((PageHeader) page)->pd_lower = ptr - page;
 
    /* Assert we didn't overrun available space */
    Assert(((PageHeader) page)->pd_lower <= ((PageHeader) page)->pd_upper);
 
    return true;
}

References Assert, BloomPageGetFreeSpace, BloomPageGetOpaque, BloomPageGetTuple, BloomPageIsDeleted, fb(), BloomPageOpaqueData::maxoff, and PageIsNew().

Referenced by blinsert(), and bloomBuildCallback().

◆ bloptions()

bytea * bloptions	(	Datum	reloptions,
		bool	validate
	)

extern

Definition at line 481 of file blutils.c.

{
    BloomOptions *rdopts;
 
    /* Parse the user-given reloptions */
    rdopts = (BloomOptions *) build_reloptions(reloptions, validate,
                                               bl_relopt_kind,
                                               sizeof(BloomOptions),
                                               bl_relopt_tab,
                                               lengthof(bl_relopt_tab));
 
    /* Convert signature length from # of bits to # to words, rounding up */
    if (rdopts)
        rdopts->bloomLength = (rdopts->bloomLength + SIGNWORDBITS - 1) / SIGNWORDBITS;
 
    return (bytea *) rdopts;
}

References bl_relopt_kind, bl_relopt_tab, BloomOptions::bloomLength, build_reloptions(), fb(), lengthof, SIGNWORDBITS, and validate().

Referenced by blhandler().

◆ blrescan()

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

extern

Definition at line 47 of file blscan.c.

{
    BloomScanOpaque so = (BloomScanOpaque) scan->opaque;
 
    if (so->sign)
        pfree(so->sign);
    so->sign = NULL;
 
    if (scankey && scan->numberOfKeys > 0)
        memcpy(scan->keyData, scankey, scan->numberOfKeys * sizeof(ScanKeyData));
}

References fb(), IndexScanDescData::keyData, IndexScanDescData::numberOfKeys, IndexScanDescData::opaque, and pfree().

Referenced by blhandler().

◆ blvacuumcleanup()

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

extern

Definition at line 188 of file blvacuum.c.

{
    Relation    index = info->index;
    BlockNumber npages,
                blkno;
    BlockRangeReadStreamPrivate p;
    ReadStream *stream;
 
    if (info->analyze_only)
        return stats;
 
    if (stats == NULL)
        stats = palloc0_object(IndexBulkDeleteResult);
 
    /*
     * Iterate over the pages: insert deleted pages into FSM and collect
     * statistics.
     */
    npages = RelationGetNumberOfBlocks(index);
    stats->num_pages = npages;
    stats->pages_free = 0;
    stats->num_index_tuples = 0;
 
    /* Scan all blocks except the metapage using streaming reads */
    p.current_blocknum = BLOOM_HEAD_BLKNO;
    p.last_exclusive = npages;
 
    /*
     * It is safe to use batchmode as block_range_read_stream_cb takes no
     * locks.
     */
    stream = read_stream_begin_relation(READ_STREAM_MAINTENANCE |
                                        READ_STREAM_FULL |
                                        READ_STREAM_USE_BATCHING,
                                        info->strategy,
                                        index,
                                        MAIN_FORKNUM,
                                        block_range_read_stream_cb,
                                        &p,
                                        0);
 
    for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
    {
        Buffer      buffer;
        Page        page;
 
        vacuum_delay_point(false);
 
        buffer = read_stream_next_buffer(stream, NULL);
        LockBuffer(buffer, BUFFER_LOCK_SHARE);
        page = BufferGetPage(buffer);
 
        if (PageIsNew(page) || BloomPageIsDeleted(page))
        {
            RecordFreeIndexPage(index, blkno);
            stats->pages_free++;
        }
        else
        {
            stats->num_index_tuples += BloomPageGetMaxOffset(page);
        }
 
        UnlockReleaseBuffer(buffer);
    }
 
    Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
    read_stream_end(stream);
 
    IndexFreeSpaceMapVacuum(info->index);
 
    return stats;
}

References IndexVacuumInfo::analyze_only, Assert, block_range_read_stream_cb(), BLOOM_HEAD_BLKNO, BloomPageGetMaxOffset, BloomPageIsDeleted, BUFFER_LOCK_SHARE, BufferGetPage(), BlockRangeReadStreamPrivate::current_blocknum, fb(), IndexVacuumInfo::index, IndexFreeSpaceMapVacuum(), InvalidBuffer, BlockRangeReadStreamPrivate::last_exclusive, LockBuffer(), MAIN_FORKNUM, IndexBulkDeleteResult::num_index_tuples, IndexBulkDeleteResult::num_pages, PageIsNew(), IndexBulkDeleteResult::pages_free, palloc0_object, read_stream_begin_relation(), read_stream_end(), READ_STREAM_FULL, READ_STREAM_MAINTENANCE, read_stream_next_buffer(), READ_STREAM_USE_BATCHING, RecordFreeIndexPage(), RelationGetNumberOfBlocks, IndexVacuumInfo::strategy, UnlockReleaseBuffer(), and vacuum_delay_point().

Referenced by blhandler().

◆ blvalidate()

bool blvalidate ( Oid opclassoid )

extern

Definition at line 30 of file blvalidate.c.

{
    bool        result = true;
    HeapTuple   classtup;
    Form_pg_opclass classform;
    Oid         opfamilyoid;
    Oid         opcintype;
    Oid         opckeytype;
    char       *opclassname;
    char       *opfamilyname;
    CatCList   *proclist,
               *oprlist;
    List       *grouplist;
    OpFamilyOpFuncGroup *opclassgroup;
    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;
    opckeytype = classform->opckeytype;
    if (!OidIsValid(opckeytype))
        opckeytype = 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;
 
        /*
         * All bloom support functions should be registered with matching
         * left/right types
         */
        if (procform->amproclefttype != procform->amprocrighttype)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("bloom opfamily %s contains support procedure %s with cross-type registration",
                            opfamilyname,
                            format_procedure(procform->amproc))));
            result = false;
        }
 
        /*
         * We can't check signatures except within the specific opclass, since
         * we need to know the associated opckeytype in many cases.
         */
        if (procform->amproclefttype != opcintype)
            continue;
 
        /* Check procedure numbers and function signatures */
        switch (procform->amprocnum)
        {
            case BLOOM_HASH_PROC:
                ok = check_amproc_signature(procform->amproc, INT4OID, false,
                                            1, 1, opckeytype);
                break;
            case BLOOM_OPTIONS_PROC:
                ok = check_amoptsproc_signature(procform->amproc);
                break;
            default:
                ereport(INFO,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("bloom opfamily %s contains function %s with invalid support number %d",
                                opfamilyname,
                                format_procedure(procform->amproc),
                                procform->amprocnum)));
                result = false;
                continue;       /* don't want additional message */
        }
 
        if (!ok)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("bloom opfamily %s contains function %s with wrong signature for support number %d",
                            opfamilyname,
                            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 it's allowed strategy for bloom */
        if (oprform->amopstrategy < 1 ||
            oprform->amopstrategy > BLOOM_NSTRATEGIES)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("bloom opfamily %s contains operator %s with invalid strategy number %d",
                            opfamilyname,
                            format_operator(oprform->amopopr),
                            oprform->amopstrategy)));
            result = false;
        }
 
        /* bloom doesn't support ORDER BY operators */
        if (oprform->amoppurpose != AMOP_SEARCH ||
            OidIsValid(oprform->amopsortfamily))
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("bloom opfamily %s contains invalid ORDER BY specification for operator %s",
                            opfamilyname,
                            format_operator(oprform->amopopr))));
            result = false;
        }
 
        /* Check operator signature --- same for all bloom strategies */
        if (!check_amop_signature(oprform->amopopr, BOOLOID,
                                  oprform->amoplefttype,
                                  oprform->amoprighttype))
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("bloom opfamily %s contains operator %s with wrong signature",
                            opfamilyname,
                            format_operator(oprform->amopopr))));
            result = false;
        }
    }
 
    /* Now check for inconsistent groups of operators/functions */
    grouplist = identify_opfamily_groups(oprlist, proclist);
    opclassgroup = NULL;
    foreach(lc, grouplist)
    {
        OpFamilyOpFuncGroup *thisgroup = (OpFamilyOpFuncGroup *) lfirst(lc);
 
        /* Remember the group exactly matching the test opclass */
        if (thisgroup->lefttype == opcintype &&
            thisgroup->righttype == opcintype)
            opclassgroup = thisgroup;
 
        /*
         * There is not a lot we can do to check the operator sets, since each
         * bloom opclass is more or less a law unto itself, and some contain
         * only operators that are binary-compatible with the opclass datatype
         * (meaning that empty operator sets can be OK).  That case also means
         * that we shouldn't insist on nonempty function sets except for the
         * opclass's own group.
         */
    }
 
    /* Check that the originally-named opclass is complete */
    for (i = 1; i <= BLOOM_NPROC; i++)
    {
        if (opclassgroup &&
            (opclassgroup->functionset & (((uint64) 1) << i)) != 0)
            continue;           /* got it */
        if (i == BLOOM_OPTIONS_PROC)
            continue;           /* optional method */
        ereport(INFO,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("bloom opclass %s is missing support function %d",
                        opclassname, i)));
        result = false;
    }
 
    ReleaseCatCacheList(proclist);
    ReleaseCatCacheList(oprlist);
    ReleaseSysCache(classtup);
 
    return result;
}

References BLOOM_HASH_PROC, BLOOM_NPROC, BLOOM_NSTRATEGIES, BLOOM_OPTIONS_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(), get_opfamily_name(), GETSTRUCT(), HeapTupleIsValid, i, identify_opfamily_groups(), INFO, lfirst, NameStr, ObjectIdGetDatum(), OidIsValid, ReleaseCatCacheList(), ReleaseSysCache(), SearchSysCache1(), and SearchSysCacheList1.

Referenced by blhandler().

◆ initBloomState()

void initBloomState	(	BloomState *	state,
		Relation	index
	)

extern

Definition at line 167 of file blutils.c.

{
    int         i;
 
    state->nColumns = index->rd_att->natts;
 
    /* Initialize hash function for each attribute */
    for (i = 0; i < index->rd_att->natts; i++)
    {
        fmgr_info_copy(&(state->hashFn[i]),
                       index_getprocinfo(index, i + 1, BLOOM_HASH_PROC),
                       CurrentMemoryContext);
        state->collations[i] = index->rd_indcollation[i];
    }
 
    /* Initialize amcache if needed with options from metapage */
    if (!index->rd_amcache)
    {
        Buffer      buffer;
        Page        page;
        BloomMetaPageData *meta;
        BloomOptions *opts;
 
        opts = MemoryContextAlloc(index->rd_indexcxt, sizeof(BloomOptions));
 
        buffer = ReadBuffer(index, BLOOM_METAPAGE_BLKNO);
        LockBuffer(buffer, BUFFER_LOCK_SHARE);
 
        page = BufferGetPage(buffer);
 
        if (!BloomPageIsMeta(page))
            elog(ERROR, "Relation is not a bloom index");
        meta = BloomPageGetMeta(BufferGetPage(buffer));
 
        if (meta->magickNumber != BLOOM_MAGICK_NUMBER)
            elog(ERROR, "Relation is not a bloom index");
 
        *opts = meta->opts;
 
        UnlockReleaseBuffer(buffer);
 
        index->rd_amcache = opts;
    }
 
    memcpy(&state->opts, index->rd_amcache, sizeof(state->opts));
    state->sizeOfBloomTuple = BLOOMTUPLEHDRSZ +
        sizeof(BloomSignatureWord) * state->opts.bloomLength;
}

References BLOOM_HASH_PROC, BLOOM_MAGICK_NUMBER, BLOOM_METAPAGE_BLKNO, BloomPageGetMeta, BloomPageIsMeta, BLOOMTUPLEHDRSZ, BUFFER_LOCK_SHARE, BufferGetPage(), CurrentMemoryContext, elog, ERROR, fb(), fmgr_info_copy(), i, index_getprocinfo(), LockBuffer(), BloomMetaPageData::magickNumber, MemoryContextAlloc(), BloomMetaPageData::opts, opts, ReadBuffer(), and UnlockReleaseBuffer().

Referenced by blbeginscan(), blbuild(), blbulkdelete(), and blinsert().

◆ signValue()

void signValue	(	BloomState *	state,
		BloomSignatureWord *	sign,
		Datum	value,
		int	attno
	)

extern

Definition at line 266 of file blutils.c.

{
    uint32      hashVal;
    int         nBit,
                j;
 
    /*
     * init generator with "column's" number to get "hashed" seed for new
     * value. We don't want to map the same numbers from different columns
     * into the same bits!
     */
    mySrand(attno);
 
    /*
     * Init hash sequence to map our value into bits. the same values in
     * different columns will be mapped into different bits because of step
     * above
     */
    hashVal = DatumGetInt32(FunctionCall1Coll(&state->hashFn[attno], state->collations[attno], value));
    mySrand(hashVal ^ myRand());
 
    for (j = 0; j < state->opts.bitSize[attno]; j++)
    {
        /* prevent multiple evaluation in SETBIT macro */
        nBit = myRand() % (state->opts.bloomLength * SIGNWORDBITS);
        SETBIT(sign, nBit);
    }
}

References DatumGetInt32(), fb(), FunctionCall1Coll(), j, myRand(), mySrand(), SETBIT, sign, SIGNWORDBITS, and value.

Referenced by blgetbitmap(), and BloomFormTuple().

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ BLOOM_DELETED

◆ BLOOM_EQUAL_STRATEGY

◆ BLOOM_HASH_PROC

◆ BLOOM_HEAD_BLKNO

◆ BLOOM_MAGICK_NUMBER

◆ BLOOM_META

◆ BLOOM_METAPAGE_BLKNO

◆ BLOOM_NPROC

◆ BLOOM_NSTRATEGIES

◆ BLOOM_OPTIONS_PROC

◆ BLOOM_PAGE_ID

◆ BloomMetaBlockN

◆ BloomPageGetData

◆ BloomPageGetFreeSpace

◆ BloomPageGetMaxOffset

◆ BloomPageGetMeta

◆ BloomPageGetNextTuple

◆ BloomPageGetOpaque

◆ BloomPageGetTuple

◆ BloomPageIsDeleted

◆ BloomPageIsMeta

◆ BloomPageSetDeleted

◆ BloomPageSetNonDeleted

◆ BLOOMTUPLEHDRSZ

◆ DEFAULT_BLOOM_BITS

◆ DEFAULT_BLOOM_LENGTH

◆ MAX_BLOOM_BITS

◆ MAX_BLOOM_LENGTH

◆ SIGNWORDBITS

Typedef Documentation

◆ BloomMetaPageData

◆ BloomOptions

◆ BloomPageOpaque

◆ BloomPageOpaqueData

◆ BloomScanOpaque

◆ BloomScanOpaqueData

◆ BloomSignatureWord

◆ BloomState

◆ BloomTuple

◆ FreeBlockNumberArray

Function Documentation

◆ blbeginscan()

◆ blbuild()

◆ blbuildempty()

◆ blbulkdelete()

◆ blcostestimate()

◆ blendscan()

◆ blgetbitmap()

◆ blinsert()

◆ BloomFillMetapage()

◆ BloomFormTuple()

◆ BloomInitMetapage()

◆ BloomInitPage()

◆ BloomNewBuffer()

◆ BloomPageAddItem()

◆ bloptions()

◆ blrescan()

◆ blvacuumcleanup()

◆ blvalidate()

◆ initBloomState()

◆ signValue()