bloom.h File Reference

#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 *)((Pointer)(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 131 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 134 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 152 of file bloom.h.

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 136 of file bloom.h.

BloomPageGetNextTuple

#define BloomPageGetNextTuple	(		state,
			tuple
	)		((BloomTuple *)((Pointer)(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)))

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 166 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 175 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
	)

Definition at line 28 of file blscan.c.

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

References IndexScanDescData::indexRelation, initBloomState(), IndexScanDescData::opaque, palloc(), RelationGetIndexScan(), BloomScanOpaqueData::sign, and BloomScanOpaqueData::state.

Referenced by blhandler().

blbuild()

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

Definition at line 121 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, (void *) &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 = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
    result->heap_tuples = reltuples;
    result->index_tuples = buildstate.indtuples;
 
    return result;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, bloomBuildCallback(), BloomInitMetapage(), BloomBuildState::blstate, BloomBuildState::count, CurrentMemoryContext, elog, ERROR, flushCachedPage(), IndexBuildResult::heap_tuples, IndexBuildResult::index_tuples, BloomBuildState::indtuples, initBloomState(), initCachedPage(), MAIN_FORKNUM, MemoryContextDelete(), palloc(), RelationGetNumberOfBlocks, RelationGetRelationName, table_index_build_scan(), and BloomBuildState::tmpCtx.

Referenced by blhandler().

blbuildempty()

void blbuildempty

(

Relation

index

)

Definition at line 164 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
	)

Definition at line 34 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;
 
    if (stats == NULL)
        stats = (IndexBulkDeleteResult *) palloc0(sizeof(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);
    for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
    {
        BloomTuple *itup,
                   *itupPtr,
                   *itupEnd;
 
        vacuum_delay_point();
 
        buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
                                    RBM_NORMAL, info->strategy);
 
        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((Pointer) itupPtr, (Pointer) 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 = (Pointer) itupPtr - page;
            /* Finish WAL-logging */
            GenericXLogFinish(gxlogState);
        }
        else
        {
            /* Didn't change anything: abort WAL-logging */
            GenericXLogAbort(gxlogState);
        }
        UnlockReleaseBuffer(buffer);
    }
 
    /*
     * 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, BLOOM_HEAD_BLKNO, BLOOM_METAPAGE_BLKNO, BloomMetaBlockN, BloomPageGetFreeSpace, BloomPageGetMaxOffset, BloomPageGetMeta, BloomPageGetNextTuple, BloomPageGetOpaque, BloomPageGetTuple, BloomPageIsDeleted, BloomPageSetDeleted, BUFFER_LOCK_EXCLUSIVE, callback(), FirstOffsetNumber, GenericXLogAbort(), GenericXLogFinish(), GenericXLogRegisterBuffer(), GenericXLogStart(), BloomTuple::heapPtr, IndexVacuumInfo::index, initBloomState(), LockBuffer(), MAIN_FORKNUM, BloomMetaPageData::nEnd, BloomMetaPageData::notFullPage, BloomMetaPageData::nStart, OffsetNumberNext, PageIsNew(), palloc0(), RBM_NORMAL, ReadBuffer(), ReadBufferExtended(), 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
	)

Definition at line 23 of file blcost.c.

{
    IndexOptInfo *index = path->indexinfo;
    GenericCosts costs = {0};
 
    /* We have to visit all index tuples anyway */
    costs.numIndexTuples = index->tuples;
 
    /* 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 genericcostestimate(), GenericCosts::indexCorrelation, IndexPath::indexinfo, GenericCosts::indexSelectivity, GenericCosts::indexStartupCost, GenericCosts::indexTotalCost, GenericCosts::numIndexPages, GenericCosts::numIndexTuples, and root.

Referenced by blhandler().

blendscan()

void blendscan

(

IndexScanDesc

scan

)

Definition at line 68 of file blscan.c.

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

References if(), IndexScanDescData::opaque, pfree(), and BloomScanOpaqueData::sign.

Referenced by blhandler().

blgetbitmap()

int64 blgetbitmap	(	IndexScanDesc	scan,
		TIDBitmap *	tbm
	)

Definition at line 81 of file blscan.c.

{
    int64       ntids = 0;
    BlockNumber blkno = BLOOM_HEAD_BLKNO,
                npages;
    int         i;
    BufferAccessStrategy bas;
    BloomScanOpaque so = (BloomScanOpaque) scan->opaque;
 
    if (so->sign == NULL)
    {
        /* New search: have to calculate search signature */
        ScanKey     skey = scan->keyData;
 
        so->sign = palloc0(sizeof(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);
 
    for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
    {
        Buffer      buffer;
        Page        page;
 
        buffer = ReadBufferExtended(scan->indexRelation, MAIN_FORKNUM,
                                    blkno, RBM_NORMAL, bas);
 
        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();
    }
    FreeAccessStrategy(bas);
 
    return ntids;
}

References BAS_BULKREAD, BLOOM_HEAD_BLKNO, BloomOptions::bloomLength, BloomPageGetMaxOffset, BloomPageGetTuple, BloomPageIsDeleted, BUFFER_LOCK_SHARE, BufferGetPage(), CHECK_FOR_INTERRUPTS, FreeAccessStrategy(), GetAccessStrategy(), BloomTuple::heapPtr, i, if(), IndexScanDescData::indexRelation, IndexScanDescData::keyData, LockBuffer(), MAIN_FORKNUM, IndexScanDescData::numberOfKeys, IndexScanDescData::opaque, BloomState::opts, PageIsNew(), palloc0(), pfree(), RBM_NORMAL, ReadBufferExtended(), RelationGetNumberOfBlocks, res, BloomTuple::sign, BloomScanOpaqueData::sign, signValue(), ScanKeyData::sk_argument, ScanKeyData::sk_attno, ScanKeyData::sk_flags, SK_ISNULL, BloomScanOpaqueData::state, 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
	)

Definition at line 174 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, GENERIC_XLOG_FULL_IMAGE, GenericXLogAbort(), GenericXLogFinish(), GenericXLogRegisterBuffer(), GenericXLogStart(), initBloomState(), InvalidBlockNumber, LockBuffer(), MemoryContextDelete(), MemoryContextSwitchTo(), BloomMetaPageData::nEnd, BloomMetaPageData::notFullPage, BloomMetaPageData::nStart, PageIsNew(), ReadBuffer(), ReleaseBuffer(), UnlockReleaseBuffer(), and values.

Referenced by blhandler().

BloomFillMetapage()

void BloomFillMetapage	(	Relation	index,
		Page	metaPage
	)

Definition at line 416 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, if(), BloomMetaPageData::magickNumber, makeDefaultBloomOptions(), BloomMetaPageData::opts, and opts.

Referenced by BloomInitMetapage().

BloomFormTuple()

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

Definition at line 295 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 i, palloc0(), res, signValue(), and values.

Referenced by blinsert(), and bloomBuildCallback().

BloomInitMetapage()

void BloomInitMetapage	(	Relation	index,
		ForkNumber	forknum
	)

Definition at line 448 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(), 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
	)

Definition at line 401 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, BloomPageOpaqueData::flags, and PageInit().

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

BloomNewBuffer()

Buffer BloomNewBuffer

(

Relation

index

)

Definition at line 355 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(), GetFreeIndexPage(), InvalidBlockNumber, LockBuffer(), MAIN_FORKNUM, PageIsNew(), ReadBuffer(), and ReleaseBuffer().

Referenced by blinsert(), and flushCachedPage().

BloomPageAddItem()

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

Definition at line 320 of file blutils.c.

{
    BloomTuple *itup;
    BloomPageOpaque opaque;
    Pointer     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((Pointer) itup, (Pointer) tuple, state->sizeOfBloomTuple);
 
    /* Adjust maxoff and pd_lower */
    opaque->maxoff++;
    ptr = (Pointer) 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, BloomPageOpaqueData::maxoff, and PageIsNew().

Referenced by blinsert(), and bloomBuildCallback().

bloptions()

bytea* bloptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 477 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(), lengthof, and SIGNWORDBITS.

Referenced by blhandler().

blrescan()

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

Definition at line 48 of file blscan.c.

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

References if(), IndexScanDescData::keyData, IndexScanDescData::numberOfKeys, IndexScanDescData::opaque, pfree(), and BloomScanOpaqueData::sign.

Referenced by blhandler().

blvacuumcleanup()

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

Definition at line 169 of file blvacuum.c.

{
    Relation    index = info->index;
    BlockNumber npages,
                blkno;
 
    if (info->analyze_only)
        return stats;
 
    if (stats == NULL)
        stats = (IndexBulkDeleteResult *) palloc0(sizeof(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;
    for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
    {
        Buffer      buffer;
        Page        page;
 
        vacuum_delay_point();
 
        buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
                                    RBM_NORMAL, info->strategy);
        LockBuffer(buffer, BUFFER_LOCK_SHARE);
        page = (Page) BufferGetPage(buffer);
 
        if (PageIsNew(page) || BloomPageIsDeleted(page))
        {
            RecordFreeIndexPage(index, blkno);
            stats->pages_free++;
        }
        else
        {
            stats->num_index_tuples += BloomPageGetMaxOffset(page);
        }
 
        UnlockReleaseBuffer(buffer);
    }
 
    IndexFreeSpaceMapVacuum(info->index);
 
    return stats;
}

References IndexVacuumInfo::analyze_only, BLOOM_HEAD_BLKNO, BloomPageGetMaxOffset, BloomPageIsDeleted, BUFFER_LOCK_SHARE, BufferGetPage(), IndexVacuumInfo::index, IndexFreeSpaceMapVacuum(), LockBuffer(), MAIN_FORKNUM, IndexBulkDeleteResult::num_index_tuples, IndexBulkDeleteResult::num_pages, PageIsNew(), IndexBulkDeleteResult::pages_free, palloc0(), RBM_NORMAL, ReadBufferExtended(), RecordFreeIndexPage(), RelationGetNumberOfBlocks, IndexVacuumInfo::strategy, UnlockReleaseBuffer(), and vacuum_delay_point().

Referenced by blhandler().

blvalidate()

bool blvalidate

(

Oid

opclassoid

)

Definition at line 32 of file blvalidate.c.

{
    bool        result = true;
    HeapTuple   classtup;
    Form_pg_opclass classform;
    Oid         opfamilyoid;
    Oid         opcintype;
    Oid         opckeytype;
    char       *opclassname;
    HeapTuple   familytup;
    Form_pg_opfamily familyform;
    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 */
    familytup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfamilyoid));
    if (!HeapTupleIsValid(familytup))
        elog(ERROR, "cache lookup failed for operator family %u", opfamilyoid);
    familyform = (Form_pg_opfamily) GETSTRUCT(familytup);
 
    opfamilyname = NameStr(familyform->opfname);
 
    /* 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("gist 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(familytup);
    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, format_operator(), format_procedure(), OpFamilyOpFuncGroup::functionset, GETSTRUCT, HeapTupleIsValid, i, identify_opfamily_groups(), INFO, OpFamilyOpFuncGroup::lefttype, lfirst, catclist::members, catclist::n_members, NameStr, ObjectIdGetDatum(), OidIsValid, ReleaseCatCacheList(), ReleaseSysCache(), OpFamilyOpFuncGroup::righttype, SearchSysCache1(), SearchSysCacheList1, and catctup::tuple.

Referenced by blhandler().

initBloomState()

void initBloomState	(	BloomState *	state,
		Relation	index
	)

Definition at line 163 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 = (void *) 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, 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
	)

Definition at line 262 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(), FunctionCall1Coll(), j, myRand(), mySrand(), SETBIT, sign, SIGNWORDBITS, and value.

Referenced by blgetbitmap(), and BloomFormTuple().