gininsert.c File Reference

#include "postgres.h"
#include "access/gin_private.h"
#include "access/gin_tuple.h"
#include "access/parallel.h"
#include "access/table.h"
#include "access/tableam.h"
#include "access/xloginsert.h"
#include "catalog/index.h"
#include "catalog/pg_collation.h"
#include "commands/progress.h"
#include "miscadmin.h"
#include "nodes/execnodes.h"
#include "pgstat.h"
#include "storage/bufmgr.h"
#include "storage/predicate.h"
#include "tcop/tcopprot.h"
#include "utils/datum.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/builtins.h"

Include dependency graph for gininsert.c:

Go to the source code of this file.

Data Structures
struct	GinBuildShared
struct	GinLeader
struct	GinBuildState
struct	GinBuffer
struct	GinSegmentInfo

Macros
#define	PARALLEL_KEY_GIN_SHARED   UINT64CONST(0xB000000000000001)
#define	PARALLEL_KEY_TUPLESORT   UINT64CONST(0xB000000000000002)
#define	PARALLEL_KEY_QUERY_TEXT   UINT64CONST(0xB000000000000003)
#define	PARALLEL_KEY_WAL_USAGE   UINT64CONST(0xB000000000000004)
#define	PARALLEL_KEY_BUFFER_USAGE   UINT64CONST(0xB000000000000005)
#define	ParallelTableScanFromGinBuildShared(shared)    (ParallelTableScanDesc) ((char *) (shared) + BUFFERALIGN(sizeof(GinBuildShared)))

Typedefs
typedef struct GinBuildShared	GinBuildShared
typedef struct GinLeader	GinLeader
typedef struct GinBuffer	GinBuffer

Functions
static void	_gin_begin_parallel (GinBuildState *buildstate, Relation heap, Relation index, bool isconcurrent, int request)
static void	_gin_end_parallel (GinLeader *ginleader, GinBuildState *state)
static Size	_gin_parallel_estimate_shared (Relation heap, Snapshot snapshot)
static double	_gin_parallel_heapscan (GinBuildState *state)
static double	_gin_parallel_merge (GinBuildState *state)
static void	_gin_leader_participate_as_worker (GinBuildState *buildstate, Relation heap, Relation index)
static void	_gin_parallel_scan_and_build (GinBuildState *state, GinBuildShared *ginshared, Sharedsort *sharedsort, Relation heap, Relation index, int sortmem, bool progress)
static ItemPointer	_gin_parse_tuple_items (GinTuple *a)
static Datum	_gin_parse_tuple_key (GinTuple *a)
static GinTuple *	_gin_build_tuple (OffsetNumber attrnum, unsigned char category, Datum key, int16 typlen, bool typbyval, ItemPointerData *items, uint32 nitems, Size *len)
static IndexTuple	addItemPointersToLeafTuple (GinState *ginstate, IndexTuple old, ItemPointerData *items, uint32 nitem, GinStatsData *buildStats, Buffer buffer)
static IndexTuple	buildFreshLeafTuple (GinState *ginstate, OffsetNumber attnum, Datum key, GinNullCategory category, ItemPointerData *items, uint32 nitem, GinStatsData *buildStats, Buffer buffer)
void	ginEntryInsert (GinState *ginstate, OffsetNumber attnum, Datum key, GinNullCategory category, ItemPointerData *items, uint32 nitem, GinStatsData *buildStats)
static void	ginHeapTupleBulkInsert (GinBuildState *buildstate, OffsetNumber attnum, Datum value, bool isNull, ItemPointer heapptr)
static void	ginBuildCallback (Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *state)
static void	ginFlushBuildState (GinBuildState *buildstate, Relation index)
static void	ginBuildCallbackParallel (Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *state)
IndexBuildResult *	ginbuild (Relation heap, Relation index, IndexInfo *indexInfo)
void	ginbuildempty (Relation index)
static void	ginHeapTupleInsert (GinState *ginstate, OffsetNumber attnum, Datum value, bool isNull, ItemPointer item)
bool	gininsert (Relation index, Datum *values, bool *isnull, ItemPointer ht_ctid, Relation heapRel, IndexUniqueCheck checkUnique, bool indexUnchanged, IndexInfo *indexInfo)
static void	AssertCheckItemPointers (GinBuffer *buffer)
static void	AssertCheckGinBuffer (GinBuffer *buffer)
static GinBuffer *	GinBufferInit (Relation index)
static bool	GinBufferIsEmpty (GinBuffer *buffer)
static bool	GinBufferKeyEquals (GinBuffer *buffer, GinTuple *tup)
static bool	GinBufferShouldTrim (GinBuffer *buffer, GinTuple *tup)
static void	GinBufferStoreTuple (GinBuffer *buffer, GinTuple *tup)
static void	GinBufferReset (GinBuffer *buffer)
static void	GinBufferTrim (GinBuffer *buffer)
static void	GinBufferFree (GinBuffer *buffer)
static bool	GinBufferCanAddKey (GinBuffer *buffer, GinTuple *tup)
static void	_gin_process_worker_data (GinBuildState *state, Tuplesortstate *worker_sort, bool progress)
void	_gin_parallel_build_main (dsm_segment *seg, shm_toc *toc)
int	_gin_compare_tuples (GinTuple *a, GinTuple *b, SortSupport ssup)

Macro Definition Documentation

PARALLEL_KEY_BUFFER_USAGE

#define PARALLEL_KEY_BUFFER_USAGE   UINT64CONST(0xB000000000000005)

Definition at line 43 of file gininsert.c.

PARALLEL_KEY_GIN_SHARED

#define PARALLEL_KEY_GIN_SHARED   UINT64CONST(0xB000000000000001)

Definition at line 39 of file gininsert.c.

PARALLEL_KEY_QUERY_TEXT

#define PARALLEL_KEY_QUERY_TEXT   UINT64CONST(0xB000000000000003)

Definition at line 41 of file gininsert.c.

PARALLEL_KEY_TUPLESORT

#define PARALLEL_KEY_TUPLESORT   UINT64CONST(0xB000000000000002)

Definition at line 40 of file gininsert.c.

PARALLEL_KEY_WAL_USAGE

#define PARALLEL_KEY_WAL_USAGE   UINT64CONST(0xB000000000000004)

Definition at line 42 of file gininsert.c.

ParallelTableScanFromGinBuildShared

#define ParallelTableScanFromGinBuildShared

(

shared

)

(ParallelTableScanDesc) ((char *) (shared) + BUFFERALIGN(sizeof(GinBuildShared)))

Definition at line 104 of file gininsert.c.

Typedef Documentation

GinBuffer

typedef struct GinBuffer GinBuffer

GinBuildShared

typedef struct GinBuildShared GinBuildShared

GinLeader

typedef struct GinLeader GinLeader

Function Documentation

_gin_begin_parallel()

static void _gin_begin_parallel ( GinBuildState *  buildstate, Relation  heap, Relation  index, bool  isconcurrent, int  request  )

static

Definition at line 927 of file gininsert.c.

{
    ParallelContext *pcxt;
    int         scantuplesortstates;
    Snapshot    snapshot;
    Size        estginshared;
    Size        estsort;
    GinBuildShared *ginshared;
    Sharedsort *sharedsort;
    GinLeader  *ginleader = (GinLeader *) palloc0(sizeof(GinLeader));
    WalUsage   *walusage;
    BufferUsage *bufferusage;
    bool        leaderparticipates = true;
    int         querylen;
 
#ifdef DISABLE_LEADER_PARTICIPATION
    leaderparticipates = false;
#endif
 
    /*
     * Enter parallel mode, and create context for parallel build of gin index
     */
    EnterParallelMode();
    Assert(request > 0);
    pcxt = CreateParallelContext("postgres", "_gin_parallel_build_main",
                                 request);
 
    scantuplesortstates = leaderparticipates ? request + 1 : request;
 
    /*
     * Prepare for scan of the base relation.  In a normal index build, we use
     * SnapshotAny because we must retrieve all tuples and do our own time
     * qual checks (because we have to index RECENTLY_DEAD tuples).  In a
     * concurrent build, we take a regular MVCC snapshot and index whatever's
     * live according to that.
     */
    if (!isconcurrent)
        snapshot = SnapshotAny;
    else
        snapshot = RegisterSnapshot(GetTransactionSnapshot());
 
    /*
     * Estimate size for our own PARALLEL_KEY_GIN_SHARED workspace.
     */
    estginshared = _gin_parallel_estimate_shared(heap, snapshot);
    shm_toc_estimate_chunk(&pcxt->estimator, estginshared);
    estsort = tuplesort_estimate_shared(scantuplesortstates);
    shm_toc_estimate_chunk(&pcxt->estimator, estsort);
 
    shm_toc_estimate_keys(&pcxt->estimator, 2);
 
    /*
     * Estimate space for WalUsage and BufferUsage -- PARALLEL_KEY_WAL_USAGE
     * and PARALLEL_KEY_BUFFER_USAGE.
     *
     * If there are no extensions loaded that care, we could skip this.  We
     * have no way of knowing whether anyone's looking at pgWalUsage or
     * pgBufferUsage, so do it unconditionally.
     */
    shm_toc_estimate_chunk(&pcxt->estimator,
                           mul_size(sizeof(WalUsage), pcxt->nworkers));
    shm_toc_estimate_keys(&pcxt->estimator, 1);
    shm_toc_estimate_chunk(&pcxt->estimator,
                           mul_size(sizeof(BufferUsage), pcxt->nworkers));
    shm_toc_estimate_keys(&pcxt->estimator, 1);
 
    /* Finally, estimate PARALLEL_KEY_QUERY_TEXT space */
    if (debug_query_string)
    {
        querylen = strlen(debug_query_string);
        shm_toc_estimate_chunk(&pcxt->estimator, querylen + 1);
        shm_toc_estimate_keys(&pcxt->estimator, 1);
    }
    else
        querylen = 0;           /* keep compiler quiet */
 
    /* Everyone's had a chance to ask for space, so now create the DSM */
    InitializeParallelDSM(pcxt);
 
    /* If no DSM segment was available, back out (do serial build) */
    if (pcxt->seg == NULL)
    {
        if (IsMVCCSnapshot(snapshot))
            UnregisterSnapshot(snapshot);
        DestroyParallelContext(pcxt);
        ExitParallelMode();
        return;
    }
 
    /* Store shared build state, for which we reserved space */
    ginshared = (GinBuildShared *) shm_toc_allocate(pcxt->toc, estginshared);
    /* Initialize immutable state */
    ginshared->heaprelid = RelationGetRelid(heap);
    ginshared->indexrelid = RelationGetRelid(index);
    ginshared->isconcurrent = isconcurrent;
    ginshared->scantuplesortstates = scantuplesortstates;
 
    ConditionVariableInit(&ginshared->workersdonecv);
    SpinLockInit(&ginshared->mutex);
 
    /* Initialize mutable state */
    ginshared->nparticipantsdone = 0;
    ginshared->reltuples = 0.0;
    ginshared->indtuples = 0.0;
 
    table_parallelscan_initialize(heap,
                                  ParallelTableScanFromGinBuildShared(ginshared),
                                  snapshot);
 
    /*
     * Store shared tuplesort-private state, for which we reserved space.
     * Then, initialize opaque state using tuplesort routine.
     */
    sharedsort = (Sharedsort *) shm_toc_allocate(pcxt->toc, estsort);
    tuplesort_initialize_shared(sharedsort, scantuplesortstates,
                                pcxt->seg);
 
    shm_toc_insert(pcxt->toc, PARALLEL_KEY_GIN_SHARED, ginshared);
    shm_toc_insert(pcxt->toc, PARALLEL_KEY_TUPLESORT, sharedsort);
 
    /* Store query string for workers */
    if (debug_query_string)
    {
        char       *sharedquery;
 
        sharedquery = (char *) shm_toc_allocate(pcxt->toc, querylen + 1);
        memcpy(sharedquery, debug_query_string, querylen + 1);
        shm_toc_insert(pcxt->toc, PARALLEL_KEY_QUERY_TEXT, sharedquery);
    }
 
    /*
     * Allocate space for each worker's WalUsage and BufferUsage; no need to
     * initialize.
     */
    walusage = shm_toc_allocate(pcxt->toc,
                                mul_size(sizeof(WalUsage), pcxt->nworkers));
    shm_toc_insert(pcxt->toc, PARALLEL_KEY_WAL_USAGE, walusage);
    bufferusage = shm_toc_allocate(pcxt->toc,
                                   mul_size(sizeof(BufferUsage), pcxt->nworkers));
    shm_toc_insert(pcxt->toc, PARALLEL_KEY_BUFFER_USAGE, bufferusage);
 
    /* Launch workers, saving status for leader/caller */
    LaunchParallelWorkers(pcxt);
    ginleader->pcxt = pcxt;
    ginleader->nparticipanttuplesorts = pcxt->nworkers_launched;
    if (leaderparticipates)
        ginleader->nparticipanttuplesorts++;
    ginleader->ginshared = ginshared;
    ginleader->sharedsort = sharedsort;
    ginleader->snapshot = snapshot;
    ginleader->walusage = walusage;
    ginleader->bufferusage = bufferusage;
 
    /* If no workers were successfully launched, back out (do serial build) */
    if (pcxt->nworkers_launched == 0)
    {
        _gin_end_parallel(ginleader, NULL);
        return;
    }
 
    /* Save leader state now that it's clear build will be parallel */
    buildstate->bs_leader = ginleader;
 
    /* Join heap scan ourselves */
    if (leaderparticipates)
        _gin_leader_participate_as_worker(buildstate, heap, index);
 
    /*
     * Caller needs to wait for all launched workers when we return.  Make
     * sure that the failure-to-start case will not hang forever.
     */
    WaitForParallelWorkersToAttach(pcxt);
}

References _gin_end_parallel(), _gin_leader_participate_as_worker(), _gin_parallel_estimate_shared(), Assert(), GinBuildState::bs_leader, GinLeader::bufferusage, ConditionVariableInit(), CreateParallelContext(), debug_query_string, DestroyParallelContext(), EnterParallelMode(), ParallelContext::estimator, ExitParallelMode(), GetTransactionSnapshot(), GinLeader::ginshared, GinBuildShared::heaprelid, GinBuildShared::indexrelid, GinBuildShared::indtuples, InitializeParallelDSM(), GinBuildShared::isconcurrent, IsMVCCSnapshot, LaunchParallelWorkers(), mul_size(), GinBuildShared::mutex, GinBuildShared::nparticipantsdone, GinLeader::nparticipanttuplesorts, ParallelContext::nworkers, ParallelContext::nworkers_launched, palloc0(), PARALLEL_KEY_BUFFER_USAGE, PARALLEL_KEY_GIN_SHARED, PARALLEL_KEY_QUERY_TEXT, PARALLEL_KEY_TUPLESORT, PARALLEL_KEY_WAL_USAGE, ParallelTableScanFromGinBuildShared, GinLeader::pcxt, RegisterSnapshot(), RelationGetRelid, GinBuildShared::reltuples, GinBuildShared::scantuplesortstates, ParallelContext::seg, GinLeader::sharedsort, shm_toc_allocate(), shm_toc_estimate_chunk, shm_toc_estimate_keys, shm_toc_insert(), GinLeader::snapshot, SnapshotAny, SpinLockInit, table_parallelscan_initialize(), ParallelContext::toc, tuplesort_estimate_shared(), tuplesort_initialize_shared(), UnregisterSnapshot(), WaitForParallelWorkersToAttach(), GinLeader::walusage, and GinBuildShared::workersdonecv.

Referenced by ginbuild().

_gin_build_tuple()

static GinTuple * _gin_build_tuple ( OffsetNumber  attrnum, unsigned char  category, Datum  key, int16  typlen, bool  typbyval, ItemPointerData *  items, uint32  nitems, Size *  len  )

static

Definition at line 2231 of file gininsert.c.

{
    GinTuple   *tuple;
    char       *ptr;
 
    Size        tuplen;
    int         keylen;
 
    dlist_mutable_iter iter;
    dlist_head  segments;
    int         ncompressed;
    Size        compresslen;
 
    /*
     * Calculate how long is the key value. Only keys with GIN_CAT_NORM_KEY
     * have actual non-empty key. We include varlena headers and \0 bytes for
     * strings, to make it easier to access the data in-line.
     *
     * For byval types we simply copy the whole Datum. We could store just the
     * necessary bytes, but this is simpler to work with and not worth the
     * extra complexity. Moreover we still need to do the MAXALIGN to allow
     * direct access to items pointers.
     *
     * XXX Note that for byval types we store the whole datum, no matter what
     * the typlen value is.
     */
    if (category != GIN_CAT_NORM_KEY)
        keylen = 0;
    else if (typbyval)
        keylen = sizeof(Datum);
    else if (typlen > 0)
        keylen = typlen;
    else if (typlen == -1)
        keylen = VARSIZE_ANY(DatumGetPointer(key));
    else if (typlen == -2)
        keylen = strlen(DatumGetPointer(key)) + 1;
    else
        elog(ERROR, "unexpected typlen value (%d)", typlen);
 
    /* compress the item pointers */
    ncompressed = 0;
    compresslen = 0;
    dlist_init(&segments);
 
    /* generate compressed segments of TID list chunks */
    while (ncompressed < nitems)
    {
        int         cnt;
        GinSegmentInfo *seginfo = palloc(sizeof(GinSegmentInfo));
 
        seginfo->seg = ginCompressPostingList(&items[ncompressed],
                                              (nitems - ncompressed),
                                              UINT16_MAX,
                                              &cnt);
 
        ncompressed += cnt;
        compresslen += SizeOfGinPostingList(seginfo->seg);
 
        dlist_push_tail(&segments, &seginfo->node);
    }
 
    /*
     * Determine GIN tuple length with all the data included. Be careful about
     * alignment, to allow direct access to compressed segments (those require
     * only SHORTALIGN).
     */
    tuplen = SHORTALIGN(offsetof(GinTuple, data) + keylen) + compresslen;
 
    *len = tuplen;
 
    /*
     * Allocate space for the whole GIN tuple.
     *
     * The palloc0 is needed - writetup_index_gin will write the whole tuple
     * to disk, so we need to make sure the padding bytes are defined
     * (otherwise valgrind would report this).
     */
    tuple = palloc0(tuplen);
 
    tuple->tuplen = tuplen;
    tuple->attrnum = attrnum;
    tuple->category = category;
    tuple->keylen = keylen;
    tuple->nitems = nitems;
 
    /* key type info */
    tuple->typlen = typlen;
    tuple->typbyval = typbyval;
 
    /*
     * Copy the key and items into the tuple. First the key value, which we
     * can simply copy right at the beginning of the data array.
     */
    if (category == GIN_CAT_NORM_KEY)
    {
        if (typbyval)
        {
            memcpy(tuple->data, &key, sizeof(Datum));
        }
        else if (typlen > 0)    /* byref, fixed length */
        {
            memcpy(tuple->data, DatumGetPointer(key), typlen);
        }
        else if (typlen == -1)
        {
            memcpy(tuple->data, DatumGetPointer(key), keylen);
        }
        else if (typlen == -2)
        {
            memcpy(tuple->data, DatumGetPointer(key), keylen);
        }
    }
 
    /* finally, copy the TIDs into the array */
    ptr = (char *) tuple + SHORTALIGN(offsetof(GinTuple, data) + keylen);
 
    /* copy in the compressed data, and free the segments */
    dlist_foreach_modify(iter, &segments)
    {
        GinSegmentInfo *seginfo = dlist_container(GinSegmentInfo, node, iter.cur);
 
        memcpy(ptr, seginfo->seg, SizeOfGinPostingList(seginfo->seg));
 
        ptr += SizeOfGinPostingList(seginfo->seg);
 
        dlist_delete(&seginfo->node);
 
        pfree(seginfo->seg);
        pfree(seginfo);
    }
 
    return tuple;
}

References GinTuple::attrnum, GinTuple::category, dlist_mutable_iter::cur, GinTuple::data, data, DatumGetPointer(), dlist_container, dlist_delete(), dlist_foreach_modify, dlist_init(), dlist_push_tail(), elog, ERROR, GIN_CAT_NORM_KEY, ginCompressPostingList(), items, sort-test::key, GinTuple::keylen, len, GinTuple::nitems, nitems, GinSegmentInfo::node, palloc(), palloc0(), pfree(), GinSegmentInfo::seg, SHORTALIGN, SizeOfGinPostingList, GinTuple::tuplen, GinTuple::typbyval, GinTuple::typlen, and VARSIZE_ANY().

Referenced by _gin_process_worker_data(), and ginFlushBuildState().

_gin_compare_tuples()

int _gin_compare_tuples	(	GinTuple *	a,
		GinTuple *	b,
		SortSupport	ssup
	)

Definition at line 2433 of file gininsert.c.

{
    int         r;
    Datum       keya,
                keyb;
 
    if (a->attrnum < b->attrnum)
        return -1;
 
    if (a->attrnum > b->attrnum)
        return 1;
 
    if (a->category < b->category)
        return -1;
 
    if (a->category > b->category)
        return 1;
 
    if (a->category == GIN_CAT_NORM_KEY)
    {
        keya = _gin_parse_tuple_key(a);
        keyb = _gin_parse_tuple_key(b);
 
        r = ApplySortComparator(keya, false,
                                keyb, false,
                                &ssup[a->attrnum - 1]);
 
        /* if the key is the same, consider the first TID in the array */
        return (r != 0) ? r : ItemPointerCompare(GinTupleGetFirst(a),
                                                 GinTupleGetFirst(b));
    }
 
    return ItemPointerCompare(GinTupleGetFirst(a),
                              GinTupleGetFirst(b));
}

References _gin_parse_tuple_key(), a, ApplySortComparator(), b, GIN_CAT_NORM_KEY, GinTupleGetFirst(), and ItemPointerCompare().

Referenced by comparetup_index_gin().

_gin_end_parallel()

static void _gin_end_parallel ( GinLeader *  ginleader, GinBuildState *  state  )

static

Definition at line 1106 of file gininsert.c.

{
    int         i;
 
    /* Shutdown worker processes */
    WaitForParallelWorkersToFinish(ginleader->pcxt);
 
    /*
     * Next, accumulate WAL usage.  (This must wait for the workers to finish,
     * or we might get incomplete data.)
     */
    for (i = 0; i < ginleader->pcxt->nworkers_launched; i++)
        InstrAccumParallelQuery(&ginleader->bufferusage[i], &ginleader->walusage[i]);
 
    /* Free last reference to MVCC snapshot, if one was used */
    if (IsMVCCSnapshot(ginleader->snapshot))
        UnregisterSnapshot(ginleader->snapshot);
    DestroyParallelContext(ginleader->pcxt);
    ExitParallelMode();
}

References GinLeader::bufferusage, DestroyParallelContext(), ExitParallelMode(), i, InstrAccumParallelQuery(), IsMVCCSnapshot, ParallelContext::nworkers_launched, GinLeader::pcxt, GinLeader::snapshot, UnregisterSnapshot(), WaitForParallelWorkersToFinish(), and GinLeader::walusage.

Referenced by _gin_begin_parallel(), and ginbuild().

_gin_leader_participate_as_worker()

static void _gin_leader_participate_as_worker ( GinBuildState *  buildstate, Relation  heap, Relation  index  )

static

Definition at line 1811 of file gininsert.c.

{
    GinLeader  *ginleader = buildstate->bs_leader;
    int         sortmem;
 
    /*
     * Might as well use reliable figure when doling out maintenance_work_mem
     * (when requested number of workers were not launched, this will be
     * somewhat higher than it is for other workers).
     */
    sortmem = maintenance_work_mem / ginleader->nparticipanttuplesorts;
 
    /* Perform work common to all participants */
    _gin_parallel_scan_and_build(buildstate, ginleader->ginshared,
                                 ginleader->sharedsort, heap, index,
                                 sortmem, true);
}

References _gin_parallel_scan_and_build(), GinBuildState::bs_leader, GinLeader::ginshared, maintenance_work_mem, GinLeader::nparticipanttuplesorts, and GinLeader::sharedsort.

Referenced by _gin_begin_parallel().

_gin_parallel_build_main()

void _gin_parallel_build_main	(	dsm_segment *	seg,
		shm_toc *	toc
	)

Definition at line 2100 of file gininsert.c.

{
    char       *sharedquery;
    GinBuildShared *ginshared;
    Sharedsort *sharedsort;
    GinBuildState buildstate;
    Relation    heapRel;
    Relation    indexRel;
    LOCKMODE    heapLockmode;
    LOCKMODE    indexLockmode;
    WalUsage   *walusage;
    BufferUsage *bufferusage;
    int         sortmem;
 
    /*
     * The only possible status flag that can be set to the parallel worker is
     * PROC_IN_SAFE_IC.
     */
    Assert((MyProc->statusFlags == 0) ||
           (MyProc->statusFlags == PROC_IN_SAFE_IC));
 
    /* Set debug_query_string for individual workers first */
    sharedquery = shm_toc_lookup(toc, PARALLEL_KEY_QUERY_TEXT, true);
    debug_query_string = sharedquery;
 
    /* Report the query string from leader */
    pgstat_report_activity(STATE_RUNNING, debug_query_string);
 
    /* Look up gin shared state */
    ginshared = shm_toc_lookup(toc, PARALLEL_KEY_GIN_SHARED, false);
 
    /* Open relations using lock modes known to be obtained by index.c */
    if (!ginshared->isconcurrent)
    {
        heapLockmode = ShareLock;
        indexLockmode = AccessExclusiveLock;
    }
    else
    {
        heapLockmode = ShareUpdateExclusiveLock;
        indexLockmode = RowExclusiveLock;
    }
 
    /* Open relations within worker */
    heapRel = table_open(ginshared->heaprelid, heapLockmode);
    indexRel = index_open(ginshared->indexrelid, indexLockmode);
 
    /* initialize the GIN build state */
    initGinState(&buildstate.ginstate, indexRel);
    buildstate.indtuples = 0;
    memset(&buildstate.buildStats, 0, sizeof(GinStatsData));
    memset(&buildstate.tid, 0, sizeof(ItemPointerData));
 
    /*
     * create a temporary memory context that is used to hold data not yet
     * dumped out to the index
     */
    buildstate.tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
                                              "Gin build temporary context",
                                              ALLOCSET_DEFAULT_SIZES);
 
    /*
     * create a temporary memory context that is used for calling
     * ginExtractEntries(), and can be reset after each tuple
     */
    buildstate.funcCtx = AllocSetContextCreate(CurrentMemoryContext,
                                               "Gin build temporary context for user-defined function",
                                               ALLOCSET_DEFAULT_SIZES);
 
    buildstate.accum.ginstate = &buildstate.ginstate;
    ginInitBA(&buildstate.accum);
 
 
    /* Look up shared state private to tuplesort.c */
    sharedsort = shm_toc_lookup(toc, PARALLEL_KEY_TUPLESORT, false);
    tuplesort_attach_shared(sharedsort, seg);
 
    /* Prepare to track buffer usage during parallel execution */
    InstrStartParallelQuery();
 
    /*
     * Might as well use reliable figure when doling out maintenance_work_mem
     * (when requested number of workers were not launched, this will be
     * somewhat higher than it is for other workers).
     */
    sortmem = maintenance_work_mem / ginshared->scantuplesortstates;
 
    _gin_parallel_scan_and_build(&buildstate, ginshared, sharedsort,
                                 heapRel, indexRel, sortmem, false);
 
    /* Report WAL/buffer usage during parallel execution */
    bufferusage = shm_toc_lookup(toc, PARALLEL_KEY_BUFFER_USAGE, false);
    walusage = shm_toc_lookup(toc, PARALLEL_KEY_WAL_USAGE, false);
    InstrEndParallelQuery(&bufferusage[ParallelWorkerNumber],
                          &walusage[ParallelWorkerNumber]);
 
    index_close(indexRel, indexLockmode);
    table_close(heapRel, heapLockmode);
}

References _gin_parallel_scan_and_build(), AccessExclusiveLock, GinBuildState::accum, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), GinBuildState::buildStats, CurrentMemoryContext, debug_query_string, GinBuildState::funcCtx, ginInitBA(), GinBuildState::ginstate, BuildAccumulator::ginstate, GinBuildShared::heaprelid, index_close(), index_open(), GinBuildShared::indexrelid, GinBuildState::indtuples, initGinState(), InstrEndParallelQuery(), InstrStartParallelQuery(), GinBuildShared::isconcurrent, maintenance_work_mem, MyProc, PARALLEL_KEY_BUFFER_USAGE, PARALLEL_KEY_GIN_SHARED, PARALLEL_KEY_QUERY_TEXT, PARALLEL_KEY_TUPLESORT, PARALLEL_KEY_WAL_USAGE, ParallelWorkerNumber, pgstat_report_activity(), PROC_IN_SAFE_IC, RowExclusiveLock, GinBuildShared::scantuplesortstates, ShareLock, ShareUpdateExclusiveLock, shm_toc_lookup(), STATE_RUNNING, PGPROC::statusFlags, table_close(), table_open(), GinBuildState::tid, GinBuildState::tmpCtx, and tuplesort_attach_shared().

_gin_parallel_estimate_shared()

static Size _gin_parallel_estimate_shared ( Relation  heap, Snapshot  snapshot  )

static

Definition at line 1800 of file gininsert.c.

{
    /* c.f. shm_toc_allocate as to why BUFFERALIGN is used */
    return add_size(BUFFERALIGN(sizeof(GinBuildShared)),
                    table_parallelscan_estimate(heap, snapshot));
}

References add_size(), BUFFERALIGN, and table_parallelscan_estimate().

Referenced by _gin_begin_parallel().

_gin_parallel_heapscan()

static double _gin_parallel_heapscan ( GinBuildState *  state )

static

Definition at line 1137 of file gininsert.c.

{
    GinBuildShared *ginshared = state->bs_leader->ginshared;
    int         nparticipanttuplesorts;
 
    nparticipanttuplesorts = state->bs_leader->nparticipanttuplesorts;
    for (;;)
    {
        SpinLockAcquire(&ginshared->mutex);
        if (ginshared->nparticipantsdone == nparticipanttuplesorts)
        {
            /* copy the data into leader state */
            state->bs_reltuples = ginshared->reltuples;
            state->bs_numtuples = ginshared->indtuples;
 
            SpinLockRelease(&ginshared->mutex);
            break;
        }
        SpinLockRelease(&ginshared->mutex);
 
        ConditionVariableSleep(&ginshared->workersdonecv,
                               WAIT_EVENT_PARALLEL_CREATE_INDEX_SCAN);
    }
 
    ConditionVariableCancelSleep();
 
    return state->bs_reltuples;
}

References ConditionVariableCancelSleep(), ConditionVariableSleep(), GinBuildShared::indtuples, GinBuildShared::mutex, GinBuildShared::nparticipantsdone, GinBuildShared::reltuples, SpinLockAcquire, SpinLockRelease, and GinBuildShared::workersdonecv.

Referenced by _gin_parallel_merge().

_gin_parallel_merge()

static double _gin_parallel_merge ( GinBuildState *  state )

static

Definition at line 1638 of file gininsert.c.

{
    GinTuple   *tup;
    Size        tuplen;
    double      reltuples = 0;
    GinBuffer  *buffer;
 
    /* GIN tuples from workers, merged by leader */
    double      numtuples = 0;
 
    /* wait for workers to scan table and produce partial results */
    reltuples = _gin_parallel_heapscan(state);
 
    /* Execute the sort */
    pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE,
                                 PROGRESS_GIN_PHASE_PERFORMSORT_2);
 
    /* do the actual sort in the leader */
    tuplesort_performsort(state->bs_sortstate);
 
    /*
     * Initialize buffer to combine entries for the same key.
     *
     * The leader is allowed to use the whole maintenance_work_mem buffer to
     * combine data. The parallel workers already completed.
     */
    buffer = GinBufferInit(state->ginstate.index);
 
    /*
     * Set the progress target for the next phase.  Reset the block number
     * values set by table_index_build_scan
     */
    {
        const int   progress_index[] = {
            PROGRESS_CREATEIDX_SUBPHASE,
            PROGRESS_CREATEIDX_TUPLES_TOTAL,
            PROGRESS_SCAN_BLOCKS_TOTAL,
            PROGRESS_SCAN_BLOCKS_DONE
        };
        const int64 progress_vals[] = {
            PROGRESS_GIN_PHASE_MERGE_2,
            state->bs_numtuples,
            0, 0
        };
 
        pgstat_progress_update_multi_param(4, progress_index, progress_vals);
    }
 
    /*
     * Read the GIN tuples from the shared tuplesort, sorted by category and
     * key. That probably gives us order matching how data is organized in the
     * index.
     *
     * We don't insert the GIN tuples right away, but instead accumulate as
     * many TIDs for the same key as possible, and then insert that at once.
     * This way we don't need to decompress/recompress the posting lists, etc.
     */
    while ((tup = tuplesort_getgintuple(state->bs_sortstate, &tuplen, true)) != NULL)
    {
        MemoryContext oldCtx;
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * If the buffer can accept the new GIN tuple, just store it there and
         * we're done. If it's a different key (or maybe too much data) flush
         * the current contents into the index first.
         */
        if (!GinBufferCanAddKey(buffer, tup))
        {
            /*
             * Buffer is not empty and it's storing a different key - flush
             * the data into the insert, and start a new entry for current
             * GinTuple.
             */
            AssertCheckItemPointers(buffer);
 
            oldCtx = MemoryContextSwitchTo(state->tmpCtx);
 
            ginEntryInsert(&state->ginstate,
                           buffer->attnum, buffer->key, buffer->category,
                           buffer->items, buffer->nitems, &state->buildStats);
 
            MemoryContextSwitchTo(oldCtx);
            MemoryContextReset(state->tmpCtx);
 
            /* discard the existing data */
            GinBufferReset(buffer);
        }
 
        /*
         * We're about to add a GIN tuple to the buffer - check the memory
         * limit first, and maybe write out some of the data into the index
         * first, if needed (and possible). We only flush the part of the TID
         * list that we know won't change, and only if there's enough data for
         * compression to work well.
         */
        if (GinBufferShouldTrim(buffer, tup))
        {
            Assert(buffer->nfrozen > 0);
 
            /*
             * Buffer is not empty and it's storing a different key - flush
             * the data into the insert, and start a new entry for current
             * GinTuple.
             */
            AssertCheckItemPointers(buffer);
 
            oldCtx = MemoryContextSwitchTo(state->tmpCtx);
 
            ginEntryInsert(&state->ginstate,
                           buffer->attnum, buffer->key, buffer->category,
                           buffer->items, buffer->nfrozen, &state->buildStats);
 
            MemoryContextSwitchTo(oldCtx);
            MemoryContextReset(state->tmpCtx);
 
            /* truncate the data we've just discarded */
            GinBufferTrim(buffer);
        }
 
        /*
         * Remember data for the current tuple (either remember the new key,
         * or append if to the existing data).
         */
        GinBufferStoreTuple(buffer, tup);
 
        /* Report progress */
        pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
                                     ++numtuples);
    }
 
    /* flush data remaining in the buffer (for the last key) */
    if (!GinBufferIsEmpty(buffer))
    {
        AssertCheckItemPointers(buffer);
 
        ginEntryInsert(&state->ginstate,
                       buffer->attnum, buffer->key, buffer->category,
                       buffer->items, buffer->nitems, &state->buildStats);
 
        /* discard the existing data */
        GinBufferReset(buffer);
 
        /* Report progress */
        pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE,
                                     ++numtuples);
    }
 
    /* relase all the memory */
    GinBufferFree(buffer);
 
    tuplesort_end(state->bs_sortstate);
 
    return reltuples;
}

References _gin_parallel_heapscan(), Assert(), AssertCheckItemPointers(), GinBuffer::attnum, GinBuffer::category, CHECK_FOR_INTERRUPTS, GinBufferCanAddKey(), GinBufferFree(), GinBufferInit(), GinBufferIsEmpty(), GinBufferReset(), GinBufferShouldTrim(), GinBufferStoreTuple(), GinBufferTrim(), ginEntryInsert(), GinBuffer::items, GinBuffer::key, MemoryContextReset(), MemoryContextSwitchTo(), GinBuffer::nfrozen, GinBuffer::nitems, pgstat_progress_update_multi_param(), pgstat_progress_update_param(), PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_CREATEIDX_TUPLES_DONE, PROGRESS_CREATEIDX_TUPLES_TOTAL, PROGRESS_GIN_PHASE_MERGE_2, PROGRESS_GIN_PHASE_PERFORMSORT_2, PROGRESS_SCAN_BLOCKS_DONE, PROGRESS_SCAN_BLOCKS_TOTAL, tuplesort_end(), tuplesort_getgintuple(), and tuplesort_performsort().

Referenced by ginbuild().

_gin_parallel_scan_and_build()

static void _gin_parallel_scan_and_build ( GinBuildState *  state, GinBuildShared *  ginshared, Sharedsort *  sharedsort, Relation  heap, Relation  index, int  sortmem, bool  progress  )

static

Definition at line 2022 of file gininsert.c.

{
    SortCoordinate coordinate;
    TableScanDesc scan;
    double      reltuples;
    IndexInfo  *indexInfo;
 
    /* Initialize local tuplesort coordination state */
    coordinate = palloc0(sizeof(SortCoordinateData));
    coordinate->isWorker = true;
    coordinate->nParticipants = -1;
    coordinate->sharedsort = sharedsort;
 
    /* remember how much space is allowed for the accumulated entries */
    state->work_mem = (sortmem / 2);
 
    /* remember how many workers participate in the build */
    state->bs_num_workers = ginshared->scantuplesortstates;
 
    /* Begin "partial" tuplesort */
    state->bs_sortstate = tuplesort_begin_index_gin(heap, index,
                                                    state->work_mem,
                                                    coordinate,
                                                    TUPLESORT_NONE);
 
    /* Local per-worker sort of raw-data */
    state->bs_worker_sort = tuplesort_begin_index_gin(heap, index,
                                                      state->work_mem,
                                                      NULL,
                                                      TUPLESORT_NONE);
 
    /* Join parallel scan */
    indexInfo = BuildIndexInfo(index);
    indexInfo->ii_Concurrent = ginshared->isconcurrent;
 
    scan = table_beginscan_parallel(heap,
                                    ParallelTableScanFromGinBuildShared(ginshared));
 
    reltuples = table_index_build_scan(heap, index, indexInfo, true, progress,
                                       ginBuildCallbackParallel, state, scan);
 
    /* write remaining accumulated entries */
    ginFlushBuildState(state, index);
 
    /*
     * Do the first phase of in-worker processing - sort the data produced by
     * the callback, and combine them into much larger chunks and place that
     * into the shared tuplestore for leader to process.
     */
    _gin_process_worker_data(state, state->bs_worker_sort, progress);
 
    /* sort the GIN tuples built by this worker */
    tuplesort_performsort(state->bs_sortstate);
 
    state->bs_reltuples += reltuples;
 
    /*
     * Done.  Record ambuild statistics.
     */
    SpinLockAcquire(&ginshared->mutex);
    ginshared->nparticipantsdone++;
    ginshared->reltuples += state->bs_reltuples;
    ginshared->indtuples += state->bs_numtuples;
    SpinLockRelease(&ginshared->mutex);
 
    /* Notify leader */
    ConditionVariableSignal(&ginshared->workersdonecv);
 
    tuplesort_end(state->bs_sortstate);
}

References _gin_process_worker_data(), BuildIndexInfo(), ConditionVariableSignal(), ginBuildCallbackParallel(), ginFlushBuildState(), IndexInfo::ii_Concurrent, GinBuildShared::indtuples, GinBuildShared::isconcurrent, SortCoordinateData::isWorker, GinBuildShared::mutex, SortCoordinateData::nParticipants, GinBuildShared::nparticipantsdone, palloc0(), ParallelTableScanFromGinBuildShared, progress, GinBuildShared::reltuples, GinBuildShared::scantuplesortstates, SortCoordinateData::sharedsort, SpinLockAcquire, SpinLockRelease, table_beginscan_parallel(), table_index_build_scan(), tuplesort_begin_index_gin(), tuplesort_end(), TUPLESORT_NONE, tuplesort_performsort(), and GinBuildShared::workersdonecv.

Referenced by _gin_leader_participate_as_worker(), and _gin_parallel_build_main().

_gin_parse_tuple_items()

static ItemPointer _gin_parse_tuple_items ( GinTuple *  a )

static

Definition at line 2401 of file gininsert.c.

{
    int         len;
    char       *ptr;
    int         ndecoded;
    ItemPointer items;
 
    len = a->tuplen - SHORTALIGN(offsetof(GinTuple, data) + a->keylen);
    ptr = (char *) a + SHORTALIGN(offsetof(GinTuple, data) + a->keylen);
 
    items = ginPostingListDecodeAllSegments((GinPostingList *) ptr, len, &ndecoded);
 
    Assert(ndecoded == a->nitems);
 
    return (ItemPointer) items;
}

References a, Assert(), data, ginPostingListDecodeAllSegments(), items, len, and SHORTALIGN.

Referenced by GinBufferStoreTuple().

_gin_parse_tuple_key()

static Datum _gin_parse_tuple_key ( GinTuple *  a )

static

Definition at line 2380 of file gininsert.c.

{
    Datum       key;
 
    if (a->category != GIN_CAT_NORM_KEY)
        return (Datum) 0;
 
    if (a->typbyval)
    {
        memcpy(&key, a->data, a->keylen);
        return key;
    }
 
    return PointerGetDatum(a->data);
}

References a, GIN_CAT_NORM_KEY, sort-test::key, and PointerGetDatum().

Referenced by _gin_compare_tuples(), and GinBufferStoreTuple().

_gin_process_worker_data()

static void _gin_process_worker_data ( GinBuildState *  state, Tuplesortstate *  worker_sort, bool  progress  )

static

Definition at line 1844 of file gininsert.c.

{
    GinTuple   *tup;
    Size        tuplen;
 
    GinBuffer  *buffer;
 
    /*
     * Initialize buffer to combine entries for the same key.
     *
     * The workers are limited to the same amount of memory as during the sort
     * in ginBuildCallbackParallel. But this probably should be the 32MB used
     * during planning, just like there.
     */
    buffer = GinBufferInit(state->ginstate.index);
 
    /* sort the raw per-worker data */
    if (progress)
        pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE,
                                     PROGRESS_GIN_PHASE_PERFORMSORT_1);
 
    tuplesort_performsort(state->bs_worker_sort);
 
    /* reset the number of GIN tuples produced by this worker */
    state->bs_numtuples = 0;
 
    if (progress)
        pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE,
                                     PROGRESS_GIN_PHASE_MERGE_1);
 
    /*
     * Read the GIN tuples from the shared tuplesort, sorted by the key, and
     * merge them into larger chunks for the leader to combine.
     */
    while ((tup = tuplesort_getgintuple(worker_sort, &tuplen, true)) != NULL)
    {
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * If the buffer can accept the new GIN tuple, just store it there and
         * we're done. If it's a different key (or maybe too much data) flush
         * the current contents into the index first.
         */
        if (!GinBufferCanAddKey(buffer, tup))
        {
            GinTuple   *ntup;
            Size        ntuplen;
 
            /*
             * Buffer is not empty and it's storing a different key - flush
             * the data into the insert, and start a new entry for current
             * GinTuple.
             */
            AssertCheckItemPointers(buffer);
 
            ntup = _gin_build_tuple(buffer->attnum, buffer->category,
                                    buffer->key, buffer->typlen, buffer->typbyval,
                                    buffer->items, buffer->nitems, &ntuplen);
 
            tuplesort_putgintuple(state->bs_sortstate, ntup, ntuplen);
            state->bs_numtuples++;
 
            pfree(ntup);
 
            /* discard the existing data */
            GinBufferReset(buffer);
        }
 
        /*
         * We're about to add a GIN tuple to the buffer - check the memory
         * limit first, and maybe write out some of the data into the index
         * first, if needed (and possible). We only flush the part of the TID
         * list that we know won't change, and only if there's enough data for
         * compression to work well.
         */
        if (GinBufferShouldTrim(buffer, tup))
        {
            GinTuple   *ntup;
            Size        ntuplen;
 
            Assert(buffer->nfrozen > 0);
 
            /*
             * Buffer is not empty and it's storing a different key - flush
             * the data into the insert, and start a new entry for current
             * GinTuple.
             */
            AssertCheckItemPointers(buffer);
 
            ntup = _gin_build_tuple(buffer->attnum, buffer->category,
                                    buffer->key, buffer->typlen, buffer->typbyval,
                                    buffer->items, buffer->nfrozen, &ntuplen);
 
            tuplesort_putgintuple(state->bs_sortstate, ntup, ntuplen);
 
            pfree(ntup);
 
            /* truncate the data we've just discarded */
            GinBufferTrim(buffer);
        }
 
        /*
         * Remember data for the current tuple (either remember the new key,
         * or append if to the existing data).
         */
        GinBufferStoreTuple(buffer, tup);
    }
 
    /* flush data remaining in the buffer (for the last key) */
    if (!GinBufferIsEmpty(buffer))
    {
        GinTuple   *ntup;
        Size        ntuplen;
 
        AssertCheckItemPointers(buffer);
 
        ntup = _gin_build_tuple(buffer->attnum, buffer->category,
                                buffer->key, buffer->typlen, buffer->typbyval,
                                buffer->items, buffer->nitems, &ntuplen);
 
        tuplesort_putgintuple(state->bs_sortstate, ntup, ntuplen);
        state->bs_numtuples++;
 
        pfree(ntup);
 
        /* discard the existing data */
        GinBufferReset(buffer);
    }
 
    /* relase all the memory */
    GinBufferFree(buffer);
 
    tuplesort_end(worker_sort);
}

References _gin_build_tuple(), Assert(), AssertCheckItemPointers(), GinBuffer::attnum, GinBuffer::category, CHECK_FOR_INTERRUPTS, GinBufferCanAddKey(), GinBufferFree(), GinBufferInit(), GinBufferIsEmpty(), GinBufferReset(), GinBufferShouldTrim(), GinBufferStoreTuple(), GinBufferTrim(), GinBuffer::items, GinBuffer::key, GinBuffer::nfrozen, GinBuffer::nitems, pfree(), pgstat_progress_update_param(), progress, PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_GIN_PHASE_MERGE_1, PROGRESS_GIN_PHASE_PERFORMSORT_1, tuplesort_end(), tuplesort_getgintuple(), tuplesort_performsort(), tuplesort_putgintuple(), GinBuffer::typbyval, and GinBuffer::typlen.

Referenced by _gin_parallel_scan_and_build().

addItemPointersToLeafTuple()

static IndexTuple addItemPointersToLeafTuple ( GinState *  ginstate, IndexTuple  old, ItemPointerData *  items, uint32  nitem, GinStatsData *  buildStats, Buffer  buffer  )

static

Definition at line 211 of file gininsert.c.

{
    OffsetNumber attnum;
    Datum       key;
    GinNullCategory category;
    IndexTuple  res;
    ItemPointerData *newItems,
               *oldItems;
    int         oldNPosting,
                newNPosting,
                nwritten;
    GinPostingList *compressedList;
 
    Assert(!GinIsPostingTree(old));
 
    attnum = gintuple_get_attrnum(ginstate, old);
    key = gintuple_get_key(ginstate, old, &category);
 
    /* merge the old and new posting lists */
    oldItems = ginReadTuple(ginstate, attnum, old, &oldNPosting);
 
    newItems = ginMergeItemPointers(items, nitem,
                                    oldItems, oldNPosting,
                                    &newNPosting);
 
    /* Compress the posting list, and try to a build tuple with room for it */
    res = NULL;
    compressedList = ginCompressPostingList(newItems, newNPosting, GinMaxItemSize, &nwritten);
    if (nwritten == newNPosting)
    {
        res = GinFormTuple(ginstate, attnum, key, category,
                           (char *) compressedList,
                           SizeOfGinPostingList(compressedList),
                           newNPosting,
                           false);
    }
 
    pfree(newItems);
    pfree(compressedList);
 
    if (!res)
    {
        /* posting list would be too big, convert to posting tree */
        BlockNumber postingRoot;
 
        /*
         * Initialize posting tree with the old tuple's posting list.  It's
         * surely small enough to fit on one posting-tree page, and should
         * already be in order with no duplicates.
         */
        postingRoot = createPostingTree(ginstate->index,
                                        oldItems,
                                        oldNPosting,
                                        buildStats,
                                        buffer);
 
        /* Now insert the TIDs-to-be-added into the posting tree */
        ginInsertItemPointers(ginstate->index, postingRoot,
                              items, nitem,
                              buildStats);
 
        /* And build a new posting-tree-only result tuple */
        res = GinFormTuple(ginstate, attnum, key, category, NULL, 0, 0, true);
        GinSetPostingTree(res, postingRoot);
    }
    pfree(oldItems);
 
    return res;
}

References Assert(), attnum, createPostingTree(), ginCompressPostingList(), GinFormTuple(), ginInsertItemPointers(), GinIsPostingTree, GinMaxItemSize, ginMergeItemPointers(), ginReadTuple(), GinSetPostingTree, gintuple_get_attrnum(), gintuple_get_key(), GinState::index, items, sort-test::key, pfree(), and SizeOfGinPostingList.

Referenced by ginEntryInsert().

AssertCheckGinBuffer()

static void AssertCheckGinBuffer ( GinBuffer *  buffer )

static

Definition at line 1231 of file gininsert.c.

{
#ifdef USE_ASSERT_CHECKING
    /* if we have any items, the array must exist */
    Assert(!((buffer->nitems > 0) && (buffer->items == NULL)));
 
    /*
     * The buffer may be empty, in which case we must not call the check of
     * item pointers, because that assumes non-emptiness.
     */
    if (buffer->nitems == 0)
        return;
 
    /* Make sure the item pointers are valid and sorted. */
    AssertCheckItemPointers(buffer);
#endif
}

References Assert(), AssertCheckItemPointers(), GinBuffer::items, and GinBuffer::nitems.

Referenced by GinBufferKeyEquals(), and GinBufferStoreTuple().

AssertCheckItemPointers()

static void AssertCheckItemPointers ( GinBuffer *  buffer )

static

Definition at line 1204 of file gininsert.c.

{
#ifdef USE_ASSERT_CHECKING
    /* we should not have a buffer with no TIDs to sort */
    Assert(buffer->items != NULL);
    Assert(buffer->nitems > 0);
 
    for (int i = 0; i < buffer->nitems; i++)
    {
        Assert(ItemPointerIsValid(&buffer->items[i]));
 
        /* don't check ordering for the first TID item */
        if (i == 0)
            continue;
 
        Assert(ItemPointerCompare(&buffer->items[i - 1], &buffer->items[i]) < 0);
    }
#endif
}

References Assert(), i, ItemPointerCompare(), ItemPointerIsValid(), GinBuffer::items, and GinBuffer::nitems.

Referenced by _gin_parallel_merge(), _gin_process_worker_data(), AssertCheckGinBuffer(), and GinBufferStoreTuple().

buildFreshLeafTuple()

static IndexTuple buildFreshLeafTuple ( GinState *  ginstate, OffsetNumber  attnum, Datum  key, GinNullCategory  category, ItemPointerData *  items, uint32  nitem, GinStatsData *  buildStats, Buffer  buffer  )

static

Definition at line 293 of file gininsert.c.

{
    IndexTuple  res = NULL;
    GinPostingList *compressedList;
    int         nwritten;
 
    /* try to build a posting list tuple with all the items */
    compressedList = ginCompressPostingList(items, nitem, GinMaxItemSize, &nwritten);
    if (nwritten == nitem)
    {
        res = GinFormTuple(ginstate, attnum, key, category,
                           (char *) compressedList,
                           SizeOfGinPostingList(compressedList),
                           nitem, false);
    }
    pfree(compressedList);
 
    if (!res)
    {
        /* posting list would be too big, build posting tree */
        BlockNumber postingRoot;
 
        /*
         * Build posting-tree-only result tuple.  We do this first so as to
         * fail quickly if the key is too big.
         */
        res = GinFormTuple(ginstate, attnum, key, category, NULL, 0, 0, true);
 
        /*
         * Initialize a new posting tree with the TIDs.
         */
        postingRoot = createPostingTree(ginstate->index, items, nitem,
                                        buildStats, buffer);
 
        /* And save the root link in the result tuple */
        GinSetPostingTree(res, postingRoot);
    }
 
    return res;
}

References attnum, createPostingTree(), ginCompressPostingList(), GinFormTuple(), GinMaxItemSize, GinSetPostingTree, GinState::index, items, sort-test::key, pfree(), and SizeOfGinPostingList.

Referenced by ginEntryInsert().

GinBufferCanAddKey()

static bool GinBufferCanAddKey ( GinBuffer *  buffer, GinTuple *  tup  )

static

Definition at line 1616 of file gininsert.c.

{
    /* empty buffer can accept data for any key */
    if (GinBufferIsEmpty(buffer))
        return true;
 
    /* otherwise just data for the same key */
    return GinBufferKeyEquals(buffer, tup);
}

References GinBufferIsEmpty(), and GinBufferKeyEquals().

Referenced by _gin_parallel_merge(), and _gin_process_worker_data().

GinBufferFree()

static void GinBufferFree ( GinBuffer *  buffer )

static

Definition at line 1596 of file gininsert.c.

{
    if (buffer->items)
        pfree(buffer->items);
 
    /* release byref values, do nothing for by-val ones */
    if (!GinBufferIsEmpty(buffer) &&
        (buffer->category == GIN_CAT_NORM_KEY) && !buffer->typbyval)
        pfree(DatumGetPointer(buffer->key));
 
    pfree(buffer);
}

References GinBuffer::category, DatumGetPointer(), GIN_CAT_NORM_KEY, GinBufferIsEmpty(), GinBuffer::items, GinBuffer::key, pfree(), and GinBuffer::typbyval.

Referenced by _gin_parallel_merge(), and _gin_process_worker_data().

GinBufferInit()

static GinBuffer * GinBufferInit ( Relation  index )

static

Definition at line 1260 of file gininsert.c.

{
    GinBuffer  *buffer = palloc0(sizeof(GinBuffer));
    int         i,
                nKeys;
    TupleDesc   desc = RelationGetDescr(index);
 
    /*
     * How many items can we fit into the memory limit? We don't want to end
     * with too many TIDs. and 64kB seems more than enough. But maybe this
     * should be tied to maintenance_work_mem or something like that?
     */
    buffer->maxitems = (64 * 1024L) / sizeof(ItemPointerData);
 
    nKeys = IndexRelationGetNumberOfKeyAttributes(index);
 
    buffer->ssup = palloc0(sizeof(SortSupportData) * nKeys);
 
    /*
     * Lookup ordering operator for the index key data type, and initialize
     * the sort support function.
     */
    for (i = 0; i < nKeys; i++)
    {
        Oid         cmpFunc;
        SortSupport sortKey = &buffer->ssup[i];
        Form_pg_attribute att = TupleDescAttr(desc, i);
 
        sortKey->ssup_cxt = CurrentMemoryContext;
        sortKey->ssup_collation = index->rd_indcollation[i];
 
        if (!OidIsValid(sortKey->ssup_collation))
            sortKey->ssup_collation = DEFAULT_COLLATION_OID;
 
        sortKey->ssup_nulls_first = false;
        sortKey->ssup_attno = i + 1;
        sortKey->abbreviate = false;
 
        Assert(sortKey->ssup_attno != 0);
 
        /*
         * If the compare proc isn't specified in the opclass definition, look
         * up the index key type's default btree comparator.
         */
        cmpFunc = index_getprocid(index, i + 1, GIN_COMPARE_PROC);
        if (cmpFunc == InvalidOid)
        {
            TypeCacheEntry *typentry;
 
            typentry = lookup_type_cache(att->atttypid,
                                         TYPECACHE_CMP_PROC_FINFO);
            if (!OidIsValid(typentry->cmp_proc_finfo.fn_oid))
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("could not identify a comparison function for type %s",
                                format_type_be(att->atttypid))));
 
            cmpFunc = typentry->cmp_proc_finfo.fn_oid;
        }
 
        PrepareSortSupportComparisonShim(cmpFunc, sortKey);
    }
 
    return buffer;
}

References SortSupportData::abbreviate, Assert(), TypeCacheEntry::cmp_proc_finfo, CurrentMemoryContext, ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), GIN_COMPARE_PROC, i, index_getprocid(), IndexRelationGetNumberOfKeyAttributes, InvalidOid, lookup_type_cache(), GinBuffer::maxitems, OidIsValid, palloc0(), PrepareSortSupportComparisonShim(), RelationGetDescr, GinBuffer::ssup, SortSupportData::ssup_attno, SortSupportData::ssup_collation, SortSupportData::ssup_cxt, SortSupportData::ssup_nulls_first, TupleDescAttr(), and TYPECACHE_CMP_PROC_FINFO.

Referenced by _gin_parallel_merge(), and _gin_process_worker_data().

GinBufferIsEmpty()

static bool GinBufferIsEmpty ( GinBuffer *  buffer )

static

Definition at line 1328 of file gininsert.c.

{
    return (buffer->nitems == 0);
}

References GinBuffer::nitems.

Referenced by _gin_parallel_merge(), _gin_process_worker_data(), GinBufferCanAddKey(), GinBufferFree(), GinBufferReset(), and GinBufferStoreTuple().

GinBufferKeyEquals()

static bool GinBufferKeyEquals ( GinBuffer *  buffer, GinTuple *  tup  )

static

Definition at line 1344 of file gininsert.c.

{
    int         r;
    Datum       tupkey;
 
    AssertCheckGinBuffer(buffer);
 
    if (tup->attrnum != buffer->attnum)
        return false;
 
    /* same attribute should have the same type info */
    Assert(tup->typbyval == buffer->typbyval);
    Assert(tup->typlen == buffer->typlen);
 
    if (tup->category != buffer->category)
        return false;
 
    /*
     * For NULL/empty keys, this means equality, for normal keys we need to
     * compare the actual key value.
     */
    if (buffer->category != GIN_CAT_NORM_KEY)
        return true;
 
    /*
     * For the tuple, get either the first sizeof(Datum) bytes for byval
     * types, or a pointer to the beginning of the data array.
     */
    tupkey = (buffer->typbyval) ? *(Datum *) tup->data : PointerGetDatum(tup->data);
 
    r = ApplySortComparator(buffer->key, false,
                            tupkey, false,
                            &buffer->ssup[buffer->attnum - 1]);
 
    return (r == 0);
}

References ApplySortComparator(), Assert(), AssertCheckGinBuffer(), GinBuffer::attnum, GinTuple::attrnum, GinBuffer::category, GinTuple::category, GinTuple::data, GIN_CAT_NORM_KEY, GinBuffer::key, PointerGetDatum(), GinBuffer::ssup, GinBuffer::typbyval, GinTuple::typbyval, GinBuffer::typlen, and GinTuple::typlen.

Referenced by GinBufferCanAddKey().

GinBufferReset()

static void GinBufferReset ( GinBuffer *  buffer )

static

Definition at line 1550 of file gininsert.c.

{
    Assert(!GinBufferIsEmpty(buffer));
 
    /* release byref values, do nothing for by-val ones */
    if ((buffer->category == GIN_CAT_NORM_KEY) && !buffer->typbyval)
        pfree(DatumGetPointer(buffer->key));
 
    /*
     * Not required, but makes it more likely to trigger NULL dereference if
     * using the value incorrectly, etc.
     */
    buffer->key = (Datum) 0;
 
    buffer->attnum = 0;
    buffer->category = 0;
    buffer->keylen = 0;
    buffer->nitems = 0;
    buffer->nfrozen = 0;
 
    buffer->typlen = 0;
    buffer->typbyval = 0;
}

References Assert(), GinBuffer::attnum, GinBuffer::category, DatumGetPointer(), GIN_CAT_NORM_KEY, GinBufferIsEmpty(), GinBuffer::key, GinBuffer::keylen, GinBuffer::nfrozen, GinBuffer::nitems, pfree(), GinBuffer::typbyval, and GinBuffer::typlen.

Referenced by _gin_parallel_merge(), and _gin_process_worker_data().

GinBufferShouldTrim()

static bool GinBufferShouldTrim ( GinBuffer *  buffer, GinTuple *  tup  )

static

Definition at line 1410 of file gininsert.c.

{
    /*
     * Check if the last TID in the current list is frozen. This is the case
     * when merging non-overlapping lists, e.g. in each parallel worker.
     */
    if ((buffer->nitems > 0) &&
        (ItemPointerCompare(&buffer->items[buffer->nitems - 1],
                            GinTupleGetFirst(tup)) == 0))
        buffer->nfrozen = buffer->nitems;
 
    /*
     * Now find the last TID we know to be frozen, i.e. the last TID right
     * before the new GIN tuple.
     *
     * Start with the first not-yet-frozen tuple, and walk until we find the
     * first TID that's higher. If we already know the whole list is frozen
     * (i.e. nfrozen == nitems), this does nothing.
     *
     * XXX This might do a binary search for sufficiently long lists, but it
     * does not seem worth the complexity. Overlapping lists should be rare
     * common, TID comparisons are cheap, and we should quickly freeze most of
     * the list.
     */
    for (int i = buffer->nfrozen; i < buffer->nitems; i++)
    {
        /* Is the TID after the first TID of the new tuple? Can't freeze. */
        if (ItemPointerCompare(&buffer->items[i],
                               GinTupleGetFirst(tup)) > 0)
            break;
 
        buffer->nfrozen++;
    }
 
    /* not enough TIDs to trim (1024 is somewhat arbitrary number) */
    if (buffer->nfrozen < 1024)
        return false;
 
    /* no need to trim if we have not hit the memory limit yet */
    if ((buffer->nitems + tup->nitems) < buffer->maxitems)
        return false;
 
    /*
     * OK, we have enough frozen TIDs to flush, and we have hit the memory
     * limit, so it's time to write it out.
     */
    return true;
}

References GinTupleGetFirst(), i, ItemPointerCompare(), GinBuffer::items, GinBuffer::maxitems, GinBuffer::nfrozen, GinBuffer::nitems, GinTuple::nitems, and nitems.

Referenced by _gin_parallel_merge(), and _gin_process_worker_data().

GinBufferStoreTuple()

static void GinBufferStoreTuple ( GinBuffer *  buffer, GinTuple *  tup  )

static

Definition at line 1483 of file gininsert.c.

{
    ItemPointerData *items;
    Datum       key;
 
    AssertCheckGinBuffer(buffer);
 
    key = _gin_parse_tuple_key(tup);
    items = _gin_parse_tuple_items(tup);
 
    /* if the buffer is empty, set the fields (and copy the key) */
    if (GinBufferIsEmpty(buffer))
    {
        buffer->category = tup->category;
        buffer->keylen = tup->keylen;
        buffer->attnum = tup->attrnum;
 
        buffer->typlen = tup->typlen;
        buffer->typbyval = tup->typbyval;
 
        if (tup->category == GIN_CAT_NORM_KEY)
            buffer->key = datumCopy(key, buffer->typbyval, buffer->typlen);
        else
            buffer->key = (Datum) 0;
    }
 
    /* add the new TIDs into the buffer, combine using merge-sort */
    {
        int         nnew;
        ItemPointer new;
 
        /*
         * Resize the array - we do this first, because we'll dereference the
         * first unfrozen TID, which would fail if the array is NULL. We'll
         * still pass 0 as number of elements in that array though.
         */
        if (buffer->items == NULL)
            buffer->items = palloc((buffer->nitems + tup->nitems) * sizeof(ItemPointerData));
        else
            buffer->items = repalloc(buffer->items,
                                     (buffer->nitems + tup->nitems) * sizeof(ItemPointerData));
 
        new = ginMergeItemPointers(&buffer->items[buffer->nfrozen], /* first unfrozen */
                                   (buffer->nitems - buffer->nfrozen),  /* num of unfrozen */
                                   items, tup->nitems, &nnew);
 
        Assert(nnew == (tup->nitems + (buffer->nitems - buffer->nfrozen)));
 
        memcpy(&buffer->items[buffer->nfrozen], new,
               nnew * sizeof(ItemPointerData));
 
        pfree(new);
 
        buffer->nitems += tup->nitems;
 
        AssertCheckItemPointers(buffer);
    }
 
    /* free the decompressed TID list */
    pfree(items);
}

References _gin_parse_tuple_items(), _gin_parse_tuple_key(), Assert(), AssertCheckGinBuffer(), AssertCheckItemPointers(), GinBuffer::attnum, GinTuple::attrnum, GinBuffer::category, GinTuple::category, datumCopy(), GIN_CAT_NORM_KEY, GinBufferIsEmpty(), ginMergeItemPointers(), GinBuffer::items, items, GinBuffer::key, sort-test::key, GinBuffer::keylen, GinTuple::keylen, GinBuffer::nfrozen, GinBuffer::nitems, GinTuple::nitems, palloc(), pfree(), repalloc(), GinBuffer::typbyval, GinTuple::typbyval, GinBuffer::typlen, and GinTuple::typlen.

Referenced by _gin_parallel_merge(), and _gin_process_worker_data().

GinBufferTrim()

static void GinBufferTrim ( GinBuffer *  buffer )

static

Definition at line 1580 of file gininsert.c.

{
    Assert((buffer->nfrozen > 0) && (buffer->nfrozen <= buffer->nitems));
 
    memmove(&buffer->items[0], &buffer->items[buffer->nfrozen],
            sizeof(ItemPointerData) * (buffer->nitems - buffer->nfrozen));
 
    buffer->nitems -= buffer->nfrozen;
    buffer->nfrozen = 0;
}

References Assert(), GinBuffer::items, GinBuffer::nfrozen, and GinBuffer::nitems.

Referenced by _gin_parallel_merge(), and _gin_process_worker_data().

ginbuild()

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

Definition at line 612 of file gininsert.c.

{
    IndexBuildResult *result;
    double      reltuples;
    GinBuildState buildstate;
    GinBuildState *state = &buildstate;
    Buffer      RootBuffer,
                MetaBuffer;
    ItemPointerData *list;
    Datum       key;
    GinNullCategory category;
    uint32      nlist;
    MemoryContext oldCtx;
    OffsetNumber attnum;
 
    if (RelationGetNumberOfBlocks(index) != 0)
        elog(ERROR, "index \"%s\" already contains data",
             RelationGetRelationName(index));
 
    initGinState(&buildstate.ginstate, index);
    buildstate.indtuples = 0;
    memset(&buildstate.buildStats, 0, sizeof(GinStatsData));
 
    /* Initialize fields for parallel build too. */
    buildstate.bs_numtuples = 0;
    buildstate.bs_reltuples = 0;
    buildstate.bs_leader = NULL;
    memset(&buildstate.tid, 0, sizeof(ItemPointerData));
 
    /* initialize the meta page */
    MetaBuffer = GinNewBuffer(index);
 
    /* initialize the root page */
    RootBuffer = GinNewBuffer(index);
 
    START_CRIT_SECTION();
    GinInitMetabuffer(MetaBuffer);
    MarkBufferDirty(MetaBuffer);
    GinInitBuffer(RootBuffer, GIN_LEAF);
    MarkBufferDirty(RootBuffer);
 
 
    UnlockReleaseBuffer(MetaBuffer);
    UnlockReleaseBuffer(RootBuffer);
    END_CRIT_SECTION();
 
    /* count the root as first entry page */
    buildstate.buildStats.nEntryPages++;
 
    /*
     * create a temporary memory context that is used to hold data not yet
     * dumped out to the index
     */
    buildstate.tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
                                              "Gin build temporary context",
                                              ALLOCSET_DEFAULT_SIZES);
 
    /*
     * create a temporary memory context that is used for calling
     * ginExtractEntries(), and can be reset after each tuple
     */
    buildstate.funcCtx = AllocSetContextCreate(CurrentMemoryContext,
                                               "Gin build temporary context for user-defined function",
                                               ALLOCSET_DEFAULT_SIZES);
 
    buildstate.accum.ginstate = &buildstate.ginstate;
    ginInitBA(&buildstate.accum);
 
    /* Report table scan phase started */
    pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE,
                                 PROGRESS_GIN_PHASE_INDEXBUILD_TABLESCAN);
 
    /*
     * Attempt to launch parallel worker scan when required
     *
     * XXX plan_create_index_workers makes the number of workers dependent on
     * maintenance_work_mem, requiring 32MB for each worker. For GIN that's
     * reasonable too, because we sort the data just like btree. It does
     * ignore the memory used to accumulate data in memory (set by work_mem),
     * but there is no way to communicate that to plan_create_index_workers.
     */
    if (indexInfo->ii_ParallelWorkers > 0)
        _gin_begin_parallel(state, heap, index, indexInfo->ii_Concurrent,
                            indexInfo->ii_ParallelWorkers);
 
    /*
     * If parallel build requested and at least one worker process was
     * successfully launched, set up coordination state, wait for workers to
     * complete. Then read all tuples from the shared tuplesort and insert
     * them into the index.
     *
     * In serial mode, simply scan the table and build the index one index
     * tuple at a time.
     */
    if (state->bs_leader)
    {
        SortCoordinate coordinate;
 
        coordinate = (SortCoordinate) palloc0(sizeof(SortCoordinateData));
        coordinate->isWorker = false;
        coordinate->nParticipants =
            state->bs_leader->nparticipanttuplesorts;
        coordinate->sharedsort = state->bs_leader->sharedsort;
 
        /*
         * Begin leader tuplesort.
         *
         * In cases where parallelism is involved, the leader receives the
         * same share of maintenance_work_mem as a serial sort (it is
         * generally treated in the same way as a serial sort once we return).
         * Parallel worker Tuplesortstates will have received only a fraction
         * of maintenance_work_mem, though.
         *
         * We rely on the lifetime of the Leader Tuplesortstate almost not
         * overlapping with any worker Tuplesortstate's lifetime.  There may
         * be some small overlap, but that's okay because we rely on leader
         * Tuplesortstate only allocating a small, fixed amount of memory
         * here. When its tuplesort_performsort() is called (by our caller),
         * and significant amounts of memory are likely to be used, all
         * workers must have already freed almost all memory held by their
         * Tuplesortstates (they are about to go away completely, too).  The
         * overall effect is that maintenance_work_mem always represents an
         * absolute high watermark on the amount of memory used by a CREATE
         * INDEX operation, regardless of the use of parallelism or any other
         * factor.
         */
        state->bs_sortstate =
            tuplesort_begin_index_gin(heap, index,
                                      maintenance_work_mem, coordinate,
                                      TUPLESORT_NONE);
 
        /* scan the relation in parallel and merge per-worker results */
        reltuples = _gin_parallel_merge(state);
 
        _gin_end_parallel(state->bs_leader, state);
    }
    else                        /* no parallel index build */
    {
        /*
         * Do the heap scan.  We disallow sync scan here because
         * dataPlaceToPage prefers to receive tuples in TID order.
         */
        reltuples = table_index_build_scan(heap, index, indexInfo, false, true,
                                           ginBuildCallback, &buildstate, NULL);
 
        /* dump remaining entries to the index */
        oldCtx = MemoryContextSwitchTo(buildstate.tmpCtx);
        ginBeginBAScan(&buildstate.accum);
        while ((list = ginGetBAEntry(&buildstate.accum,
                                     &attnum, &key, &category, &nlist)) != NULL)
        {
            /* there could be many entries, so be willing to abort here */
            CHECK_FOR_INTERRUPTS();
            ginEntryInsert(&buildstate.ginstate, attnum, key, category,
                           list, nlist, &buildstate.buildStats);
        }
        MemoryContextSwitchTo(oldCtx);
    }
 
    MemoryContextDelete(buildstate.funcCtx);
    MemoryContextDelete(buildstate.tmpCtx);
 
    /*
     * Update metapage stats
     */
    buildstate.buildStats.nTotalPages = RelationGetNumberOfBlocks(index);
    ginUpdateStats(index, &buildstate.buildStats, true);
 
    /*
     * We didn't write WAL records as we built the index, so if WAL-logging is
     * required, write all pages to the WAL now.
     */
    if (RelationNeedsWAL(index))
    {
        log_newpage_range(index, MAIN_FORKNUM,
                          0, RelationGetNumberOfBlocks(index),
                          true);
    }
 
    /*
     * Return statistics
     */
    result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
 
    result->heap_tuples = reltuples;
    result->index_tuples = buildstate.indtuples;
 
    return result;
}

References _gin_begin_parallel(), _gin_end_parallel(), _gin_parallel_merge(), GinBuildState::accum, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, attnum, GinBuildState::bs_leader, GinBuildState::bs_numtuples, GinBuildState::bs_reltuples, GinBuildState::buildStats, CHECK_FOR_INTERRUPTS, CurrentMemoryContext, elog, END_CRIT_SECTION, ERROR, GinBuildState::funcCtx, GIN_LEAF, ginBeginBAScan(), ginBuildCallback(), ginEntryInsert(), ginGetBAEntry(), ginInitBA(), GinInitBuffer(), GinInitMetabuffer(), GinNewBuffer(), GinBuildState::ginstate, BuildAccumulator::ginstate, ginUpdateStats(), IndexBuildResult::heap_tuples, IndexInfo::ii_Concurrent, IndexInfo::ii_ParallelWorkers, IndexBuildResult::index_tuples, GinBuildState::indtuples, initGinState(), SortCoordinateData::isWorker, sort-test::key, sort-test::list, log_newpage_range(), MAIN_FORKNUM, maintenance_work_mem, MarkBufferDirty(), MemoryContextDelete(), MemoryContextSwitchTo(), GinStatsData::nEntryPages, SortCoordinateData::nParticipants, GinStatsData::nTotalPages, palloc(), palloc0(), pgstat_progress_update_param(), PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_GIN_PHASE_INDEXBUILD_TABLESCAN, RelationGetNumberOfBlocks, RelationGetRelationName, RelationNeedsWAL, SortCoordinateData::sharedsort, START_CRIT_SECTION, table_index_build_scan(), GinBuildState::tid, GinBuildState::tmpCtx, tuplesort_begin_index_gin(), TUPLESORT_NONE, and UnlockReleaseBuffer().

Referenced by ginhandler().

ginBuildCallback()

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

static

Definition at line 446 of file gininsert.c.

{
    GinBuildState *buildstate = (GinBuildState *) state;
    MemoryContext oldCtx;
    int         i;
 
    oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);
 
    for (i = 0; i < buildstate->ginstate.origTupdesc->natts; i++)
        ginHeapTupleBulkInsert(buildstate, (OffsetNumber) (i + 1),
                               values[i], isnull[i], tid);
 
    /* If we've maxed out our available memory, dump everything to the index */
    if (buildstate->accum.allocatedMemory >= maintenance_work_mem * (Size) 1024)
    {
        ItemPointerData *list;
        Datum       key;
        GinNullCategory category;
        uint32      nlist;
        OffsetNumber attnum;
 
        ginBeginBAScan(&buildstate->accum);
        while ((list = ginGetBAEntry(&buildstate->accum,
                                     &attnum, &key, &category, &nlist)) != NULL)
        {
            /* there could be many entries, so be willing to abort here */
            CHECK_FOR_INTERRUPTS();
            ginEntryInsert(&buildstate->ginstate, attnum, key, category,
                           list, nlist, &buildstate->buildStats);
        }
 
        MemoryContextReset(buildstate->tmpCtx);
        ginInitBA(&buildstate->accum);
    }
 
    MemoryContextSwitchTo(oldCtx);
}

References GinBuildState::accum, BuildAccumulator::allocatedMemory, attnum, GinBuildState::buildStats, CHECK_FOR_INTERRUPTS, ginBeginBAScan(), ginEntryInsert(), ginGetBAEntry(), ginHeapTupleBulkInsert(), ginInitBA(), GinBuildState::ginstate, i, sort-test::key, sort-test::list, maintenance_work_mem, MemoryContextReset(), MemoryContextSwitchTo(), TupleDescData::natts, GinState::origTupdesc, GinBuildState::tmpCtx, and values.

Referenced by ginbuild().

ginBuildCallbackParallel()

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

static

Definition at line 564 of file gininsert.c.

{
    GinBuildState *buildstate = (GinBuildState *) state;
    MemoryContext oldCtx;
    int         i;
 
    oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);
 
    /*
     * if scan wrapped around - flush accumulated entries and start anew
     *
     * With parallel scans, we don't have a guarantee the scan does not start
     * half-way through the relation (serial builds disable sync scans and
     * always start from block 0, parallel scans require allow_sync=true).
     *
     * Building the posting lists assumes the TIDs are monotonic and never go
     * back, and the wrap around would break that. We handle that by detecting
     * the wraparound, and flushing all entries. This means we'll later see
     * two separate entries with non-overlapping TID lists (which can be
     * combined by merge sort).
     *
     * To detect a wraparound, we remember the last TID seen by each worker
     * (for any key). If the next TID seen by the worker is lower, the scan
     * must have wrapped around.
     */
    if (ItemPointerCompare(tid, &buildstate->tid) < 0)
        ginFlushBuildState(buildstate, index);
 
    /* remember the TID we're about to process */
    buildstate->tid = *tid;
 
    for (i = 0; i < buildstate->ginstate.origTupdesc->natts; i++)
        ginHeapTupleBulkInsert(buildstate, (OffsetNumber) (i + 1),
                               values[i], isnull[i], tid);
 
    /*
     * If we've maxed out our available memory, dump everything to the
     * tuplesort. We use half the per-worker fraction of maintenance_work_mem,
     * the other half is used for the tuplesort.
     */
    if (buildstate->accum.allocatedMemory >= buildstate->work_mem * (Size) 1024)
        ginFlushBuildState(buildstate, index);
 
    MemoryContextSwitchTo(oldCtx);
}

References GinBuildState::accum, BuildAccumulator::allocatedMemory, ginFlushBuildState(), ginHeapTupleBulkInsert(), GinBuildState::ginstate, i, ItemPointerCompare(), MemoryContextSwitchTo(), TupleDescData::natts, GinState::origTupdesc, GinBuildState::tid, GinBuildState::tmpCtx, values, and GinBuildState::work_mem.

Referenced by _gin_parallel_scan_and_build().

ginbuildempty()

void ginbuildempty

(

Relation

index

)

Definition at line 806 of file gininsert.c.

{
    Buffer      RootBuffer,
                MetaBuffer;
 
    /* An empty GIN index has two pages. */
    MetaBuffer = ExtendBufferedRel(BMR_REL(index), INIT_FORKNUM, NULL,
                                   EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK);
    RootBuffer = ExtendBufferedRel(BMR_REL(index), INIT_FORKNUM, NULL,
                                   EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK);
 
    /* Initialize and xlog metabuffer and root buffer. */
    START_CRIT_SECTION();
    GinInitMetabuffer(MetaBuffer);
    MarkBufferDirty(MetaBuffer);
    log_newpage_buffer(MetaBuffer, true);
    GinInitBuffer(RootBuffer, GIN_LEAF);
    MarkBufferDirty(RootBuffer);
    log_newpage_buffer(RootBuffer, false);
    END_CRIT_SECTION();
 
    /* Unlock and release the buffers. */
    UnlockReleaseBuffer(MetaBuffer);
    UnlockReleaseBuffer(RootBuffer);
}

References BMR_REL, EB_LOCK_FIRST, EB_SKIP_EXTENSION_LOCK, END_CRIT_SECTION, ExtendBufferedRel(), GIN_LEAF, GinInitBuffer(), GinInitMetabuffer(), INIT_FORKNUM, log_newpage_buffer(), MarkBufferDirty(), START_CRIT_SECTION, and UnlockReleaseBuffer().

Referenced by ginhandler().

ginEntryInsert()

void ginEntryInsert	(	GinState *	ginstate,
		OffsetNumber	attnum,
		Datum	key,
		GinNullCategory	category,
		ItemPointerData *	items,
		uint32	nitem,
		GinStatsData *	buildStats
	)

Definition at line 345 of file gininsert.c.

{
    GinBtreeData btree;
    GinBtreeEntryInsertData insertdata;
    GinBtreeStack *stack;
    IndexTuple  itup;
    Page        page;
 
    insertdata.isDelete = false;
 
    ginPrepareEntryScan(&btree, attnum, key, category, ginstate);
    btree.isBuild = (buildStats != NULL);
 
    stack = ginFindLeafPage(&btree, false, false);
    page = BufferGetPage(stack->buffer);
 
    if (btree.findItem(&btree, stack))
    {
        /* found pre-existing entry */
        itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, stack->off));
 
        if (GinIsPostingTree(itup))
        {
            /* add entries to existing posting tree */
            BlockNumber rootPostingTree = GinGetPostingTree(itup);
 
            /* release all stack */
            LockBuffer(stack->buffer, GIN_UNLOCK);
            freeGinBtreeStack(stack);
 
            /* insert into posting tree */
            ginInsertItemPointers(ginstate->index, rootPostingTree,
                                  items, nitem,
                                  buildStats);
            return;
        }
 
        CheckForSerializableConflictIn(ginstate->index, NULL,
                                       BufferGetBlockNumber(stack->buffer));
        /* modify an existing leaf entry */
        itup = addItemPointersToLeafTuple(ginstate, itup,
                                          items, nitem, buildStats, stack->buffer);
 
        insertdata.isDelete = true;
    }
    else
    {
        CheckForSerializableConflictIn(ginstate->index, NULL,
                                       BufferGetBlockNumber(stack->buffer));
        /* no match, so construct a new leaf entry */
        itup = buildFreshLeafTuple(ginstate, attnum, key, category,
                                   items, nitem, buildStats, stack->buffer);
 
        /*
         * nEntries counts leaf tuples, so increment it only when we make a
         * new one.
         */
        if (buildStats)
            buildStats->nEntries++;
    }
 
    /* Insert the new or modified leaf tuple */
    insertdata.entry = itup;
    ginInsertValue(&btree, stack, &insertdata, buildStats);
    pfree(itup);
}

References addItemPointersToLeafTuple(), attnum, GinBtreeStack::buffer, BufferGetBlockNumber(), BufferGetPage(), buildFreshLeafTuple(), CheckForSerializableConflictIn(), GinBtreeEntryInsertData::entry, GinBtreeData::findItem, freeGinBtreeStack(), GIN_UNLOCK, ginFindLeafPage(), GinGetPostingTree, ginInsertItemPointers(), ginInsertValue(), GinIsPostingTree, ginPrepareEntryScan(), GinState::index, GinBtreeData::isBuild, GinBtreeEntryInsertData::isDelete, items, sort-test::key, LockBuffer(), GinStatsData::nEntries, GinBtreeStack::off, PageGetItem(), PageGetItemId(), and pfree().

Referenced by _gin_parallel_merge(), ginbuild(), ginBuildCallback(), ginHeapTupleInsert(), and ginInsertCleanup().

ginFlushBuildState()

static void ginFlushBuildState ( GinBuildState *  buildstate, Relation  index  )

static

Definition at line 499 of file gininsert.c.

{
    ItemPointerData *list;
    Datum       key;
    GinNullCategory category;
    uint32      nlist;
    OffsetNumber attnum;
    TupleDesc   tdesc = RelationGetDescr(index);
    uint32      maxlen;
 
    /* maximum number of TIDs per chunk (two chunks per worker) */
    maxlen = MaxAllocSize / sizeof(ItemPointerData);
    maxlen /= (2 * buildstate->bs_num_workers);
 
    ginBeginBAScan(&buildstate->accum);
    while ((list = ginGetBAEntry(&buildstate->accum,
                                 &attnum, &key, &category, &nlist)) != NULL)
    {
        /* information about the key */
        CompactAttribute *attr = TupleDescCompactAttr(tdesc, (attnum - 1));
 
        /* start of the chunk */
        uint32      offset = 0;
 
        /* split the entry into smaller chunk with up to maxlen items */
        while (offset < nlist)
        {
            /* GIN tuple and tuple length */
            GinTuple   *tup;
            Size        tuplen;
            uint32      len = Min(maxlen, nlist - offset);
 
            /* there could be many entries, so be willing to abort here */
            CHECK_FOR_INTERRUPTS();
 
            tup = _gin_build_tuple(attnum, category,
                                   key, attr->attlen, attr->attbyval,
                                   &list[offset], len,
                                   &tuplen);
 
            offset += len;
 
            tuplesort_putgintuple(buildstate->bs_worker_sort, tup, tuplen);
 
            pfree(tup);
        }
    }
 
    MemoryContextReset(buildstate->tmpCtx);
    ginInitBA(&buildstate->accum);
}

References _gin_build_tuple(), GinBuildState::accum, CompactAttribute::attbyval, CompactAttribute::attlen, attnum, GinBuildState::bs_num_workers, GinBuildState::bs_worker_sort, CHECK_FOR_INTERRUPTS, ginBeginBAScan(), ginGetBAEntry(), ginInitBA(), sort-test::key, len, sort-test::list, MaxAllocSize, MemoryContextReset(), Min, pfree(), RelationGetDescr, GinBuildState::tmpCtx, TupleDescCompactAttr(), and tuplesort_putgintuple().

Referenced by _gin_parallel_scan_and_build(), and ginBuildCallbackParallel().

ginHeapTupleBulkInsert()

static void ginHeapTupleBulkInsert ( GinBuildState *  buildstate, OffsetNumber  attnum, Datum  value, bool  isNull, ItemPointer  heapptr  )

static

Definition at line 422 of file gininsert.c.

{
    Datum      *entries;
    GinNullCategory *categories;
    int32       nentries;
    MemoryContext oldCtx;
 
    oldCtx = MemoryContextSwitchTo(buildstate->funcCtx);
    entries = ginExtractEntries(buildstate->accum.ginstate, attnum,
                                value, isNull,
                                &nentries, &categories);
    MemoryContextSwitchTo(oldCtx);
 
    ginInsertBAEntries(&buildstate->accum, heapptr, attnum,
                       entries, categories, nentries);
 
    buildstate->indtuples += nentries;
 
    MemoryContextReset(buildstate->funcCtx);
}

References GinBuildState::accum, attnum, GinBuildState::funcCtx, ginExtractEntries(), ginInsertBAEntries(), BuildAccumulator::ginstate, GinBuildState::indtuples, MemoryContextReset(), MemoryContextSwitchTo(), and value.

Referenced by ginBuildCallback(), and ginBuildCallbackParallel().

ginHeapTupleInsert()

static void ginHeapTupleInsert ( GinState *  ginstate, OffsetNumber  attnum, Datum  value, bool  isNull, ItemPointer  item  )

static

Definition at line 837 of file gininsert.c.

{
    Datum      *entries;
    GinNullCategory *categories;
    int32       i,
                nentries;
 
    entries = ginExtractEntries(ginstate, attnum, value, isNull,
                                &nentries, &categories);
 
    for (i = 0; i < nentries; i++)
        ginEntryInsert(ginstate, attnum, entries[i], categories[i],
                       item, 1, NULL);
}

References attnum, ginEntryInsert(), ginExtractEntries(), i, and value.

Referenced by gininsert().

gininsert()

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

Definition at line 855 of file gininsert.c.

{
    GinState   *ginstate = (GinState *) indexInfo->ii_AmCache;
    MemoryContext oldCtx;
    MemoryContext insertCtx;
    int         i;
 
    /* Initialize GinState cache if first call in this statement */
    if (ginstate == NULL)
    {
        oldCtx = MemoryContextSwitchTo(indexInfo->ii_Context);
        ginstate = (GinState *) palloc(sizeof(GinState));
        initGinState(ginstate, index);
        indexInfo->ii_AmCache = ginstate;
        MemoryContextSwitchTo(oldCtx);
    }
 
    insertCtx = AllocSetContextCreate(CurrentMemoryContext,
                                      "Gin insert temporary context",
                                      ALLOCSET_DEFAULT_SIZES);
 
    oldCtx = MemoryContextSwitchTo(insertCtx);
 
    if (GinGetUseFastUpdate(index))
    {
        GinTupleCollector collector;
 
        memset(&collector, 0, sizeof(GinTupleCollector));
 
        for (i = 0; i < ginstate->origTupdesc->natts; i++)
            ginHeapTupleFastCollect(ginstate, &collector,
                                    (OffsetNumber) (i + 1),
                                    values[i], isnull[i],
                                    ht_ctid);
 
        ginHeapTupleFastInsert(ginstate, &collector);
    }
    else
    {
        for (i = 0; i < ginstate->origTupdesc->natts; i++)
            ginHeapTupleInsert(ginstate, (OffsetNumber) (i + 1),
                               values[i], isnull[i],
                               ht_ctid);
    }
 
    MemoryContextSwitchTo(oldCtx);
    MemoryContextDelete(insertCtx);
 
    return false;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, CurrentMemoryContext, GinGetUseFastUpdate, ginHeapTupleFastCollect(), ginHeapTupleFastInsert(), ginHeapTupleInsert(), i, if(), IndexInfo::ii_AmCache, IndexInfo::ii_Context, initGinState(), MemoryContextDelete(), MemoryContextSwitchTo(), TupleDescData::natts, GinState::origTupdesc, palloc(), and values.

Referenced by ginhandler().