ginbulk.c File Reference

#include "postgres.h"
#include <limits.h>
#include "access/gin_private.h"
#include "utils/datum.h"
#include "utils/memutils.h"

Include dependency graph for ginbulk.c:

Go to the source code of this file.

Macros
#define	DEF_NENTRY   2048 /* GinEntryAccumulator allocation quantum */
#define	DEF_NPTR   5 /* ItemPointer initial allocation quantum */

Functions
static void	ginCombineData (RBTNode *existing, const RBTNode *newdata, void *arg)
static int	cmpEntryAccumulator (const RBTNode *a, const RBTNode *b, void *arg)
static RBTNode *	ginAllocEntryAccumulator (void *arg)
void	ginInitBA (BuildAccumulator *accum)
static Datum	getDatumCopy (BuildAccumulator *accum, OffsetNumber attnum, Datum value)
static void	ginInsertBAEntry (BuildAccumulator *accum, ItemPointer heapptr, OffsetNumber attnum, Datum key, GinNullCategory category)
void	ginInsertBAEntries (BuildAccumulator *accum, ItemPointer heapptr, OffsetNumber attnum, Datum *entries, GinNullCategory *categories, int32 nentries)
static int	qsortCompareItemPointers (const void *a, const void *b)
void	ginBeginBAScan (BuildAccumulator *accum)
ItemPointerData *	ginGetBAEntry (BuildAccumulator *accum, OffsetNumber *attnum, Datum *key, GinNullCategory *category, uint32 *n)

Macro Definition Documentation

DEF_NENTRY

#define DEF_NENTRY   2048 /* GinEntryAccumulator allocation quantum */

Definition at line 24 of file ginbulk.c.

DEF_NPTR

#define DEF_NPTR   5 /* ItemPointer initial allocation quantum */

Definition at line 25 of file ginbulk.c.

Function Documentation

cmpEntryAccumulator()

static int cmpEntryAccumulator ( const RBTNode *  a, const RBTNode *  b, void *  arg  )

static

Definition at line 72 of file ginbulk.c.

{
    const GinEntryAccumulator *ea = (const GinEntryAccumulator *) a;
    const GinEntryAccumulator *eb = (const GinEntryAccumulator *) b;
    BuildAccumulator *accum = (BuildAccumulator *) arg;
 
    return ginCompareAttEntries(accum->ginstate,
                                ea->attnum, ea->key, ea->category,
                                eb->attnum, eb->key, eb->category);
}

References a, arg, GinEntryAccumulator::attnum, b, GinEntryAccumulator::category, ginCompareAttEntries(), BuildAccumulator::ginstate, and GinEntryAccumulator::key.

Referenced by ginInitBA().

getDatumCopy()

static Datum getDatumCopy ( BuildAccumulator *  accum, OffsetNumber  attnum, Datum  value  )

static

Definition at line 128 of file ginbulk.c.

{
    CompactAttribute *att;
    Datum       res;
 
    att = TupleDescCompactAttr(accum->ginstate->origTupdesc, attnum - 1);
    if (att->attbyval)
        res = value;
    else
    {
        res = datumCopy(value, false, att->attlen);
        accum->allocatedMemory += GetMemoryChunkSpace(DatumGetPointer(res));
    }
    return res;
}

References BuildAccumulator::allocatedMemory, CompactAttribute::attbyval, CompactAttribute::attlen, attnum, datumCopy(), DatumGetPointer(), GetMemoryChunkSpace(), BuildAccumulator::ginstate, GinState::origTupdesc, TupleDescCompactAttr(), and value.

Referenced by ginInsertBAEntry().

ginAllocEntryAccumulator()

static RBTNode * ginAllocEntryAccumulator ( void *  arg )

static

Definition at line 85 of file ginbulk.c.

{
    BuildAccumulator *accum = (BuildAccumulator *) arg;
    GinEntryAccumulator *ea;
 
    /*
     * Allocate memory by rather big chunks to decrease overhead.  We have no
     * need to reclaim RBTNodes individually, so this costs nothing.
     */
    if (accum->entryallocator == NULL || accum->eas_used >= DEF_NENTRY)
    {
        accum->entryallocator = palloc(sizeof(GinEntryAccumulator) * DEF_NENTRY);
        accum->allocatedMemory += GetMemoryChunkSpace(accum->entryallocator);
        accum->eas_used = 0;
    }
 
    /* Allocate new RBTNode from current chunk */
    ea = accum->entryallocator + accum->eas_used;
    accum->eas_used++;
 
    return (RBTNode *) ea;
}

References BuildAccumulator::allocatedMemory, arg, DEF_NENTRY, BuildAccumulator::eas_used, BuildAccumulator::entryallocator, GetMemoryChunkSpace(), and palloc().

Referenced by ginInitBA().

ginBeginBAScan()

void ginBeginBAScan

(

BuildAccumulator *

accum

)

Definition at line 257 of file ginbulk.c.

{
    rbt_begin_iterate(accum->tree, LeftRightWalk, &accum->tree_walk);
}

References LeftRightWalk, rbt_begin_iterate(), BuildAccumulator::tree, and BuildAccumulator::tree_walk.

Referenced by ginbuild(), ginBuildCallback(), ginFlushBuildState(), and ginInsertCleanup().

ginCombineData()

static void ginCombineData ( RBTNode *  existing, const RBTNode *  newdata, void *  arg  )

static

Definition at line 30 of file ginbulk.c.

{
    GinEntryAccumulator *eo = (GinEntryAccumulator *) existing;
    const GinEntryAccumulator *en = (const GinEntryAccumulator *) newdata;
    BuildAccumulator *accum = (BuildAccumulator *) arg;
 
    /*
     * Note this code assumes that newdata contains only one itempointer.
     */
    if (eo->count >= eo->maxcount)
    {
        if (eo->maxcount > INT_MAX)
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("posting list is too long"),
                     errhint("Reduce \"maintenance_work_mem\".")));
 
        accum->allocatedMemory -= GetMemoryChunkSpace(eo->list);
        eo->maxcount *= 2;
        eo->list = (ItemPointerData *)
            repalloc_huge(eo->list, sizeof(ItemPointerData) * eo->maxcount);
        accum->allocatedMemory += GetMemoryChunkSpace(eo->list);
    }
 
    /* If item pointers are not ordered, they will need to be sorted later */
    if (eo->shouldSort == false)
    {
        int         res;
 
        res = ginCompareItemPointers(eo->list + eo->count - 1, en->list);
        Assert(res != 0);
 
        if (res > 0)
            eo->shouldSort = true;
    }
 
    eo->list[eo->count] = en->list[0];
    eo->count++;
}

References BuildAccumulator::allocatedMemory, arg, Assert(), GinEntryAccumulator::count, ereport, errcode(), errhint(), errmsg(), ERROR, GetMemoryChunkSpace(), ginCompareItemPointers(), GinEntryAccumulator::list, GinEntryAccumulator::maxcount, repalloc_huge(), and GinEntryAccumulator::shouldSort.

Referenced by ginInitBA().

ginGetBAEntry()

ItemPointerData * ginGetBAEntry	(	BuildAccumulator *	accum,
		OffsetNumber *	attnum,
		Datum *	key,
		GinNullCategory *	category,
		uint32 *	n
	)

Definition at line 268 of file ginbulk.c.

{
    GinEntryAccumulator *entry;
    ItemPointerData *list;
 
    entry = (GinEntryAccumulator *) rbt_iterate(&accum->tree_walk);
 
    if (entry == NULL)
        return NULL;            /* no more entries */
 
    *attnum = entry->attnum;
    *key = entry->key;
    *category = entry->category;
    list = entry->list;
    *n = entry->count;
 
    Assert(list != NULL && entry->count > 0);
 
    if (entry->shouldSort && entry->count > 1)
        qsort(list, entry->count, sizeof(ItemPointerData),
              qsortCompareItemPointers);
 
    return list;
}

References Assert(), GinEntryAccumulator::attnum, attnum, GinEntryAccumulator::category, GinEntryAccumulator::count, GinEntryAccumulator::key, sort-test::key, GinEntryAccumulator::list, sort-test::list, qsort, qsortCompareItemPointers(), rbt_iterate(), GinEntryAccumulator::shouldSort, and BuildAccumulator::tree_walk.

Referenced by ginbuild(), ginBuildCallback(), ginFlushBuildState(), and ginInsertCleanup().

ginInitBA()

void ginInitBA

(

BuildAccumulator *

accum

)

Definition at line 109 of file ginbulk.c.

{
    /* accum->ginstate is intentionally not set here */
    accum->allocatedMemory = 0;
    accum->entryallocator = NULL;
    accum->eas_used = 0;
    accum->tree = rbt_create(sizeof(GinEntryAccumulator),
                             cmpEntryAccumulator,
                             ginCombineData,
                             ginAllocEntryAccumulator,
                             NULL,  /* no freefunc needed */
                             accum);
}

References BuildAccumulator::allocatedMemory, cmpEntryAccumulator(), BuildAccumulator::eas_used, BuildAccumulator::entryallocator, ginAllocEntryAccumulator(), ginCombineData(), rbt_create(), and BuildAccumulator::tree.

Referenced by _gin_parallel_build_main(), ginbuild(), ginBuildCallback(), ginFlushBuildState(), and ginInsertCleanup().

ginInsertBAEntries()

void ginInsertBAEntries	(	BuildAccumulator *	accum,
		ItemPointer	heapptr,
		OffsetNumber	attnum,
		Datum *	entries,
		GinNullCategory *	categories,
		int32	nentries
	)

Definition at line 210 of file ginbulk.c.

{
    uint32      step = nentries;
 
    if (nentries <= 0)
        return;
 
    Assert(ItemPointerIsValid(heapptr) && attnum >= FirstOffsetNumber);
 
    /*
     * step will contain largest power of 2 and <= nentries
     */
    step |= (step >> 1);
    step |= (step >> 2);
    step |= (step >> 4);
    step |= (step >> 8);
    step |= (step >> 16);
    step >>= 1;
    step++;
 
    while (step > 0)
    {
        int         i;
 
        for (i = step - 1; i < nentries && i >= 0; i += step << 1 /* *2 */ )
            ginInsertBAEntry(accum, heapptr, attnum,
                             entries[i], categories[i]);
 
        step >>= 1;             /* /2 */
    }
}

References Assert(), attnum, FirstOffsetNumber, ginInsertBAEntry(), i, and ItemPointerIsValid().

Referenced by ginHeapTupleBulkInsert(), and processPendingPage().

ginInsertBAEntry()

static void ginInsertBAEntry ( BuildAccumulator *  accum, ItemPointer  heapptr, OffsetNumber  attnum, Datum  key, GinNullCategory  category  )

static

Definition at line 148 of file ginbulk.c.

{
    GinEntryAccumulator eatmp;
    GinEntryAccumulator *ea;
    bool        isNew;
 
    /*
     * For the moment, fill only the fields of eatmp that will be looked at by
     * cmpEntryAccumulator or ginCombineData.
     */
    eatmp.attnum = attnum;
    eatmp.key = key;
    eatmp.category = category;
    /* temporarily set up single-entry itempointer list */
    eatmp.list = heapptr;
 
    ea = (GinEntryAccumulator *) rbt_insert(accum->tree, (RBTNode *) &eatmp,
                                            &isNew);
 
    if (isNew)
    {
        /*
         * Finish initializing new tree entry, including making permanent
         * copies of the datum (if it's not null) and itempointer.
         */
        if (category == GIN_CAT_NORM_KEY)
            ea->key = getDatumCopy(accum, attnum, key);
        ea->maxcount = DEF_NPTR;
        ea->count = 1;
        ea->shouldSort = false;
        ea->list =
            (ItemPointerData *) palloc(sizeof(ItemPointerData) * DEF_NPTR);
        ea->list[0] = *heapptr;
        accum->allocatedMemory += GetMemoryChunkSpace(ea->list);
    }
    else
    {
        /*
         * ginCombineData did everything needed.
         */
    }
}

References BuildAccumulator::allocatedMemory, GinEntryAccumulator::attnum, attnum, GinEntryAccumulator::category, GinEntryAccumulator::count, DEF_NPTR, getDatumCopy(), GetMemoryChunkSpace(), GIN_CAT_NORM_KEY, GinEntryAccumulator::key, sort-test::key, GinEntryAccumulator::list, GinEntryAccumulator::maxcount, palloc(), rbt_insert(), GinEntryAccumulator::shouldSort, and BuildAccumulator::tree.

Referenced by ginInsertBAEntries().

qsortCompareItemPointers()

static int qsortCompareItemPointers ( const void *  a, const void *  b  )

static

Definition at line 246 of file ginbulk.c.

{
    int         res = ginCompareItemPointers((ItemPointer) a, (ItemPointer) b);
 
    /* Assert that there are no equal item pointers being sorted */
    Assert(res != 0);
    return res;
}

References a, Assert(), b, and ginCompareItemPointers().

Referenced by ginGetBAEntry().