blinsert.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "access/generic_xlog.h"
#include "access/tableam.h"
#include "bloom.h"
#include "miscadmin.h"
#include "nodes/execnodes.h"
#include "storage/bufmgr.h"
#include "utils/memutils.h"
#include "utils/rel.h"

Include dependency graph for blinsert.c:

Go to the source code of this file.

Data Structures
struct	BloomBuildState

Functions
	PG_MODULE_MAGIC_EXT (.name="bloom",.version=PG_VERSION)
static void	flushCachedPage (Relation index, BloomBuildState *buildstate)
static void	initCachedPage (BloomBuildState *buildstate)
static void	bloomBuildCallback (Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *state)
IndexBuildResult *	blbuild (Relation heap, Relation index, IndexInfo *indexInfo)
void	blbuildempty (Relation index)
bool	blinsert (Relation index, Datum *values, bool *isnull, ItemPointer ht_ctid, Relation heapRel, IndexUniqueCheck checkUnique, bool indexUnchanged, IndexInfo *indexInfo)

Function Documentation

blbuild()

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

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 = (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 165 of file blinsert.c.

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

References BloomInitMetapage(), and INIT_FORKNUM.

Referenced by blhandler().

blinsert()

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

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, 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().

bloomBuildCallback()

static void bloomBuildCallback ( Relation  index, ItemPointer  tid, Datum *  values, bool *  isnull, bool  tupleIsAlive, void *  state  )

static

Definition at line 75 of file blinsert.c.

{
    BloomBuildState *buildstate = (BloomBuildState *) state;
    MemoryContext oldCtx;
    BloomTuple *itup;
 
    oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);
 
    itup = BloomFormTuple(&buildstate->blstate, tid, values, isnull);
 
    /* Try to add next item to cached page */
    if (BloomPageAddItem(&buildstate->blstate, buildstate->data.data, itup))
    {
        /* Next item was added successfully */
        buildstate->count++;
    }
    else
    {
        /* Cached page is full, flush it out and make a new one */
        flushCachedPage(index, buildstate);
 
        CHECK_FOR_INTERRUPTS();
 
        initCachedPage(buildstate);
 
        if (!BloomPageAddItem(&buildstate->blstate, buildstate->data.data, itup))
        {
            /* We shouldn't be here since we're inserting to the empty page */
            elog(ERROR, "could not add new bloom tuple to empty page");
        }
 
        /* Next item was added successfully */
        buildstate->count++;
    }
 
    /* Update total tuple count */
    buildstate->indtuples += 1;
 
    MemoryContextSwitchTo(oldCtx);
    MemoryContextReset(buildstate->tmpCtx);
}

References BloomFormTuple(), BloomPageAddItem(), BloomBuildState::blstate, CHECK_FOR_INTERRUPTS, BloomBuildState::count, BloomBuildState::data, PGAlignedBlock::data, elog, ERROR, flushCachedPage(), BloomBuildState::indtuples, initCachedPage(), MemoryContextReset(), MemoryContextSwitchTo(), BloomBuildState::tmpCtx, and values.

Referenced by blbuild().

flushCachedPage()

static void flushCachedPage ( Relation  index, BloomBuildState *  buildstate  )

static

Definition at line 48 of file blinsert.c.

{
    Page        page;
    Buffer      buffer = BloomNewBuffer(index);
    GenericXLogState *state;
 
    state = GenericXLogStart(index);
    page = GenericXLogRegisterBuffer(state, buffer, GENERIC_XLOG_FULL_IMAGE);
    memcpy(page, buildstate->data.data, BLCKSZ);
    GenericXLogFinish(state);
    UnlockReleaseBuffer(buffer);
}

References BloomNewBuffer(), BloomBuildState::data, PGAlignedBlock::data, GENERIC_XLOG_FULL_IMAGE, GenericXLogFinish(), GenericXLogRegisterBuffer(), GenericXLogStart(), and UnlockReleaseBuffer().

Referenced by blbuild(), and bloomBuildCallback().

initCachedPage()

static void initCachedPage ( BloomBuildState *  buildstate )

static

Definition at line 65 of file blinsert.c.

{
    BloomInitPage(buildstate->data.data, 0);
    buildstate->count = 0;
}

References BloomInitPage(), BloomBuildState::count, BloomBuildState::data, and PGAlignedBlock::data.

Referenced by blbuild(), and bloomBuildCallback().

PG_MODULE_MAGIC_EXT()

PG_MODULE_MAGIC_EXT	(	.	name = "bloom",
		.	version = PG_VERSION
	)