gin_private.h File Reference

#include "access/amapi.h"
#include "access/gin.h"
#include "access/ginblock.h"
#include "access/htup_details.h"
#include "access/itup.h"
#include "common/int.h"
#include "catalog/pg_am_d.h"
#include "fmgr.h"
#include "lib/rbtree.h"
#include "nodes/tidbitmap.h"
#include "storage/bufmgr.h"

Include dependency graph for gin_private.h:

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

Go to the source code of this file.

Data Structures
struct	GinOptions
struct	GinState
struct	GinBtreeStack
struct	GinBtreeData
struct	GinBtreeEntryInsertData
struct	GinBtreeDataLeafInsertData
struct	GinScanKeyData
struct	GinScanEntryData
struct	GinScanOpaqueData
struct	GinEntryAccumulator
struct	BuildAccumulator
struct	GinTupleCollector

Macros
#define	GIN_DEFAULT_USE_FASTUPDATE   true
#define	GinGetUseFastUpdate(relation)
#define	GinGetPendingListCleanupSize(relation)
#define	GIN_UNLOCK   BUFFER_LOCK_UNLOCK
#define	GIN_SHARE   BUFFER_LOCK_SHARE
#define	GIN_EXCLUSIVE   BUFFER_LOCK_EXCLUSIVE

Typedefs
typedef struct GinOptions	GinOptions
typedef struct GinState	GinState
typedef struct GinBtreeStack	GinBtreeStack
typedef struct GinBtreeData *	GinBtree
typedef struct GinBtreeData	GinBtreeData
typedef struct GinVacuumState	GinVacuumState
typedef struct GinScanKeyData *	GinScanKey
typedef struct GinScanEntryData *	GinScanEntry
typedef struct GinScanKeyData	GinScanKeyData
typedef struct GinScanEntryData	GinScanEntryData
typedef struct GinScanOpaqueData	GinScanOpaqueData
typedef GinScanOpaqueData *	GinScanOpaque
typedef struct GinEntryAccumulator	GinEntryAccumulator
typedef struct GinTupleCollector	GinTupleCollector

Enumerations
enum	GinPlaceToPageRC { GPTP_NO_WORK , GPTP_INSERT , GPTP_SPLIT }

Functions
bytea *	ginoptions (Datum reloptions, bool validate)
void	initGinState (GinState *state, Relation index)
Buffer	GinNewBuffer (Relation index)
void	GinInitBuffer (Buffer b, uint32 f)
void	GinInitPage (Page page, uint32 f, Size pageSize)
void	GinInitMetabuffer (Buffer b)
Datum *	ginExtractEntries (GinState *ginstate, OffsetNumber attnum, Datum value, bool isNull, int32 *nentries, GinNullCategory **categories)
OffsetNumber	gintuple_get_attrnum (GinState *ginstate, IndexTuple tuple)
Datum	gintuple_get_key (GinState *ginstate, IndexTuple tuple, GinNullCategory *category)
char *	ginbuildphasename (int64 phasenum)
IndexBuildResult *	ginbuild (Relation heap, Relation index, struct IndexInfo *indexInfo)
void	ginbuildempty (Relation index)
bool	gininsert (Relation index, Datum *values, bool *isnull, ItemPointer ht_ctid, Relation heapRel, IndexUniqueCheck checkUnique, bool indexUnchanged, struct IndexInfo *indexInfo)
void	ginEntryInsert (GinState *ginstate, OffsetNumber attnum, Datum key, GinNullCategory category, ItemPointerData *items, uint32 nitem, GinStatsData *buildStats)
GinBtreeStack *	ginFindLeafPage (GinBtree btree, bool searchMode, bool rootConflictCheck)
Buffer	ginStepRight (Buffer buffer, Relation index, int lockmode)
void	freeGinBtreeStack (GinBtreeStack *stack)
void	ginInsertValue (GinBtree btree, GinBtreeStack *stack, void *insertdata, GinStatsData *buildStats)
IndexTuple	GinFormTuple (GinState *ginstate, OffsetNumber attnum, Datum key, GinNullCategory category, Pointer data, Size dataSize, int nipd, bool errorTooBig)
void	ginPrepareEntryScan (GinBtree btree, OffsetNumber attnum, Datum key, GinNullCategory category, GinState *ginstate)
void	ginEntryFillRoot (GinBtree btree, Page root, BlockNumber lblkno, Page lpage, BlockNumber rblkno, Page rpage)
ItemPointer	ginReadTuple (GinState *ginstate, OffsetNumber attnum, IndexTuple itup, int *nitems)
ItemPointer	GinDataLeafPageGetItems (Page page, int *nitems, ItemPointerData advancePast)
int	GinDataLeafPageGetItemsToTbm (Page page, TIDBitmap *tbm)
BlockNumber	createPostingTree (Relation index, ItemPointerData *items, uint32 nitems, GinStatsData *buildStats, Buffer entrybuffer)
void	GinDataPageAddPostingItem (Page page, PostingItem *data, OffsetNumber offset)
void	GinPageDeletePostingItem (Page page, OffsetNumber offset)
void	ginInsertItemPointers (Relation index, BlockNumber rootBlkno, ItemPointerData *items, uint32 nitem, GinStatsData *buildStats)
GinBtreeStack *	ginScanBeginPostingTree (GinBtree btree, Relation index, BlockNumber rootBlkno)
void	ginDataFillRoot (GinBtree btree, Page root, BlockNumber lblkno, Page lpage, BlockNumber rblkno, Page rpage)
void	ginVacuumPostingTreeLeaf (Relation indexrel, Buffer buffer, GinVacuumState *gvs)
IndexScanDesc	ginbeginscan (Relation rel, int nkeys, int norderbys)
void	ginendscan (IndexScanDesc scan)
void	ginrescan (IndexScanDesc scan, ScanKey scankey, int nscankeys, ScanKey orderbys, int norderbys)
void	ginNewScanKey (IndexScanDesc scan)
void	ginFreeScanKeys (GinScanOpaque so)
int64	gingetbitmap (IndexScanDesc scan, TIDBitmap *tbm)
void	ginInitConsistentFunction (GinState *ginstate, GinScanKey key)
IndexBulkDeleteResult *	ginbulkdelete (IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
IndexBulkDeleteResult *	ginvacuumcleanup (IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
ItemPointer	ginVacuumItemPointers (GinVacuumState *gvs, ItemPointerData *items, int nitem, int *nremaining)
bool	ginvalidate (Oid opclassoid)
void	ginadjustmembers (Oid opfamilyoid, Oid opclassoid, List *operators, List *functions)
void	ginInitBA (BuildAccumulator *accum)
void	ginInsertBAEntries (BuildAccumulator *accum, ItemPointer heapptr, OffsetNumber attnum, Datum *entries, GinNullCategory *categories, int32 nentries)
void	ginBeginBAScan (BuildAccumulator *accum)
ItemPointerData *	ginGetBAEntry (BuildAccumulator *accum, OffsetNumber *attnum, Datum *key, GinNullCategory *category, uint32 *n)
void	ginHeapTupleFastInsert (GinState *ginstate, GinTupleCollector *collector)
void	ginHeapTupleFastCollect (GinState *ginstate, GinTupleCollector *collector, OffsetNumber attnum, Datum value, bool isNull, ItemPointer ht_ctid)
void	ginInsertCleanup (GinState *ginstate, bool full_clean, bool fill_fsm, bool forceCleanup, IndexBulkDeleteResult *stats)
GinPostingList *	ginCompressPostingList (const ItemPointerData *ipd, int nipd, int maxsize, int *nwritten)
int	ginPostingListDecodeAllSegmentsToTbm (GinPostingList *ptr, int len, TIDBitmap *tbm)
ItemPointer	ginPostingListDecodeAllSegments (GinPostingList *segment, int len, int *ndecoded_out)
ItemPointer	ginPostingListDecode (GinPostingList *plist, int *ndecoded_out)
ItemPointer	ginMergeItemPointers (ItemPointerData *a, uint32 na, ItemPointerData *b, uint32 nb, int *nmerged)
static int	ginCompareItemPointers (const ItemPointerData *a, const ItemPointerData *b)
static int	ginCompareEntries (GinState *ginstate, OffsetNumber attnum, Datum a, GinNullCategory categorya, Datum b, GinNullCategory categoryb)
static int	ginCompareAttEntries (GinState *ginstate, OffsetNumber attnuma, Datum a, GinNullCategory categorya, OffsetNumber attnumb, Datum b, GinNullCategory categoryb)
int	ginTraverseLock (Buffer buffer, bool searchMode)

Macro Definition Documentation

GIN_DEFAULT_USE_FASTUPDATE

#define GIN_DEFAULT_USE_FASTUPDATE   true

Definition at line 35 of file gin_private.h.

GIN_EXCLUSIVE

#define GIN_EXCLUSIVE   BUFFER_LOCK_EXCLUSIVE

Definition at line 53 of file gin_private.h.

GIN_SHARE

#define GIN_SHARE   BUFFER_LOCK_SHARE

Definition at line 52 of file gin_private.h.

GIN_UNLOCK

#define GIN_UNLOCK   BUFFER_LOCK_UNLOCK

Definition at line 51 of file gin_private.h.

GinGetPendingListCleanupSize

#define GinGetPendingListCleanupSize

(

relation

)

Value:

    (AssertMacro(relation->rd_rel->relkind == RELKIND_INDEX && \
                 relation->rd_rel->relam == GIN_AM_OID), \
     (relation)->rd_options && \
     ((GinOptions *) (relation)->rd_options)->pendingListCleanupSize != -1 ? \
     ((GinOptions *) (relation)->rd_options)->pendingListCleanupSize : \
     gin_pending_list_limit)

Definition at line 41 of file gin_private.h.

                                                                     : \
     gin_pending_list_limit)

GinGetUseFastUpdate

#define GinGetUseFastUpdate

(

relation

)

Value:

    (AssertMacro(relation->rd_rel->relkind == RELKIND_INDEX && \
                 relation->rd_rel->relam == GIN_AM_OID), \
     (relation)->rd_options ? \
     ((GinOptions *) (relation)->rd_options)->useFastUpdate : GIN_DEFAULT_USE_FASTUPDATE)

Definition at line 36 of file gin_private.h.

                                                            : GIN_DEFAULT_USE_FASTUPDATE)

Typedef Documentation

GinBtree

typedef struct GinBtreeData* GinBtree

Definition at line 137 of file gin_private.h.

GinBtreeData

typedef struct GinBtreeData GinBtreeData

GinBtreeStack

typedef struct GinBtreeStack GinBtreeStack

GinEntryAccumulator

typedef struct GinEntryAccumulator GinEntryAccumulator

GinOptions

typedef struct GinOptions GinOptions

GinScanEntry

typedef struct GinScanEntryData* GinScanEntry

Definition at line 263 of file gin_private.h.

GinScanEntryData

typedef struct GinScanEntryData GinScanEntryData

GinScanKey

typedef struct GinScanKeyData* GinScanKey

Definition at line 261 of file gin_private.h.

GinScanKeyData

typedef struct GinScanKeyData GinScanKeyData

GinScanOpaque

typedef GinScanOpaqueData* GinScanOpaque

Definition at line 390 of file gin_private.h.

GinScanOpaqueData

typedef struct GinScanOpaqueData GinScanOpaqueData

GinState

typedef struct GinState GinState

GinTupleCollector

typedef struct GinTupleCollector GinTupleCollector

GinVacuumState

typedef struct GinVacuumState GinVacuumState

Definition at line 239 of file gin_private.h.

Enumeration Type Documentation

GinPlaceToPageRC

enum GinPlaceToPageRC

Enumerator
GPTP_NO_WORK
GPTP_INSERT
GPTP_SPLIT

Definition at line 140 of file gin_private.h.

{
    GPTP_NO_WORK,
    GPTP_INSERT,
    GPTP_SPLIT,
} GinPlaceToPageRC;

Function Documentation

createPostingTree()

BlockNumber createPostingTree ( Relation  index, ItemPointerData *  items, uint32  nitems, GinStatsData *  buildStats, Buffer  entrybuffer  )

extern

Definition at line 1775 of file gindatapage.c.

{
    BlockNumber blkno;
    Buffer      buffer;
    Page        tmppage;
    Page        page;
    char       *ptr;
    int         nrootitems;
    int         rootsize;
    bool        is_build = (buildStats != NULL);
 
    /* Construct the new root page in memory first. */
    tmppage = (Page) palloc(BLCKSZ);
    GinInitPage(tmppage, GIN_DATA | GIN_LEAF | GIN_COMPRESSED, BLCKSZ);
    GinPageGetOpaque(tmppage)->rightlink = InvalidBlockNumber;
 
    /*
     * Write as many of the items to the root page as fit. In segments of max
     * GinPostingListSegmentMaxSize bytes each.
     */
    nrootitems = 0;
    rootsize = 0;
    ptr = (char *) GinDataLeafPageGetPostingList(tmppage);
    while (nrootitems < nitems)
    {
        GinPostingList *segment;
        int         npacked;
        int         segsize;
 
        segment = ginCompressPostingList(&items[nrootitems],
                                         nitems - nrootitems,
                                         GinPostingListSegmentMaxSize,
                                         &npacked);
        segsize = SizeOfGinPostingList(segment);
        if (rootsize + segsize > GinDataPageMaxDataSize)
            break;
 
        memcpy(ptr, segment, segsize);
        ptr += segsize;
        rootsize += segsize;
        nrootitems += npacked;
        pfree(segment);
    }
    GinDataPageSetDataSize(tmppage, rootsize);
 
    /*
     * All set. Get a new physical page, and copy the in-memory page to it.
     */
    buffer = GinNewBuffer(index);
    page = BufferGetPage(buffer);
    blkno = BufferGetBlockNumber(buffer);
 
    /*
     * Copy any predicate locks from the entry tree leaf (containing posting
     * list) to the posting tree.
     */
    PredicateLockPageSplit(index, BufferGetBlockNumber(entrybuffer), blkno);
 
    START_CRIT_SECTION();
 
    PageRestoreTempPage(tmppage, page);
    MarkBufferDirty(buffer);
 
    if (RelationNeedsWAL(index) && !is_build)
    {
        XLogRecPtr  recptr;
        ginxlogCreatePostingTree data;
 
        data.size = rootsize;
 
        XLogBeginInsert();
        XLogRegisterData(&data, sizeof(ginxlogCreatePostingTree));
 
        XLogRegisterData(GinDataLeafPageGetPostingList(page),
                         rootsize);
        XLogRegisterBuffer(0, buffer, REGBUF_WILL_INIT);
 
        recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_CREATE_PTREE);
        PageSetLSN(page, recptr);
    }
 
    END_CRIT_SECTION();
 
    UnlockReleaseBuffer(buffer);
 
    /* During index build, count the newly-added data page */
    if (buildStats)
        buildStats->nDataPages++;
 
    elog(DEBUG2, "created GIN posting tree with %d items", nrootitems);
 
    /*
     * Add any remaining TIDs to the newly-created posting tree.
     */
    if (nitems > nrootitems)
    {
        ginInsertItemPointers(index, blkno,
                              items + nrootitems,
                              nitems - nrootitems,
                              buildStats);
    }
 
    return blkno;
}

References BufferGetBlockNumber(), BufferGetPage(), data, DEBUG2, elog, END_CRIT_SECTION, fb(), GIN_COMPRESSED, GIN_DATA, GIN_LEAF, ginCompressPostingList(), GinDataLeafPageGetPostingList, GinDataPageMaxDataSize, GinDataPageSetDataSize, GinInitPage(), ginInsertItemPointers(), GinNewBuffer(), GinPageGetOpaque, GinPostingListSegmentMaxSize, InvalidBlockNumber, items, MarkBufferDirty(), GinStatsData::nDataPages, nitems, PageRestoreTempPage(), PageSetLSN(), palloc(), pfree(), PredicateLockPageSplit(), REGBUF_WILL_INIT, RelationNeedsWAL, ginxlogCreatePostingTree::size, SizeOfGinPostingList, START_CRIT_SECTION, UnlockReleaseBuffer(), XLOG_GIN_CREATE_PTREE, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by addItemPointersToLeafTuple(), and buildFreshLeafTuple().

freeGinBtreeStack()

void freeGinBtreeStack ( GinBtreeStack *  stack )

extern

Definition at line 198 of file ginbtree.c.

{
    while (stack)
    {
        GinBtreeStack *tmp = stack->parent;
 
        if (stack->buffer != InvalidBuffer)
            ReleaseBuffer(stack->buffer);
 
        pfree(stack);
        stack = tmp;
    }
}

References GinBtreeStack::buffer, InvalidBuffer, GinBtreeStack::parent, pfree(), and ReleaseBuffer().

Referenced by entryLoadMoreItems(), ginEntryInsert(), ginFinishSplit(), ginInsertValue(), scanPostingTree(), and startScanEntry().

ginadjustmembers()

void ginadjustmembers ( Oid  opfamilyoid, Oid  opclassoid, List *  operators, List *  functions  )

extern

Definition at line 269 of file ginvalidate.c.

{
    ListCell   *lc;
 
    /*
     * Operator members of a GIN opfamily should never have hard dependencies,
     * since their connection to the opfamily depends only on what the support
     * functions think, and that can be altered.  For consistency, we make all
     * soft dependencies point to the opfamily, though a soft dependency on
     * the opclass would work as well in the CREATE OPERATOR CLASS case.
     */
    foreach(lc, operators)
    {
        OpFamilyMember *op = (OpFamilyMember *) lfirst(lc);
 
        op->ref_is_hard = false;
        op->ref_is_family = true;
        op->refobjid = opfamilyoid;
    }
 
    /*
     * Required support functions should have hard dependencies.  Preferably
     * those are just dependencies on the opclass, but if we're in ALTER
     * OPERATOR FAMILY, we leave the dependency pointing at the whole
     * opfamily.  (Given that GIN opclasses generally don't share opfamilies,
     * it seems unlikely to be worth working harder.)
     */
    foreach(lc, functions)
    {
        OpFamilyMember *op = (OpFamilyMember *) lfirst(lc);
 
        switch (op->number)
        {
            case GIN_EXTRACTVALUE_PROC:
            case GIN_EXTRACTQUERY_PROC:
                /* Required support function */
                op->ref_is_hard = true;
                break;
            case GIN_COMPARE_PROC:
            case GIN_CONSISTENT_PROC:
            case GIN_COMPARE_PARTIAL_PROC:
            case GIN_TRICONSISTENT_PROC:
            case GIN_OPTIONS_PROC:
                /* Optional, so force it to be a soft family dependency */
                op->ref_is_hard = false;
                op->ref_is_family = true;
                op->refobjid = opfamilyoid;
                break;
            default:
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("support function number %d is invalid for access method %s",
                                op->number, "gin")));
                break;
        }
    }
}

References ereport, errcode(), errmsg, ERROR, fb(), functions, GIN_COMPARE_PARTIAL_PROC, GIN_COMPARE_PROC, GIN_CONSISTENT_PROC, GIN_EXTRACTQUERY_PROC, GIN_EXTRACTVALUE_PROC, GIN_OPTIONS_PROC, GIN_TRICONSISTENT_PROC, lfirst, OpFamilyMember::number, OpFamilyMember::ref_is_family, OpFamilyMember::ref_is_hard, and OpFamilyMember::refobjid.

Referenced by ginhandler().

ginBeginBAScan()

void ginBeginBAScan ( BuildAccumulator *  accum )

extern

Definition at line 256 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().

ginbeginscan()

IndexScanDesc ginbeginscan ( Relation  rel, int  nkeys, int  norderbys  )

extern

Definition at line 26 of file ginscan.c.

{
    IndexScanDesc scan;
    GinScanOpaque so;
 
    /* no order by operators allowed */
    Assert(norderbys == 0);
 
    scan = RelationGetIndexScan(rel, nkeys, norderbys);
 
    /* allocate private workspace */
    so = (GinScanOpaque) palloc_object(GinScanOpaqueData);
    so->keys = NULL;
    so->nkeys = 0;
    so->tempCtx = AllocSetContextCreate(CurrentMemoryContext,
                                        "Gin scan temporary context",
                                        ALLOCSET_DEFAULT_SIZES);
    so->keyCtx = AllocSetContextCreate(CurrentMemoryContext,
                                       "Gin scan key context",
                                       ALLOCSET_DEFAULT_SIZES);
    initGinState(&so->ginstate, scan->indexRelation);
 
    scan->opaque = so;
 
    return scan;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, CurrentMemoryContext, fb(), IndexScanDescData::indexRelation, initGinState(), IndexScanDescData::opaque, palloc_object, and RelationGetIndexScan().

Referenced by ginhandler().

ginbuild()

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

extern

Definition at line 618 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 = palloc0_object(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 = palloc_object(IndexBuildResult);
 
    result->heap_tuples = reltuples;
    result->index_tuples = buildstate.indtuples;
 
    return result;
}

References _gin_begin_parallel(), _gin_end_parallel(), _gin_parallel_merge(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, attnum, CHECK_FOR_INTERRUPTS, CurrentMemoryContext, elog, END_CRIT_SECTION, ERROR, fb(), GIN_LEAF, ginBeginBAScan(), ginBuildCallback(), ginEntryInsert(), ginGetBAEntry(), ginInitBA(), GinInitBuffer(), GinInitMetabuffer(), GinNewBuffer(), ginUpdateStats(), IndexBuildResult::heap_tuples, IndexInfo::ii_Concurrent, IndexInfo::ii_ParallelWorkers, IndexBuildResult::index_tuples, initGinState(), log_newpage_range(), MAIN_FORKNUM, maintenance_work_mem, MarkBufferDirty(), MemoryContextDelete(), MemoryContextSwitchTo(), palloc0_object, palloc_object, pgstat_progress_update_param(), PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_GIN_PHASE_INDEXBUILD_TABLESCAN, RelationGetNumberOfBlocks, RelationGetRelationName, RelationNeedsWAL, START_CRIT_SECTION, table_index_build_scan(), tuplesort_begin_index_gin(), TUPLESORT_NONE, and UnlockReleaseBuffer().

Referenced by ginhandler().

ginbuildempty()

void ginbuildempty ( Relation  index )

extern

Definition at line 812 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(), fb(), GIN_LEAF, GinInitBuffer(), GinInitMetabuffer(), INIT_FORKNUM, log_newpage_buffer(), MarkBufferDirty(), START_CRIT_SECTION, and UnlockReleaseBuffer().

Referenced by ginhandler().

ginbuildphasename()

char * ginbuildphasename ( int64  phasenum )

extern

Definition at line 676 of file ginutil.c.

{
    switch (phasenum)
    {
        case PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE:
            return "initializing";
        case PROGRESS_GIN_PHASE_INDEXBUILD_TABLESCAN:
            return "scanning table";
        case PROGRESS_GIN_PHASE_PERFORMSORT_1:
            return "sorting tuples (workers)";
        case PROGRESS_GIN_PHASE_MERGE_1:
            return "merging tuples (workers)";
        case PROGRESS_GIN_PHASE_PERFORMSORT_2:
            return "sorting tuples";
        case PROGRESS_GIN_PHASE_MERGE_2:
            return "merging tuples";
        default:
            return NULL;
    }
}

References fb(), PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE, PROGRESS_GIN_PHASE_INDEXBUILD_TABLESCAN, PROGRESS_GIN_PHASE_MERGE_1, PROGRESS_GIN_PHASE_MERGE_2, PROGRESS_GIN_PHASE_PERFORMSORT_1, and PROGRESS_GIN_PHASE_PERFORMSORT_2.

Referenced by ginhandler().

ginbulkdelete()

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

extern

Definition at line 602 of file ginvacuum.c.

{
    Relation    index = info->index;
    BlockNumber blkno = GIN_ROOT_BLKNO;
    GinVacuumState gvs;
    Buffer      buffer;
    BlockNumber rootOfPostingTree[BLCKSZ / (sizeof(IndexTupleData) + sizeof(ItemId))];
    uint32      nRoot;
 
    gvs.tmpCxt = AllocSetContextCreate(CurrentMemoryContext,
                                       "Gin vacuum temporary context",
                                       ALLOCSET_DEFAULT_SIZES);
    gvs.index = index;
    gvs.callback = callback;
    gvs.callback_state = callback_state;
    gvs.strategy = info->strategy;
    initGinState(&gvs.ginstate, index);
 
    /* first time through? */
    if (stats == NULL)
    {
        /* Yes, so initialize stats to zeroes */
        stats = palloc0_object(IndexBulkDeleteResult);
 
        /*
         * and cleanup any pending inserts
         */
        ginInsertCleanup(&gvs.ginstate, !AmAutoVacuumWorkerProcess(),
                         false, true, stats);
    }
 
    /* we'll re-count the tuples each time */
    stats->num_index_tuples = 0;
    gvs.result = stats;
 
    buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
                                RBM_NORMAL, info->strategy);
 
    /* find leaf page */
    for (;;)
    {
        Page        page = BufferGetPage(buffer);
        IndexTuple  itup;
 
        LockBuffer(buffer, GIN_SHARE);
 
        Assert(!GinPageIsData(page));
 
        if (GinPageIsLeaf(page))
        {
            LockBuffer(buffer, GIN_UNLOCK);
            LockBuffer(buffer, GIN_EXCLUSIVE);
 
            if (blkno == GIN_ROOT_BLKNO && !GinPageIsLeaf(page))
            {
                LockBuffer(buffer, GIN_UNLOCK);
                continue;       /* check it one more */
            }
            break;
        }
 
        Assert(PageGetMaxOffsetNumber(page) >= FirstOffsetNumber);
 
        itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, FirstOffsetNumber));
        blkno = GinGetDownlink(itup);
        Assert(blkno != InvalidBlockNumber);
 
        UnlockReleaseBuffer(buffer);
        buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
                                    RBM_NORMAL, info->strategy);
    }
 
    /* right now we found leftmost page in entry's BTree */
 
    for (;;)
    {
        Page        page = BufferGetPage(buffer);
        Page        resPage;
        uint32      i;
 
        Assert(!GinPageIsData(page));
 
        resPage = ginVacuumEntryPage(&gvs, buffer, rootOfPostingTree, &nRoot);
 
        blkno = GinPageGetOpaque(page)->rightlink;
 
        if (resPage)
        {
            START_CRIT_SECTION();
            PageRestoreTempPage(resPage, page);
            MarkBufferDirty(buffer);
            xlogVacuumPage(gvs.index, buffer);
            END_CRIT_SECTION();
            UnlockReleaseBuffer(buffer);
        }
        else
        {
            UnlockReleaseBuffer(buffer);
        }
 
        vacuum_delay_point(false);
 
        for (i = 0; i < nRoot; i++)
        {
            ginVacuumPostingTree(&gvs, rootOfPostingTree[i]);
            vacuum_delay_point(false);
        }
 
        if (blkno == InvalidBlockNumber)    /* rightmost page */
            break;
 
        buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
                                    RBM_NORMAL, info->strategy);
        LockBuffer(buffer, GIN_EXCLUSIVE);
    }
 
    MemoryContextDelete(gvs.tmpCxt);
 
    return gvs.result;
}

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AmAutoVacuumWorkerProcess, Assert, DataPageDeleteStack::buffer, BufferGetPage(), callback(), CurrentMemoryContext, END_CRIT_SECTION, fb(), FirstOffsetNumber, GIN_EXCLUSIVE, GIN_ROOT_BLKNO, GIN_SHARE, GIN_UNLOCK, GinGetDownlink, ginInsertCleanup(), GinPageGetOpaque, GinPageIsData, GinPageIsLeaf, ginVacuumEntryPage(), ginVacuumPostingTree(), i, IndexVacuumInfo::index, initGinState(), InvalidBlockNumber, LockBuffer(), MAIN_FORKNUM, MarkBufferDirty(), MemoryContextDelete(), IndexBulkDeleteResult::num_index_tuples, PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), PageRestoreTempPage(), palloc0_object, RBM_NORMAL, ReadBufferExtended(), START_CRIT_SECTION, IndexVacuumInfo::strategy, GinVacuumState::tmpCxt, UnlockReleaseBuffer(), vacuum_delay_point(), and xlogVacuumPage().

Referenced by ginhandler().

ginCompareAttEntries()

static int ginCompareAttEntries ( GinState *  ginstate, OffsetNumber  attnuma, Datum  a, GinNullCategory  categorya, OffsetNumber  attnumb, Datum  b, GinNullCategory  categoryb  )

inlinestatic

Definition at line 526 of file gin_private.h.

{
    /* attribute number is the first sort key */
    if (attnuma != attnumb)
        return (attnuma < attnumb) ? -1 : 1;
 
    return ginCompareEntries(ginstate, attnuma, a, categorya, b, categoryb);
 
}

References a, b, fb(), and ginCompareEntries().

Referenced by cmpEntryAccumulator(), entryIsMoveRight(), entryLocateEntry(), entryLocateLeafEntry(), and gin_check_parent_keys_consistency().

ginCompareEntries()

static int ginCompareEntries ( GinState *  ginstate, OffsetNumber  attnum, Datum  a, GinNullCategory  categorya, Datum  b, GinNullCategory  categoryb  )

inlinestatic

Definition at line 504 of file gin_private.h.

{
    /* if not of same null category, sort by that first */
    if (categorya != categoryb)
        return (categorya < categoryb) ? -1 : 1;
 
    /* all null items in same category are equal */
    if (categorya != GIN_CAT_NORM_KEY)
        return 0;
 
    /* both not null, so safe to call the compareFn */
    return DatumGetInt32(FunctionCall2Coll(&ginstate->compareFn[attnum - 1],
                                           ginstate->supportCollation[attnum - 1],
                                           a, b));
}

References a, attnum, b, GinState::compareFn, DatumGetInt32(), fb(), FunctionCall2Coll(), GIN_CAT_NORM_KEY, and GinState::supportCollation.

Referenced by collectMatchBitmap(), collectMatchesForHeapRow(), ginCompareAttEntries(), and ginFillScanEntry().

ginCompareItemPointers()

static int ginCompareItemPointers ( const ItemPointerData *  a, const ItemPointerData *  b  )

inlinestatic

Definition at line 492 of file gin_private.h.

{
    uint64      ia = (uint64) GinItemPointerGetBlockNumber(a) << 32 | GinItemPointerGetOffsetNumber(a);
    uint64      ib = (uint64) GinItemPointerGetBlockNumber(b) << 32 | GinItemPointerGetOffsetNumber(b);
 
    return pg_cmp_u64(ia, ib);
}

References a, b, fb(), GinItemPointerGetBlockNumber, GinItemPointerGetOffsetNumber, and pg_cmp_u64().

Referenced by addItemsToLeaf(), dataBeginPlaceToPageLeaf(), dataIsMoveRight(), dataLocateItem(), entryGetItem(), entryLoadMoreItems(), ginCombineData(), GinDataLeafPageGetItems(), ginMergeItemPointers(), ginPostingListDecodeAllSegments(), keyGetItem(), qsortCompareItemPointers(), and scanGetItem().

ginCompressPostingList()

GinPostingList * ginCompressPostingList ( const ItemPointerData *  ipd, int  nipd, int  maxsize, int *  nwritten  )

extern

Definition at line 197 of file ginpostinglist.c.

{
    uint64      prev;
    int         totalpacked = 0;
    int         maxbytes;
    GinPostingList *result;
    unsigned char *ptr;
    unsigned char *endptr;
 
    maxsize = SHORTALIGN_DOWN(maxsize);
 
    result = palloc(maxsize);
 
    maxbytes = maxsize - offsetof(GinPostingList, bytes);
    Assert(maxbytes > 0);
 
    /* Store the first special item */
    result->first = ipd[0];
 
    prev = itemptr_to_uint64(&result->first);
 
    ptr = result->bytes;
    endptr = result->bytes + maxbytes;
    for (totalpacked = 1; totalpacked < nipd; totalpacked++)
    {
        uint64      val = itemptr_to_uint64(&ipd[totalpacked]);
        uint64      delta = val - prev;
 
        Assert(val > prev);
 
        if (endptr - ptr >= MaxBytesPerInteger)
            encode_varbyte(delta, &ptr);
        else
        {
            /*
             * There are less than 7 bytes left. Have to check if the next
             * item fits in that space before writing it out.
             */
            unsigned char buf[MaxBytesPerInteger];
            unsigned char *p = buf;
 
            encode_varbyte(delta, &p);
            if (p - buf > (endptr - ptr))
                break;          /* output is full */
 
            memcpy(ptr, buf, p - buf);
            ptr += (p - buf);
        }
        prev = val;
    }
    result->nbytes = ptr - result->bytes;
 
    /*
     * If we wrote an odd number of bytes, zero out the padding byte at the
     * end.
     */
    if (result->nbytes != SHORTALIGN(result->nbytes))
        result->bytes[result->nbytes] = 0;
 
    if (nwritten)
        *nwritten = totalpacked;
 
    Assert(SizeOfGinPostingList(result) <= maxsize);
 
    /*
     * Check that the encoded segment decodes back to the original items.
     */
#if defined (CHECK_ENCODING_ROUNDTRIP)
    {
        int         ndecoded;
        ItemPointer tmp = ginPostingListDecode(result, &ndecoded);
 
        Assert(ndecoded == totalpacked);
        Assert(memcmp(tmp, ipd, ndecoded * sizeof(ItemPointerData)) == 0);
        pfree(tmp);
    }
#endif
 
    return result;
}

References Assert, buf, GinPostingList::bytes, encode_varbyte(), fb(), GinPostingList::first, ginPostingListDecode(), itemptr_to_uint64(), MaxBytesPerInteger, GinPostingList::nbytes, palloc(), pfree(), SHORTALIGN, SHORTALIGN_DOWN, SizeOfGinPostingList, and val.

Referenced by _gin_build_tuple(), addItemPointersToLeafTuple(), buildFreshLeafTuple(), createPostingTree(), ginRedoRecompress(), ginVacuumEntryPage(), ginVacuumPostingTreeLeaf(), leafRepackItems(), and test_itemptr_pair().

ginDataFillRoot()

void ginDataFillRoot ( GinBtree  btree, Page  root, BlockNumber  lblkno, Page  lpage, BlockNumber  rblkno, Page  rpage  )

extern

Definition at line 1349 of file gindatapage.c.

{
    PostingItem li,
                ri;
 
    li.key = *GinDataPageGetRightBound(lpage);
    PostingItemSetBlockNumber(&li, lblkno);
    GinDataPageAddPostingItem(root, &li, InvalidOffsetNumber);
 
    ri.key = *GinDataPageGetRightBound(rpage);
    PostingItemSetBlockNumber(&ri, rblkno);
    GinDataPageAddPostingItem(root, &ri, InvalidOffsetNumber);
}

References fb(), GinDataPageAddPostingItem(), GinDataPageGetRightBound, InvalidOffsetNumber, PostingItem::key, PostingItemSetBlockNumber, and root.

Referenced by ginPrepareDataScan().

GinDataLeafPageGetItems()

ItemPointer GinDataLeafPageGetItems ( Page  page, int *  nitems, ItemPointerData  advancePast  )

extern

Definition at line 135 of file gindatapage.c.

{
    ItemPointer result;
 
    if (GinPageIsCompressed(page))
    {
        GinPostingList *seg = GinDataLeafPageGetPostingList(page);
        Size        len = GinDataLeafPageGetPostingListSize(page);
        char       *endptr = (char *) seg + len;
        GinPostingList *next;
 
        /* Skip to the segment containing advancePast+1 */
        if (ItemPointerIsValid(&advancePast))
        {
            next = GinNextPostingListSegment(seg);
            while ((char *) next < endptr &&
                   ginCompareItemPointers(&next->first, &advancePast) <= 0)
            {
                seg = next;
                next = GinNextPostingListSegment(seg);
            }
            len = endptr - (char *) seg;
        }
 
        if (len > 0)
            result = ginPostingListDecodeAllSegments(seg, len, nitems);
        else
        {
            result = NULL;
            *nitems = 0;
        }
    }
    else
    {
        ItemPointer tmp = dataLeafPageGetUncompressed(page, nitems);
 
        result = palloc((*nitems) * sizeof(ItemPointerData));
        memcpy(result, tmp, (*nitems) * sizeof(ItemPointerData));
    }
 
    return result;
}

References dataLeafPageGetUncompressed(), fb(), ginCompareItemPointers(), GinDataLeafPageGetPostingList, GinDataLeafPageGetPostingListSize, GinNextPostingListSegment, GinPageIsCompressed, ginPostingListDecodeAllSegments(), ItemPointerIsValid(), len, next, nitems, and palloc().

Referenced by entryLoadMoreItems(), gin_check_posting_tree_parent_keys_consistency(), and startScanEntry().

GinDataLeafPageGetItemsToTbm()

int GinDataLeafPageGetItemsToTbm ( Page  page, TIDBitmap *  tbm  )

extern

Definition at line 182 of file gindatapage.c.

{
    ItemPointer uncompressed;
    int         nitems;
 
    if (GinPageIsCompressed(page))
    {
        GinPostingList *segment = GinDataLeafPageGetPostingList(page);
        Size        len = GinDataLeafPageGetPostingListSize(page);
 
        nitems = ginPostingListDecodeAllSegmentsToTbm(segment, len, tbm);
    }
    else
    {
        uncompressed = dataLeafPageGetUncompressed(page, &nitems);
 
        if (nitems > 0)
            tbm_add_tuples(tbm, uncompressed, nitems, false);
    }
 
    return nitems;
}

References dataLeafPageGetUncompressed(), fb(), GinDataLeafPageGetPostingList, GinDataLeafPageGetPostingListSize, GinPageIsCompressed, ginPostingListDecodeAllSegmentsToTbm(), len, nitems, and tbm_add_tuples().

Referenced by scanPostingTree().

GinDataPageAddPostingItem()

void GinDataPageAddPostingItem ( Page  page, PostingItem *  data, OffsetNumber  offset  )

extern

Definition at line 380 of file gindatapage.c.

{
    OffsetNumber maxoff = GinPageGetOpaque(page)->maxoff;
    char       *ptr;
 
    Assert(PostingItemGetBlockNumber(data) != InvalidBlockNumber);
    Assert(!GinPageIsLeaf(page));
 
    if (offset == InvalidOffsetNumber)
    {
        ptr = (char *) GinDataPageGetPostingItem(page, maxoff + 1);
    }
    else
    {
        ptr = (char *) GinDataPageGetPostingItem(page, offset);
        if (offset != maxoff + 1)
            memmove(ptr + sizeof(PostingItem),
                    ptr,
                    (maxoff - offset + 1) * sizeof(PostingItem));
    }
    memcpy(ptr, data, sizeof(PostingItem));
 
    maxoff++;
    GinPageGetOpaque(page)->maxoff = maxoff;
 
    /*
     * Also set pd_lower to the end of the posting items, to follow the
     * "standard" page layout, so that we can squeeze out the unused space
     * from full-page images.
     */
    GinDataPageSetDataSize(page, maxoff * sizeof(PostingItem));
}

References Assert, data, fb(), GinDataPageGetPostingItem, GinDataPageSetDataSize, GinPageGetOpaque, GinPageIsLeaf, InvalidBlockNumber, InvalidOffsetNumber, and PostingItemGetBlockNumber.

Referenced by dataExecPlaceToPageInternal(), ginDataFillRoot(), and ginRedoInsertData().

ginendscan()

void ginendscan ( IndexScanDesc  scan )

extern

Definition at line 504 of file ginscan.c.

{
    GinScanOpaque so = (GinScanOpaque) scan->opaque;
 
    ginFreeScanKeys(so);
 
    MemoryContextDelete(so->tempCtx);
    MemoryContextDelete(so->keyCtx);
 
    pfree(so);
}

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

Referenced by ginhandler().

ginEntryFillRoot()

void ginEntryFillRoot ( GinBtree  btree, Page  root, BlockNumber  lblkno, Page  lpage, BlockNumber  rblkno, Page  rpage  )

extern

Definition at line 723 of file ginentrypage.c.

{
    IndexTuple  itup;
 
    itup = GinFormInteriorTuple(getRightMostTuple(lpage), lpage, lblkno);
    if (PageAddItem(root, itup, IndexTupleSize(itup), InvalidOffsetNumber, false, false) == InvalidOffsetNumber)
        elog(ERROR, "failed to add item to index root page");
    pfree(itup);
 
    itup = GinFormInteriorTuple(getRightMostTuple(rpage), rpage, rblkno);
    if (PageAddItem(root, itup, IndexTupleSize(itup), InvalidOffsetNumber, false, false) == InvalidOffsetNumber)
        elog(ERROR, "failed to add item to index root page");
    pfree(itup);
}

References elog, ERROR, fb(), getRightMostTuple(), GinFormInteriorTuple(), IndexTupleSize(), InvalidOffsetNumber, PageAddItem, pfree(), and root.

Referenced by ginPrepareEntryScan().

ginEntryInsert()

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

extern

Definition at line 351 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(), fb(), GinBtreeData::findItem, freeGinBtreeStack(), GIN_UNLOCK, ginFindLeafPage(), GinGetPostingTree, ginInsertItemPointers(), ginInsertValue(), GinIsPostingTree, ginPrepareEntryScan(), GinState::index, GinBtreeData::isBuild, items, LockBuffer(), GinStatsData::nEntries, GinBtreeStack::off, PageGetItem(), PageGetItemId(), and pfree().

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

ginExtractEntries()

Datum * ginExtractEntries ( GinState *  ginstate, OffsetNumber  attnum, Datum  value, bool  isNull, int32 *  nentries, GinNullCategory **  categories  )

extern

Definition at line 452 of file ginutil.c.

{
    Datum      *entries;
    bool       *nullFlags;
    int32       i;
 
    /*
     * We don't call the extractValueFn on a null item.  Instead generate a
     * placeholder.
     */
    if (isNull)
    {
        *nentries = 1;
        entries = palloc_object(Datum);
        entries[0] = (Datum) 0;
        *categories = palloc_object(GinNullCategory);
        (*categories)[0] = GIN_CAT_NULL_ITEM;
        return entries;
    }
 
    /* OK, call the opclass's extractValueFn */
    nullFlags = NULL;           /* in case extractValue doesn't set it */
    entries = (Datum *)
        DatumGetPointer(FunctionCall3Coll(&ginstate->extractValueFn[attnum - 1],
                                          ginstate->supportCollation[attnum - 1],
                                          value,
                                          PointerGetDatum(nentries),
                                          PointerGetDatum(&nullFlags)));
 
    /*
     * Generate a placeholder if the item contained no keys.
     */
    if (entries == NULL || *nentries <= 0)
    {
        *nentries = 1;
        entries = palloc_object(Datum);
        entries[0] = (Datum) 0;
        *categories = palloc_object(GinNullCategory);
        (*categories)[0] = GIN_CAT_EMPTY_ITEM;
        return entries;
    }
 
    /*
     * If the extractValueFn didn't create a nullFlags array, create one,
     * assuming that everything's non-null.
     */
    if (nullFlags == NULL)
        nullFlags = (bool *) palloc0(*nentries * sizeof(bool));
 
    /*
     * If there's more than one key, sort and unique-ify.
     *
     * XXX Using qsort here is notationally painful, and the overhead is
     * pretty bad too.  For small numbers of keys it'd likely be better to use
     * a simple insertion sort.
     */
    if (*nentries > 1)
    {
        keyEntryData *keydata;
        cmpEntriesArg arg;
 
        keydata = palloc_array(keyEntryData, *nentries);
        for (i = 0; i < *nentries; i++)
        {
            keydata[i].datum = entries[i];
            keydata[i].isnull = nullFlags[i];
        }
 
        arg.cmpDatumFunc = &ginstate->compareFn[attnum - 1];
        arg.collation = ginstate->supportCollation[attnum - 1];
        arg.haveDups = false;
        qsort_arg(keydata, *nentries, sizeof(keyEntryData),
                  cmpEntries, &arg);
 
        if (arg.haveDups)
        {
            /* there are duplicates, must get rid of 'em */
            int32       j;
 
            entries[0] = keydata[0].datum;
            nullFlags[0] = keydata[0].isnull;
            j = 1;
            for (i = 1; i < *nentries; i++)
            {
                if (cmpEntries(&keydata[i - 1], &keydata[i], &arg) != 0)
                {
                    entries[j] = keydata[i].datum;
                    nullFlags[j] = keydata[i].isnull;
                    j++;
                }
            }
            *nentries = j;
        }
        else
        {
            /* easy, no duplicates */
            for (i = 0; i < *nentries; i++)
            {
                entries[i] = keydata[i].datum;
                nullFlags[i] = keydata[i].isnull;
            }
        }
 
        pfree(keydata);
    }
 
    /*
     * Create GinNullCategory representation from nullFlags.
     */
    *categories = (GinNullCategory *) palloc0(*nentries * sizeof(GinNullCategory));
    for (i = 0; i < *nentries; i++)
        (*categories)[i] = (nullFlags[i] ? GIN_CAT_NULL_KEY : GIN_CAT_NORM_KEY);
 
    return entries;
}

References arg, attnum, cmpEntries(), GinState::compareFn, DatumGetPointer(), GinState::extractValueFn, fb(), FunctionCall3Coll(), GIN_CAT_EMPTY_ITEM, GIN_CAT_NORM_KEY, GIN_CAT_NULL_ITEM, GIN_CAT_NULL_KEY, i, j, palloc0(), palloc_array, palloc_object, pfree(), PointerGetDatum(), qsort_arg(), GinState::supportCollation, and value.

Referenced by ginHeapTupleBulkInsert(), ginHeapTupleFastCollect(), and ginHeapTupleInsert().

ginFindLeafPage()

GinBtreeStack * ginFindLeafPage ( GinBtree  btree, bool  searchMode, bool  rootConflictCheck  )

extern

Definition at line 83 of file ginbtree.c.

{
    GinBtreeStack *stack;
 
    stack = palloc_object(GinBtreeStack);
    stack->blkno = btree->rootBlkno;
    stack->buffer = ReadBuffer(btree->index, btree->rootBlkno);
    stack->parent = NULL;
    stack->predictNumber = 1;
 
    if (rootConflictCheck)
        CheckForSerializableConflictIn(btree->index, NULL, btree->rootBlkno);
 
    for (;;)
    {
        Page        page;
        BlockNumber child;
        int         access;
 
        stack->off = InvalidOffsetNumber;
 
        page = BufferGetPage(stack->buffer);
 
        access = ginTraverseLock(stack->buffer, searchMode);
 
        /*
         * If we're going to modify the tree, finish any incomplete splits we
         * encounter on the way.
         */
        if (!searchMode && GinPageIsIncompleteSplit(page))
            ginFinishOldSplit(btree, stack, NULL, access);
 
        /*
         * ok, page is correctly locked, we should check to move right ..,
         * root never has a right link, so small optimization
         */
        while (btree->fullScan == false && stack->blkno != btree->rootBlkno &&
               btree->isMoveRight(btree, page))
        {
            BlockNumber rightlink = GinPageGetOpaque(page)->rightlink;
 
            if (rightlink == InvalidBlockNumber)
                /* rightmost page */
                break;
 
            stack->buffer = ginStepRight(stack->buffer, btree->index, access);
            stack->blkno = rightlink;
            page = BufferGetPage(stack->buffer);
 
            if (!searchMode && GinPageIsIncompleteSplit(page))
                ginFinishOldSplit(btree, stack, NULL, access);
        }
 
        if (GinPageIsLeaf(page))    /* we found, return locked page */
            return stack;
 
        /* now we have correct buffer, try to find child */
        child = btree->findChildPage(btree, stack);
 
        LockBuffer(stack->buffer, GIN_UNLOCK);
        Assert(child != InvalidBlockNumber);
        Assert(stack->blkno != child);
 
        if (searchMode)
        {
            /* in search mode we may forget path to leaf */
            stack->blkno = child;
            stack->buffer = ReleaseAndReadBuffer(stack->buffer, btree->index, stack->blkno);
        }
        else
        {
            GinBtreeStack *ptr = palloc_object(GinBtreeStack);
 
            ptr->parent = stack;
            stack = ptr;
            stack->blkno = child;
            stack->buffer = ReadBuffer(btree->index, stack->blkno);
            stack->predictNumber = 1;
        }
    }
}

References Assert, GinBtreeStack::blkno, GinBtreeStack::buffer, BufferGetPage(), CheckForSerializableConflictIn(), fb(), GinBtreeData::findChildPage, GinBtreeData::fullScan, GIN_UNLOCK, ginFinishOldSplit(), GinPageGetOpaque, GinPageIsIncompleteSplit, GinPageIsLeaf, ginStepRight(), ginTraverseLock(), GinBtreeData::index, InvalidBlockNumber, InvalidOffsetNumber, GinBtreeData::isMoveRight, LockBuffer(), GinBtreeStack::off, palloc_object, GinBtreeStack::parent, GinBtreeStack::predictNumber, ReadBuffer(), ReleaseAndReadBuffer(), and GinBtreeData::rootBlkno.

Referenced by entryLoadMoreItems(), ginEntryInsert(), ginInsertItemPointers(), ginScanBeginPostingTree(), and startScanEntry().

GinFormTuple()

IndexTuple GinFormTuple ( GinState *  ginstate, OffsetNumber  attnum, Datum  key, GinNullCategory  category, Pointer  data, Size  dataSize, int  nipd, bool  errorTooBig  )

extern

Definition at line 44 of file ginentrypage.c.

{
    Datum       datums[2];
    bool        isnull[2];
    IndexTuple  itup;
    uint32      newsize;
 
    /* Build the basic tuple: optional column number, plus key datum */
    if (ginstate->oneCol)
    {
        datums[0] = key;
        isnull[0] = (category != GIN_CAT_NORM_KEY);
    }
    else
    {
        datums[0] = UInt16GetDatum(attnum);
        isnull[0] = false;
        datums[1] = key;
        isnull[1] = (category != GIN_CAT_NORM_KEY);
    }
 
    itup = index_form_tuple(ginstate->tupdesc[attnum - 1], datums, isnull);
 
    /*
     * Determine and store offset to the posting list, making sure there is
     * room for the category byte if needed.
     *
     * Note: because index_form_tuple MAXALIGNs the tuple size, there may well
     * be some wasted pad space.  Is it worth recomputing the data length to
     * prevent that?  That would also allow us to Assert that the real data
     * doesn't overlap the GinNullCategory byte, which this code currently
     * takes on faith.
     */
    newsize = IndexTupleSize(itup);
 
    if (IndexTupleHasNulls(itup))
    {
        uint32      minsize;
 
        Assert(category != GIN_CAT_NORM_KEY);
        minsize = GinCategoryOffset(itup, ginstate) + sizeof(GinNullCategory);
        newsize = Max(newsize, minsize);
    }
 
    newsize = SHORTALIGN(newsize);
 
    GinSetPostingOffset(itup, newsize);
    GinSetNPosting(itup, nipd);
 
    /*
     * Add space needed for posting list, if any.  Then check that the tuple
     * won't be too big to store.
     */
    newsize += dataSize;
 
    newsize = MAXALIGN(newsize);
 
    if (newsize > GinMaxItemSize)
    {
        if (errorTooBig)
            ereport(ERROR,
                    (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                     errmsg("index row size %zu exceeds maximum %zu for index \"%s\"",
                            (Size) newsize, (Size) GinMaxItemSize,
                            RelationGetRelationName(ginstate->index))));
        pfree(itup);
        return NULL;
    }
 
    /*
     * Resize tuple if needed
     */
    if (newsize != IndexTupleSize(itup))
    {
        itup = repalloc(itup, newsize);
 
        /*
         * PostgreSQL 9.3 and earlier did not clear this new space, so we
         * might find uninitialized padding when reading tuples from disk.
         */
        memset((char *) itup + IndexTupleSize(itup),
               0, newsize - IndexTupleSize(itup));
        /* set new size in tuple header */
        itup->t_info &= ~INDEX_SIZE_MASK;
        itup->t_info |= newsize;
    }
 
    /*
     * Copy in the posting list, if provided
     */
    if (data)
    {
        char       *ptr = GinGetPosting(itup);
 
        memcpy(ptr, data, dataSize);
    }
 
    /*
     * Insert category byte, if needed
     */
    if (category != GIN_CAT_NORM_KEY)
    {
        Assert(IndexTupleHasNulls(itup));
        GinSetNullCategory(itup, ginstate, category);
    }
    return itup;
}

References Assert, attnum, data, ereport, errcode(), errmsg, ERROR, fb(), GIN_CAT_NORM_KEY, GinCategoryOffset, GinGetPosting, GinMaxItemSize, GinSetNPosting, GinSetNullCategory, GinSetPostingOffset, GinState::index, index_form_tuple(), IndexTupleHasNulls(), IndexTupleSize(), Max, MAXALIGN, GinState::oneCol, pfree(), RelationGetRelationName, repalloc(), SHORTALIGN, IndexTupleData::t_info, GinState::tupdesc, and UInt16GetDatum().

Referenced by addItemPointersToLeafTuple(), buildFreshLeafTuple(), ginHeapTupleFastCollect(), and ginVacuumEntryPage().

ginFreeScanKeys()

void ginFreeScanKeys ( GinScanOpaque  so )

extern

Definition at line 237 of file ginscan.c.

{
    uint32      i;
 
    if (so->keys == NULL)
        return;
 
    for (i = 0; i < so->totalentries; i++)
    {
        GinScanEntry entry = so->entries[i];
 
        if (entry->buffer != InvalidBuffer)
            ReleaseBuffer(entry->buffer);
        if (entry->list)
            pfree(entry->list);
        if (entry->matchIterator)
            tbm_end_private_iterate(entry->matchIterator);
        if (entry->matchBitmap)
            tbm_free(entry->matchBitmap);
    }
 
    MemoryContextReset(so->keyCtx);
 
    so->keys = NULL;
    so->nkeys = 0;
    so->entries = NULL;
    so->totalentries = 0;
}

References GinScanEntryData::buffer, fb(), i, InvalidBuffer, GinScanEntryData::list, GinScanEntryData::matchBitmap, GinScanEntryData::matchIterator, MemoryContextReset(), pfree(), ReleaseBuffer(), tbm_end_private_iterate(), and tbm_free().

Referenced by ginendscan(), gingetbitmap(), and ginrescan().

ginGetBAEntry()

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

extern

Definition at line 267 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, fb(), GinEntryAccumulator::key, GinEntryAccumulator::list, qsort, qsortCompareItemPointers(), rbt_iterate(), GinEntryAccumulator::shouldSort, and BuildAccumulator::tree_walk.

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

gingetbitmap()

int64 gingetbitmap ( IndexScanDesc  scan, TIDBitmap *  tbm  )

extern

Definition at line 1931 of file ginget.c.

{
    GinScanOpaque so = (GinScanOpaque) scan->opaque;
    int64       ntids;
    ItemPointerData iptr;
    bool        recheck;
 
    /*
     * Set up the scan keys, and check for unsatisfiable query.
     */
    ginFreeScanKeys(so);        /* there should be no keys yet, but just to be
                                 * sure */
    ginNewScanKey(scan);
 
    if (GinIsVoidRes(scan))
        return 0;
 
    ntids = 0;
 
    /*
     * First, scan the pending list and collect any matching entries into the
     * bitmap.  After we scan a pending item, some other backend could post it
     * into the main index, and so we might visit it a second time during the
     * main scan.  This is okay because we'll just re-set the same bit in the
     * bitmap.  (The possibility of duplicate visits is a major reason why GIN
     * can't support the amgettuple API, however.) Note that it would not do
     * to scan the main index before the pending list, since concurrent
     * cleanup could then make us miss entries entirely.
     */
    scanPendingInsert(scan, tbm, &ntids);
 
    /*
     * Now scan the main index.
     */
    startScan(scan);
 
    ItemPointerSetMin(&iptr);
 
    for (;;)
    {
        if (!scanGetItem(scan, iptr, &iptr, &recheck))
            break;
 
        if (ItemPointerIsLossyPage(&iptr))
            tbm_add_page(tbm, ItemPointerGetBlockNumber(&iptr));
        else
            tbm_add_tuples(tbm, &iptr, 1, recheck);
        ntids++;
    }
 
    return ntids;
}

References fb(), ginFreeScanKeys(), GinIsVoidRes, ginNewScanKey(), ItemPointerGetBlockNumber(), ItemPointerIsLossyPage, ItemPointerSetMin, IndexScanDescData::opaque, scanGetItem(), scanPendingInsert(), startScan(), tbm_add_page(), and tbm_add_tuples().

Referenced by ginhandler().

ginHeapTupleFastCollect()

void ginHeapTupleFastCollect ( GinState *  ginstate, GinTupleCollector *  collector, OffsetNumber  attnum, Datum  value, bool  isNull, ItemPointer  ht_ctid  )

extern

Definition at line 483 of file ginfast.c.

{
    Datum      *entries;
    GinNullCategory *categories;
    int32       i,
                nentries;
 
    /*
     * Extract the key values that need to be inserted in the index
     */
    entries = ginExtractEntries(ginstate, attnum, value, isNull,
                                &nentries, &categories);
 
    /*
     * Protect against integer overflow in allocation calculations
     */
    if (nentries < 0 ||
        collector->ntuples + nentries > MaxAllocSize / sizeof(IndexTuple))
        elog(ERROR, "too many entries for GIN index");
 
    /*
     * Allocate/reallocate memory for storing collected tuples
     */
    if (collector->tuples == NULL)
    {
        /*
         * Determine the number of elements to allocate in the tuples array
         * initially.  Make it a power of 2 to avoid wasting memory when
         * resizing (since palloc likes powers of 2).
         */
        collector->lentuples = pg_nextpower2_32(Max(16, nentries));
        collector->tuples = palloc_array(IndexTuple, collector->lentuples);
    }
    else if (collector->lentuples < collector->ntuples + nentries)
    {
        /*
         * Advance lentuples to the next suitable power of 2.  This won't
         * overflow, though we could get to a value that exceeds
         * MaxAllocSize/sizeof(IndexTuple), causing an error in repalloc.
         */
        collector->lentuples = pg_nextpower2_32(collector->ntuples + nentries);
        collector->tuples = repalloc_array(collector->tuples,
                                           IndexTuple, collector->lentuples);
    }
 
    /*
     * Build an index tuple for each key value, and add to array.  In pending
     * tuples we just stick the heap TID into t_tid.
     */
    for (i = 0; i < nentries; i++)
    {
        IndexTuple  itup;
 
        itup = GinFormTuple(ginstate, attnum, entries[i], categories[i],
                            NULL, 0, 0, true);
        itup->t_tid = *ht_ctid;
        collector->tuples[collector->ntuples++] = itup;
        collector->sumsize += IndexTupleSize(itup);
    }
}

References attnum, elog, ERROR, fb(), ginExtractEntries(), GinFormTuple(), i, IndexTupleSize(), Max, MaxAllocSize, palloc_array, pg_nextpower2_32(), repalloc_array, IndexTupleData::t_tid, and value.

Referenced by gininsert().

ginHeapTupleFastInsert()

void ginHeapTupleFastInsert ( GinState *  ginstate, GinTupleCollector *  collector  )

extern

Definition at line 219 of file ginfast.c.

{
    Relation    index = ginstate->index;
    Buffer      metabuffer;
    Page        metapage;
    GinMetaPageData *metadata = NULL;
    Buffer      buffer = InvalidBuffer;
    Page        page = NULL;
    ginxlogUpdateMeta data;
    bool        separateList = false;
    bool        needCleanup = false;
    int         cleanupSize;
    bool        needWal;
 
    if (collector->ntuples == 0)
        return;
 
    needWal = RelationNeedsWAL(index);
 
    data.locator = index->rd_locator;
    data.ntuples = 0;
    data.newRightlink = data.prevTail = InvalidBlockNumber;
 
    metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
    metapage = BufferGetPage(metabuffer);
 
    /*
     * An insertion to the pending list could logically belong anywhere in the
     * tree, so it conflicts with all serializable scans.  All scans acquire a
     * predicate lock on the metabuffer to represent that.  Therefore we'll
     * check for conflicts in, but not until we have the page locked and are
     * ready to modify the page.
     */
 
    if (collector->sumsize + collector->ntuples * sizeof(ItemIdData) > GinListPageSize)
    {
        /*
         * Total size is greater than one page => make sublist
         */
        separateList = true;
    }
    else
    {
        LockBuffer(metabuffer, GIN_EXCLUSIVE);
        metadata = GinPageGetMeta(metapage);
 
        if (metadata->head == InvalidBlockNumber ||
            collector->sumsize + collector->ntuples * sizeof(ItemIdData) > metadata->tailFreeSize)
        {
            /*
             * Pending list is empty or total size is greater than freespace
             * on tail page => make sublist
             *
             * We unlock metabuffer to keep high concurrency
             */
            separateList = true;
            LockBuffer(metabuffer, GIN_UNLOCK);
        }
    }
 
    if (separateList)
    {
        /*
         * We should make sublist separately and append it to the tail
         */
        GinMetaPageData sublist;
 
        memset(&sublist, 0, sizeof(GinMetaPageData));
        makeSublist(index, collector->tuples, collector->ntuples, &sublist);
 
        /*
         * metapage was unlocked, see above
         */
        LockBuffer(metabuffer, GIN_EXCLUSIVE);
        metadata = GinPageGetMeta(metapage);
 
        CheckForSerializableConflictIn(index, NULL, GIN_METAPAGE_BLKNO);
 
        if (metadata->head == InvalidBlockNumber)
        {
            /*
             * Main list is empty, so just insert sublist as main list
             */
            START_CRIT_SECTION();
 
            metadata->head = sublist.head;
            metadata->tail = sublist.tail;
            metadata->tailFreeSize = sublist.tailFreeSize;
 
            metadata->nPendingPages = sublist.nPendingPages;
            metadata->nPendingHeapTuples = sublist.nPendingHeapTuples;
 
            if (needWal)
                XLogBeginInsert();
        }
        else
        {
            /*
             * Merge lists
             */
            data.prevTail = metadata->tail;
            data.newRightlink = sublist.head;
 
            buffer = ReadBuffer(index, metadata->tail);
            LockBuffer(buffer, GIN_EXCLUSIVE);
            page = BufferGetPage(buffer);
 
            Assert(GinPageGetOpaque(page)->rightlink == InvalidBlockNumber);
 
            START_CRIT_SECTION();
 
            GinPageGetOpaque(page)->rightlink = sublist.head;
 
            MarkBufferDirty(buffer);
 
            metadata->tail = sublist.tail;
            metadata->tailFreeSize = sublist.tailFreeSize;
 
            metadata->nPendingPages += sublist.nPendingPages;
            metadata->nPendingHeapTuples += sublist.nPendingHeapTuples;
 
            if (needWal)
            {
                XLogBeginInsert();
                XLogRegisterBuffer(1, buffer, REGBUF_STANDARD);
            }
        }
    }
    else
    {
        /*
         * Insert into tail page.  Metapage is already locked
         */
        OffsetNumber l,
                    off;
        int         i,
                    tupsize;
        char       *ptr;
        char       *collectordata;
 
        CheckForSerializableConflictIn(index, NULL, GIN_METAPAGE_BLKNO);
 
        buffer = ReadBuffer(index, metadata->tail);
        LockBuffer(buffer, GIN_EXCLUSIVE);
        page = BufferGetPage(buffer);
 
        off = (PageIsEmpty(page)) ? FirstOffsetNumber :
            OffsetNumberNext(PageGetMaxOffsetNumber(page));
 
        collectordata = ptr = (char *) palloc(collector->sumsize);
 
        data.ntuples = collector->ntuples;
 
        START_CRIT_SECTION();
 
        if (needWal)
            XLogBeginInsert();
 
        /*
         * Increase counter of heap tuples
         */
        Assert(GinPageGetOpaque(page)->maxoff <= metadata->nPendingHeapTuples);
        GinPageGetOpaque(page)->maxoff++;
        metadata->nPendingHeapTuples++;
 
        for (i = 0; i < collector->ntuples; i++)
        {
            tupsize = IndexTupleSize(collector->tuples[i]);
            l = PageAddItem(page, collector->tuples[i], tupsize, off, false, false);
 
            if (l == InvalidOffsetNumber)
                elog(ERROR, "failed to add item to index page in \"%s\"",
                     RelationGetRelationName(index));
 
            memcpy(ptr, collector->tuples[i], tupsize);
            ptr += tupsize;
 
            off++;
        }
 
        Assert((ptr - collectordata) <= collector->sumsize);
 
        MarkBufferDirty(buffer);
 
        if (needWal)
        {
            XLogRegisterBuffer(1, buffer, REGBUF_STANDARD);
            XLogRegisterBufData(1, collectordata, collector->sumsize);
        }
 
        metadata->tailFreeSize = PageGetExactFreeSpace(page);
    }
 
    /*
     * Set pd_lower just past the end of the metadata.  This is essential,
     * because without doing so, metadata will be lost if xlog.c compresses
     * the page.  (We must do this here because pre-v11 versions of PG did not
     * set the metapage's pd_lower correctly, so a pg_upgraded index might
     * contain the wrong value.)
     */
    ((PageHeader) metapage)->pd_lower =
        ((char *) metadata + sizeof(GinMetaPageData)) - (char *) metapage;
 
    /*
     * Write metabuffer, make xlog entry
     */
    MarkBufferDirty(metabuffer);
 
    if (needWal)
    {
        XLogRecPtr  recptr;
 
        memcpy(&data.metadata, metadata, sizeof(GinMetaPageData));
 
        XLogRegisterBuffer(0, metabuffer, REGBUF_WILL_INIT | REGBUF_STANDARD);
        XLogRegisterData(&data, sizeof(ginxlogUpdateMeta));
 
        recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_UPDATE_META_PAGE);
        PageSetLSN(metapage, recptr);
 
        if (buffer != InvalidBuffer)
        {
            PageSetLSN(page, recptr);
        }
    }
 
    if (buffer != InvalidBuffer)
        UnlockReleaseBuffer(buffer);
 
    /*
     * Force pending list cleanup when it becomes too long. And,
     * ginInsertCleanup could take significant amount of time, so we prefer to
     * call it when it can do all the work in a single collection cycle. In
     * non-vacuum mode, it shouldn't require maintenance_work_mem, so fire it
     * while pending list is still small enough to fit into
     * gin_pending_list_limit.
     *
     * ginInsertCleanup() should not be called inside our CRIT_SECTION.
     */
    cleanupSize = GinGetPendingListCleanupSize(index);
    if (metadata->nPendingPages * GIN_PAGE_FREESIZE > cleanupSize * (Size) 1024)
        needCleanup = true;
 
    END_CRIT_SECTION();
 
    UnlockReleaseBuffer(metabuffer);
 
    /*
     * Since it could contend with concurrent cleanup process we cleanup
     * pending list not forcibly.
     */
    if (needCleanup)
        ginInsertCleanup(ginstate, false, true, false, NULL);
}

References Assert, BufferGetPage(), CheckForSerializableConflictIn(), data, elog, END_CRIT_SECTION, ERROR, fb(), FirstOffsetNumber, GIN_EXCLUSIVE, GIN_METAPAGE_BLKNO, GIN_PAGE_FREESIZE, GIN_UNLOCK, GinGetPendingListCleanupSize, ginInsertCleanup(), GinListPageSize, GinPageGetMeta, GinPageGetOpaque, GinMetaPageData::head, i, GinState::index, IndexTupleSize(), InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, LockBuffer(), makeSublist(), MarkBufferDirty(), GinMetaPageData::nPendingHeapTuples, GinMetaPageData::nPendingPages, OffsetNumberNext, PageAddItem, PageGetExactFreeSpace(), PageGetMaxOffsetNumber(), PageIsEmpty(), PageSetLSN(), palloc(), ReadBuffer(), REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetRelationName, RelationNeedsWAL, START_CRIT_SECTION, GinMetaPageData::tail, GinMetaPageData::tailFreeSize, UnlockReleaseBuffer(), XLOG_GIN_UPDATE_META_PAGE, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by gininsert().

ginInitBA()

void ginInitBA ( BuildAccumulator *  accum )

extern

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, fb(), ginAllocEntryAccumulator(), ginCombineData(), rbt_create(), and BuildAccumulator::tree.

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

GinInitBuffer()

void GinInitBuffer ( Buffer  b, uint32  f  )

extern

Definition at line 357 of file ginutil.c.

{
    GinInitPage(BufferGetPage(b), f, BufferGetPageSize(b));
}

References b, BufferGetPage(), BufferGetPageSize(), and GinInitPage().

Referenced by ginbuild(), ginbuildempty(), ginRedoCreatePTree(), ginRedoDeleteListPages(), ginRedoInsertListPage(), and writeListPage().

ginInitConsistentFunction()

void ginInitConsistentFunction ( GinState *  ginstate, GinScanKey  key  )

extern

Definition at line 227 of file ginlogic.c.

{
    if (key->searchMode == GIN_SEARCH_MODE_EVERYTHING)
    {
        key->boolConsistentFn = trueConsistentFn;
        key->triConsistentFn = trueTriConsistentFn;
    }
    else
    {
        key->consistentFmgrInfo = &ginstate->consistentFn[key->attnum - 1];
        key->triConsistentFmgrInfo = &ginstate->triConsistentFn[key->attnum - 1];
        key->collation = ginstate->supportCollation[key->attnum - 1];
 
        if (OidIsValid(ginstate->consistentFn[key->attnum - 1].fn_oid))
            key->boolConsistentFn = directBoolConsistentFn;
        else
            key->boolConsistentFn = shimBoolConsistentFn;
 
        if (OidIsValid(ginstate->triConsistentFn[key->attnum - 1].fn_oid))
            key->triConsistentFn = directTriConsistentFn;
        else
            key->triConsistentFn = shimTriConsistentFn;
    }
}

References GinState::consistentFn, directBoolConsistentFn(), directTriConsistentFn(), FmgrInfo::fn_oid, GIN_SEARCH_MODE_EVERYTHING, OidIsValid, shimBoolConsistentFn(), shimTriConsistentFn(), GinState::supportCollation, GinState::triConsistentFn, trueConsistentFn(), and trueTriConsistentFn().

Referenced by ginFillScanKey().

GinInitMetabuffer()

void GinInitMetabuffer ( Buffer  b )

extern

Definition at line 363 of file ginutil.c.

{
    GinMetaPageData *metadata;
    Page        page = BufferGetPage(b);
 
    GinInitPage(page, GIN_META, BufferGetPageSize(b));
 
    metadata = GinPageGetMeta(page);
 
    metadata->head = metadata->tail = InvalidBlockNumber;
    metadata->tailFreeSize = 0;
    metadata->nPendingPages = 0;
    metadata->nPendingHeapTuples = 0;
    metadata->nTotalPages = 0;
    metadata->nEntryPages = 0;
    metadata->nDataPages = 0;
    metadata->nEntries = 0;
    metadata->ginVersion = GIN_CURRENT_VERSION;
 
    /*
     * Set pd_lower just past the end of the metadata.  This is essential,
     * because without doing so, metadata will be lost if xlog.c compresses
     * the page.
     */
    ((PageHeader) page)->pd_lower =
        ((char *) metadata + sizeof(GinMetaPageData)) - (char *) page;
}

References b, BufferGetPage(), BufferGetPageSize(), GIN_CURRENT_VERSION, GIN_META, GinInitPage(), GinPageGetMeta, GinMetaPageData::ginVersion, GinMetaPageData::head, InvalidBlockNumber, GinMetaPageData::nDataPages, GinMetaPageData::nEntries, GinMetaPageData::nEntryPages, GinMetaPageData::nPendingHeapTuples, GinMetaPageData::nPendingPages, GinMetaPageData::nTotalPages, GinMetaPageData::tail, and GinMetaPageData::tailFreeSize.

Referenced by ginbuild(), ginbuildempty(), ginRedoDeleteListPages(), and ginRedoUpdateMetapage().

GinInitPage()

void GinInitPage ( Page  page, uint32  f, Size  pageSize  )

extern

Definition at line 345 of file ginutil.c.

{
    GinPageOpaque opaque;
 
    PageInit(page, pageSize, sizeof(GinPageOpaqueData));
 
    opaque = GinPageGetOpaque(page);
    opaque->flags = f;
    opaque->rightlink = InvalidBlockNumber;
}

References fb(), GinPageOpaqueData::flags, GinPageGetOpaque, InvalidBlockNumber, PageInit(), and GinPageOpaqueData::rightlink.

Referenced by createPostingTree(), dataPlaceToPageLeafSplit(), dataSplitPageInternal(), entrySplitPage(), GinInitBuffer(), GinInitMetabuffer(), and ginPlaceToPage().

gininsert()

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

extern

Definition at line 865 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 = palloc_object(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, fb(), GinGetUseFastUpdate, ginHeapTupleFastCollect(), ginHeapTupleFastInsert(), ginHeapTupleInsert(), i, IndexInfo::ii_AmCache, IndexInfo::ii_Context, initGinState(), MemoryContextDelete(), MemoryContextSwitchTo(), TupleDescData::natts, GinState::origTupdesc, palloc_object, and values.

Referenced by ginhandler().

ginInsertBAEntries()

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

extern

Definition at line 209 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, fb(), FirstOffsetNumber, ginInsertBAEntry(), i, and ItemPointerIsValid().

Referenced by ginHeapTupleBulkInsert(), and processPendingPage().

ginInsertCleanup()

void ginInsertCleanup ( GinState *  ginstate, bool  full_clean, bool  fill_fsm, bool  forceCleanup, IndexBulkDeleteResult *  stats  )

extern

Definition at line 780 of file ginfast.c.

{
    Relation    index = ginstate->index;
    Buffer      metabuffer,
                buffer;
    Page        metapage,
                page;
    GinMetaPageData *metadata;
    MemoryContext opCtx,
                oldCtx;
    BuildAccumulator accum;
    KeyArray    datums;
    BlockNumber blkno,
                blknoFinish;
    bool        cleanupFinish = false;
    bool        fsm_vac = false;
    int         workMemory;
 
    /*
     * We would like to prevent concurrent cleanup process. For that we will
     * lock metapage in exclusive mode using LockPage() call. Nobody other
     * will use that lock for metapage, so we keep possibility of concurrent
     * insertion into pending list
     */
 
    if (forceCleanup)
    {
        /*
         * We are called from [auto]vacuum/analyze or gin_clean_pending_list()
         * and we would like to wait concurrent cleanup to finish.
         */
        LockPage(index, GIN_METAPAGE_BLKNO, ExclusiveLock);
        workMemory =
            (AmAutoVacuumWorkerProcess() && autovacuum_work_mem != -1) ?
            autovacuum_work_mem : maintenance_work_mem;
    }
    else
    {
        /*
         * We are called from regular insert and if we see concurrent cleanup
         * just exit in hope that concurrent process will clean up pending
         * list.
         */
        if (!ConditionalLockPage(index, GIN_METAPAGE_BLKNO, ExclusiveLock))
            return;
        workMemory = work_mem;
    }
 
    metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
    LockBuffer(metabuffer, GIN_SHARE);
    metapage = BufferGetPage(metabuffer);
    metadata = GinPageGetMeta(metapage);
 
    if (metadata->head == InvalidBlockNumber)
    {
        /* Nothing to do */
        UnlockReleaseBuffer(metabuffer);
        UnlockPage(index, GIN_METAPAGE_BLKNO, ExclusiveLock);
        return;
    }
 
    /*
     * Remember a tail page to prevent infinite cleanup if other backends add
     * new tuples faster than we can cleanup.
     */
    blknoFinish = metadata->tail;
 
    /*
     * Read and lock head of pending list
     */
    blkno = metadata->head;
    buffer = ReadBuffer(index, blkno);
    LockBuffer(buffer, GIN_SHARE);
    page = BufferGetPage(buffer);
 
    LockBuffer(metabuffer, GIN_UNLOCK);
 
    /*
     * Initialize.  All temporary space will be in opCtx
     */
    opCtx = AllocSetContextCreate(CurrentMemoryContext,
                                  "GIN insert cleanup temporary context",
                                  ALLOCSET_DEFAULT_SIZES);
 
    oldCtx = MemoryContextSwitchTo(opCtx);
 
    initKeyArray(&datums, 128);
    ginInitBA(&accum);
    accum.ginstate = ginstate;
 
    /*
     * At the top of this loop, we have pin and lock on the current page of
     * the pending list.  However, we'll release that before exiting the loop.
     * Note we also have pin but not lock on the metapage.
     */
    for (;;)
    {
        Assert(!GinPageIsDeleted(page));
 
        /*
         * Are we walk through the page which as we remember was a tail when
         * we start our cleanup?  But if caller asks us to clean up whole
         * pending list then ignore old tail, we will work until list becomes
         * empty.
         */
        if (blkno == blknoFinish && full_clean == false)
            cleanupFinish = true;
 
        /*
         * read page's datums into accum
         */
        processPendingPage(&accum, &datums, page, FirstOffsetNumber);
 
        vacuum_delay_point(false);
 
        /*
         * Is it time to flush memory to disk?  Flush if we are at the end of
         * the pending list, or if we have a full row and memory is getting
         * full.
         */
        if (GinPageGetOpaque(page)->rightlink == InvalidBlockNumber ||
            (GinPageHasFullRow(page) &&
             accum.allocatedMemory >= workMemory * (Size) 1024))
        {
            ItemPointerData *list;
            uint32      nlist;
            Datum       key;
            GinNullCategory category;
            OffsetNumber maxoff,
                        attnum;
 
            /*
             * Unlock current page to increase performance. Changes of page
             * will be checked later by comparing maxoff after completion of
             * memory flush.
             */
            maxoff = PageGetMaxOffsetNumber(page);
            LockBuffer(buffer, GIN_UNLOCK);
 
            /*
             * Moving collected data into regular structure can take
             * significant amount of time - so, run it without locking pending
             * list.
             */
            ginBeginBAScan(&accum);
            while ((list = ginGetBAEntry(&accum,
                                         &attnum, &key, &category, &nlist)) != NULL)
            {
                ginEntryInsert(ginstate, attnum, key, category,
                               list, nlist, NULL);
                vacuum_delay_point(false);
            }
 
            /*
             * Lock the whole list to remove pages
             */
            LockBuffer(metabuffer, GIN_EXCLUSIVE);
            LockBuffer(buffer, GIN_SHARE);
 
            Assert(!GinPageIsDeleted(page));
 
            /*
             * While we left the page unlocked, more stuff might have gotten
             * added to it.  If so, process those entries immediately.  There
             * shouldn't be very many, so we don't worry about the fact that
             * we're doing this with exclusive lock. Insertion algorithm
             * guarantees that inserted row(s) will not continue on next page.
             * NOTE: intentionally no vacuum_delay_point in this loop.
             */
            if (PageGetMaxOffsetNumber(page) != maxoff)
            {
                ginInitBA(&accum);
                processPendingPage(&accum, &datums, page, maxoff + 1);
 
                ginBeginBAScan(&accum);
                while ((list = ginGetBAEntry(&accum,
                                             &attnum, &key, &category, &nlist)) != NULL)
                    ginEntryInsert(ginstate, attnum, key, category,
                                   list, nlist, NULL);
            }
 
            /*
             * Remember next page - it will become the new list head
             */
            blkno = GinPageGetOpaque(page)->rightlink;
            UnlockReleaseBuffer(buffer);    /* shiftList will do exclusive
                                             * locking */
 
            /*
             * remove read pages from pending list, at this point all content
             * of read pages is in regular structure
             */
            shiftList(index, metabuffer, blkno, fill_fsm, stats);
 
            /* At this point, some pending pages have been freed up */
            fsm_vac = true;
 
            Assert(blkno == metadata->head);
            LockBuffer(metabuffer, GIN_UNLOCK);
 
            /*
             * if we removed the whole pending list or we cleanup tail (which
             * we remembered on start our cleanup process) then just exit
             */
            if (blkno == InvalidBlockNumber || cleanupFinish)
                break;
 
            /*
             * release memory used so far and reinit state
             */
            MemoryContextReset(opCtx);
            initKeyArray(&datums, datums.maxvalues);
            ginInitBA(&accum);
        }
        else
        {
            blkno = GinPageGetOpaque(page)->rightlink;
            UnlockReleaseBuffer(buffer);
        }
 
        /*
         * Read next page in pending list
         */
        vacuum_delay_point(false);
        buffer = ReadBuffer(index, blkno);
        LockBuffer(buffer, GIN_SHARE);
        page = BufferGetPage(buffer);
    }
 
    UnlockPage(index, GIN_METAPAGE_BLKNO, ExclusiveLock);
    ReleaseBuffer(metabuffer);
 
    /*
     * As pending list pages can have a high churn rate, it is desirable to
     * recycle them immediately to the FreeSpaceMap when ordinary backends
     * clean the list.
     */
    if (fsm_vac && fill_fsm)
        IndexFreeSpaceMapVacuum(index);
 
    /* Clean up temporary space */
    MemoryContextSwitchTo(oldCtx);
    MemoryContextDelete(opCtx);
}

References BuildAccumulator::allocatedMemory, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AmAutoVacuumWorkerProcess, Assert, attnum, autovacuum_work_mem, BufferGetPage(), ConditionalLockPage(), CurrentMemoryContext, ExclusiveLock, fb(), FirstOffsetNumber, GIN_EXCLUSIVE, GIN_METAPAGE_BLKNO, GIN_SHARE, GIN_UNLOCK, ginBeginBAScan(), ginEntryInsert(), ginGetBAEntry(), ginInitBA(), GinPageGetMeta, GinPageGetOpaque, GinPageHasFullRow, GinPageIsDeleted, BuildAccumulator::ginstate, GinMetaPageData::head, GinState::index, IndexFreeSpaceMapVacuum(), initKeyArray(), InvalidBlockNumber, LockBuffer(), LockPage(), maintenance_work_mem, KeyArray::maxvalues, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), opCtx, PageGetMaxOffsetNumber(), processPendingPage(), ReadBuffer(), ReleaseBuffer(), shiftList(), GinMetaPageData::tail, UnlockPage(), UnlockReleaseBuffer(), vacuum_delay_point(), and work_mem.

Referenced by gin_clean_pending_list(), ginbulkdelete(), ginHeapTupleFastInsert(), and ginvacuumcleanup().

ginInsertItemPointers()

void ginInsertItemPointers ( Relation  index, BlockNumber  rootBlkno, ItemPointerData *  items, uint32  nitem, GinStatsData *  buildStats  )

extern

Definition at line 1908 of file gindatapage.c.

{
    GinBtreeData btree;
    GinBtreeDataLeafInsertData insertdata;
    GinBtreeStack *stack;
 
    ginPrepareDataScan(&btree, index, rootBlkno);
    btree.isBuild = (buildStats != NULL);
    insertdata.items = items;
    insertdata.nitem = nitem;
    insertdata.curitem = 0;
 
    while (insertdata.curitem < insertdata.nitem)
    {
        /* search for the leaf page where the first item should go to */
        btree.itemptr = insertdata.items[insertdata.curitem];
        stack = ginFindLeafPage(&btree, false, true);
 
        ginInsertValue(&btree, stack, &insertdata, buildStats);
    }
}

References fb(), ginFindLeafPage(), ginInsertValue(), ginPrepareDataScan(), GinBtreeData::isBuild, GinBtreeData::itemptr, and items.

Referenced by addItemPointersToLeafTuple(), createPostingTree(), and ginEntryInsert().

ginInsertValue()

void ginInsertValue ( GinBtree  btree, GinBtreeStack *  stack, void *  insertdata, GinStatsData *  buildStats  )

extern

Definition at line 816 of file ginbtree.c.

{
    bool        done;
 
    /* If the leaf page was incompletely split, finish the split first */
    if (GinPageIsIncompleteSplit(BufferGetPage(stack->buffer)))
        ginFinishOldSplit(btree, stack, buildStats, GIN_EXCLUSIVE);
 
    done = ginPlaceToPage(btree, stack,
                          insertdata, InvalidBlockNumber,
                          InvalidBuffer, buildStats);
    if (done)
    {
        LockBuffer(stack->buffer, GIN_UNLOCK);
        freeGinBtreeStack(stack);
    }
    else
        ginFinishSplit(btree, stack, true, buildStats);
}

References GinBtreeStack::buffer, BufferGetPage(), fb(), freeGinBtreeStack(), GIN_EXCLUSIVE, GIN_UNLOCK, ginFinishOldSplit(), ginFinishSplit(), GinPageIsIncompleteSplit, ginPlaceToPage(), InvalidBlockNumber, InvalidBuffer, and LockBuffer().

Referenced by ginEntryInsert(), and ginInsertItemPointers().

ginMergeItemPointers()

ItemPointer ginMergeItemPointers ( ItemPointerData *  a, uint32  na, ItemPointerData *  b, uint32  nb, int *  nmerged  )

extern

Definition at line 378 of file ginpostinglist.c.

{
    ItemPointerData *dst;
 
    dst = (ItemPointer) palloc((na + nb) * sizeof(ItemPointerData));
 
    /*
     * If the argument arrays don't overlap, we can just append them to each
     * other.
     */
    if (na == 0 || nb == 0 || ginCompareItemPointers(&a[na - 1], &b[0]) < 0)
    {
        memcpy(dst, a, na * sizeof(ItemPointerData));
        memcpy(&dst[na], b, nb * sizeof(ItemPointerData));
        *nmerged = na + nb;
    }
    else if (ginCompareItemPointers(&b[nb - 1], &a[0]) < 0)
    {
        memcpy(dst, b, nb * sizeof(ItemPointerData));
        memcpy(&dst[nb], a, na * sizeof(ItemPointerData));
        *nmerged = na + nb;
    }
    else
    {
        ItemPointerData *dptr = dst;
        ItemPointerData *aptr = a;
        ItemPointerData *bptr = b;
 
        while (aptr - a < na && bptr - b < nb)
        {
            int         cmp = ginCompareItemPointers(aptr, bptr);
 
            if (cmp > 0)
                *dptr++ = *bptr++;
            else if (cmp == 0)
            {
                /* only keep one copy of the identical items */
                *dptr++ = *bptr++;
                aptr++;
            }
            else
                *dptr++ = *aptr++;
        }
 
        while (aptr - a < na)
            *dptr++ = *aptr++;
 
        while (bptr - b < nb)
            *dptr++ = *bptr++;
 
        *nmerged = dptr - dst;
    }
 
    return dst;
}

References a, b, cmp(), fb(), ginCompareItemPointers(), and palloc().

Referenced by addItemPointersToLeafTuple(), addItemsToLeaf(), GinBufferStoreTuple(), ginRedoRecompress(), and leafRepackItems().

GinNewBuffer()

Buffer GinNewBuffer ( Relation  index )

extern

Definition at line 307 of file ginutil.c.

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

References BMR_REL, BufferGetPage(), ConditionalLockBuffer(), EB_LOCK_FIRST, ExtendBufferedRel(), fb(), GetFreeIndexPage(), GIN_UNLOCK, GinPageIsRecyclable(), InvalidBlockNumber, LockBuffer(), MAIN_FORKNUM, ReadBuffer(), and ReleaseBuffer().

Referenced by createPostingTree(), ginbuild(), ginPlaceToPage(), and makeSublist().

ginNewScanKey()

void ginNewScanKey ( IndexScanDesc  scan )

extern

Definition at line 267 of file ginscan.c.

{
    ScanKey     scankey = scan->keyData;
    GinScanOpaque so = (GinScanOpaque) scan->opaque;
    int         i;
    int         numExcludeOnly;
    bool        hasNullQuery = false;
    bool        attrHasNormalScan[INDEX_MAX_KEYS] = {false};
    MemoryContext oldCtx;
 
    /*
     * Allocate all the scan key information in the key context. (If
     * extractQuery leaks anything there, it won't be reset until the end of
     * scan or rescan, but that's OK.)
     */
    oldCtx = MemoryContextSwitchTo(so->keyCtx);
 
    /* if no scan keys provided, allocate extra EVERYTHING GinScanKey */
    so->keys = (GinScanKey)
        palloc(Max(scan->numberOfKeys, 1) * sizeof(GinScanKeyData));
    so->nkeys = 0;
 
    /* initialize expansible array of GinScanEntry pointers */
    so->totalentries = 0;
    so->allocentries = 32;
    so->entries = (GinScanEntry *)
        palloc(so->allocentries * sizeof(GinScanEntry));
 
    so->isVoidRes = false;
 
    for (i = 0; i < scan->numberOfKeys; i++)
    {
        ScanKey     skey = &scankey[i];
        Datum      *queryValues;
        int32       nQueryValues = 0;
        bool       *partial_matches = NULL;
        Pointer    *extra_data = NULL;
        bool       *nullFlags = NULL;
        GinNullCategory *categories;
        int32       searchMode = GIN_SEARCH_MODE_DEFAULT;
 
        /*
         * We assume that GIN-indexable operators are strict, so a null query
         * argument means an unsatisfiable query.
         */
        if (skey->sk_flags & SK_ISNULL)
        {
            so->isVoidRes = true;
            break;
        }
 
        /* OK to call the extractQueryFn */
        queryValues = (Datum *)
            DatumGetPointer(FunctionCall7Coll(&so->ginstate.extractQueryFn[skey->sk_attno - 1],
                                              so->ginstate.supportCollation[skey->sk_attno - 1],
                                              skey->sk_argument,
                                              PointerGetDatum(&nQueryValues),
                                              UInt16GetDatum(skey->sk_strategy),
                                              PointerGetDatum(&partial_matches),
                                              PointerGetDatum(&extra_data),
                                              PointerGetDatum(&nullFlags),
                                              PointerGetDatum(&searchMode)));
 
        /*
         * If bogus searchMode is returned, treat as GIN_SEARCH_MODE_ALL; note
         * in particular we don't allow extractQueryFn to select
         * GIN_SEARCH_MODE_EVERYTHING.
         */
        if (searchMode < GIN_SEARCH_MODE_DEFAULT ||
            searchMode > GIN_SEARCH_MODE_ALL)
            searchMode = GIN_SEARCH_MODE_ALL;
 
        /* Non-default modes require the index to have placeholders */
        if (searchMode != GIN_SEARCH_MODE_DEFAULT)
            hasNullQuery = true;
 
        /*
         * In default mode, no keys means an unsatisfiable query.
         */
        if (queryValues == NULL || nQueryValues <= 0)
        {
            if (searchMode == GIN_SEARCH_MODE_DEFAULT)
            {
                so->isVoidRes = true;
                break;
            }
            nQueryValues = 0;   /* ensure sane value */
        }
 
        /*
         * Create GinNullCategory representation.  If the extractQueryFn
         * didn't create a nullFlags array, we assume everything is non-null.
         * While at it, detect whether any null keys are present.
         */
        categories = (GinNullCategory *) palloc0(nQueryValues * sizeof(GinNullCategory));
        if (nullFlags)
        {
            int32       j;
 
            for (j = 0; j < nQueryValues; j++)
            {
                if (nullFlags[j])
                {
                    categories[j] = GIN_CAT_NULL_KEY;
                    hasNullQuery = true;
                }
            }
        }
 
        ginFillScanKey(so, skey->sk_attno,
                       skey->sk_strategy, searchMode,
                       skey->sk_argument, nQueryValues,
                       queryValues, categories,
                       partial_matches, extra_data);
 
        /* Remember if we had any non-excludeOnly keys */
        if (searchMode != GIN_SEARCH_MODE_ALL)
            attrHasNormalScan[skey->sk_attno - 1] = true;
    }
 
    /*
     * Processing GIN_SEARCH_MODE_ALL scan keys requires us to make a second
     * pass over the scan keys.  Above we marked each such scan key as
     * excludeOnly.  If the involved column has any normal (not excludeOnly)
     * scan key as well, then we can leave it like that.  Otherwise, one
     * excludeOnly scan key must receive a GIN_CAT_EMPTY_QUERY hidden entry
     * and be set to normal (excludeOnly = false).
     */
    numExcludeOnly = 0;
    for (i = 0; i < so->nkeys; i++)
    {
        GinScanKey  key = &so->keys[i];
 
        if (key->searchMode != GIN_SEARCH_MODE_ALL)
            continue;
 
        if (!attrHasNormalScan[key->attnum - 1])
        {
            key->excludeOnly = false;
            ginScanKeyAddHiddenEntry(so, key, GIN_CAT_EMPTY_QUERY);
            attrHasNormalScan[key->attnum - 1] = true;
        }
        else
            numExcludeOnly++;
    }
 
    /*
     * If we left any excludeOnly scan keys as-is, move them to the end of the
     * scan key array: they must appear after normal key(s).
     */
    if (numExcludeOnly > 0)
    {
        GinScanKey  tmpkeys;
        int         iNormalKey;
        int         iExcludeOnly;
 
        /* We'd better have made at least one normal key */
        Assert(numExcludeOnly < so->nkeys);
        /* Make a temporary array to hold the re-ordered scan keys */
        tmpkeys = (GinScanKey) palloc(so->nkeys * sizeof(GinScanKeyData));
        /* Re-order the keys ... */
        iNormalKey = 0;
        iExcludeOnly = so->nkeys - numExcludeOnly;
        for (i = 0; i < so->nkeys; i++)
        {
            GinScanKey  key = &so->keys[i];
 
            if (key->excludeOnly)
            {
                memcpy(tmpkeys + iExcludeOnly, key, sizeof(GinScanKeyData));
                iExcludeOnly++;
            }
            else
            {
                memcpy(tmpkeys + iNormalKey, key, sizeof(GinScanKeyData));
                iNormalKey++;
            }
        }
        Assert(iNormalKey == so->nkeys - numExcludeOnly);
        Assert(iExcludeOnly == so->nkeys);
        /* ... and copy them back to so->keys[] */
        memcpy(so->keys, tmpkeys, so->nkeys * sizeof(GinScanKeyData));
        pfree(tmpkeys);
    }
 
    /*
     * If there are no regular scan keys, generate an EVERYTHING scankey to
     * drive a full-index scan.
     */
    if (so->nkeys == 0 && !so->isVoidRes)
    {
        hasNullQuery = true;
        ginFillScanKey(so, FirstOffsetNumber,
                       InvalidStrategy, GIN_SEARCH_MODE_EVERYTHING,
                       (Datum) 0, 0,
                       NULL, NULL, NULL, NULL);
    }
 
    /*
     * If the index is version 0, it may be missing null and placeholder
     * entries, which would render searches for nulls and full-index scans
     * unreliable.  Throw an error if so.
     */
    if (hasNullQuery && !so->isVoidRes)
    {
        GinStatsData ginStats;
 
        ginGetStats(scan->indexRelation, &ginStats);
        if (ginStats.ginVersion < 1)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("old GIN indexes do not support whole-index scans nor searches for nulls"),
                     errhint("To fix this, do REINDEX INDEX \"%s\".",
                             RelationGetRelationName(scan->indexRelation))));
    }
 
    MemoryContextSwitchTo(oldCtx);
 
    pgstat_count_index_scan(scan->indexRelation);
    if (scan->instrument)
        scan->instrument->nsearches++;
}

References Assert, DatumGetPointer(), ereport, errcode(), errhint(), errmsg, ERROR, fb(), FirstOffsetNumber, FunctionCall7Coll(), GIN_CAT_EMPTY_QUERY, GIN_CAT_NULL_KEY, GIN_SEARCH_MODE_ALL, GIN_SEARCH_MODE_DEFAULT, GIN_SEARCH_MODE_EVERYTHING, ginFillScanKey(), ginGetStats(), ginScanKeyAddHiddenEntry(), i, INDEX_MAX_KEYS, IndexScanDescData::indexRelation, IndexScanDescData::instrument, InvalidStrategy, j, IndexScanDescData::keyData, Max, MemoryContextSwitchTo(), IndexScanInstrumentation::nsearches, IndexScanDescData::numberOfKeys, IndexScanDescData::opaque, palloc(), palloc0(), pfree(), pgstat_count_index_scan, PointerGetDatum(), RelationGetRelationName, SK_ISNULL, and UInt16GetDatum().

Referenced by gingetbitmap().

ginoptions()

bytea * ginoptions ( Datum  reloptions, bool  validate  )

extern

Definition at line 571 of file ginutil.c.

{
    static const relopt_parse_elt tab[] = {
        {"fastupdate", RELOPT_TYPE_BOOL, offsetof(GinOptions, useFastUpdate)},
        {"gin_pending_list_limit", RELOPT_TYPE_INT, offsetof(GinOptions,
                                                             pendingListCleanupSize)}
    };
 
    return (bytea *) build_reloptions(reloptions, validate,
                                      RELOPT_KIND_GIN,
                                      sizeof(GinOptions),
                                      tab, lengthof(tab));
}

References build_reloptions(), fb(), lengthof, RELOPT_KIND_GIN, RELOPT_TYPE_BOOL, RELOPT_TYPE_INT, and validate().

Referenced by ginhandler().

GinPageDeletePostingItem()

void GinPageDeletePostingItem ( Page  page, OffsetNumber  offset  )

extern

Definition at line 417 of file gindatapage.c.

{
    OffsetNumber maxoff = GinPageGetOpaque(page)->maxoff;
 
    Assert(!GinPageIsLeaf(page));
    Assert(offset >= FirstOffsetNumber && offset <= maxoff);
 
    if (offset != maxoff)
        memmove(GinDataPageGetPostingItem(page, offset),
                GinDataPageGetPostingItem(page, offset + 1),
                sizeof(PostingItem) * (maxoff - offset));
 
    maxoff--;
    GinPageGetOpaque(page)->maxoff = maxoff;
 
    GinDataPageSetDataSize(page, maxoff * sizeof(PostingItem));
}

References Assert, fb(), FirstOffsetNumber, GinDataPageGetPostingItem, GinDataPageSetDataSize, GinPageGetOpaque, and GinPageIsLeaf.

Referenced by ginDeletePostingPage(), and ginRedoDeletePage().

ginPostingListDecode()

ItemPointer ginPostingListDecode ( GinPostingList *  plist, int *  ndecoded_out  )

extern

Definition at line 284 of file ginpostinglist.c.

{
    return ginPostingListDecodeAllSegments(plist,
                                           SizeOfGinPostingList(plist),
                                           ndecoded_out);
}

References fb(), ginPostingListDecodeAllSegments(), and SizeOfGinPostingList.

Referenced by addItemsToLeaf(), dataBeginPlaceToPageLeaf(), gin_leafpage_items(), ginCompressPostingList(), ginReadTuple(), ginReadTupleWithoutState(), ginRedoRecompress(), ginVacuumEntryPage(), ginVacuumPostingTreeLeaf(), leafRepackItems(), and test_itemptr_pair().

ginPostingListDecodeAllSegments()

ItemPointer ginPostingListDecodeAllSegments ( GinPostingList *  segment, int  len, int *  ndecoded_out  )

extern

Definition at line 297 of file ginpostinglist.c.

{
    ItemPointer result;
    int         nallocated;
    uint64      val;
    char       *endseg = ((char *) segment) + len;
    int         ndecoded;
    unsigned char *ptr;
    unsigned char *endptr;
 
    /*
     * Guess an initial size of the array.
     */
    nallocated = segment->nbytes * 2 + 1;
    result = palloc(nallocated * sizeof(ItemPointerData));
 
    ndecoded = 0;
    while ((char *) segment < endseg)
    {
        /* enlarge output array if needed */
        if (ndecoded >= nallocated)
        {
            nallocated *= 2;
            result = repalloc(result, nallocated * sizeof(ItemPointerData));
        }
 
        /* copy the first item */
        Assert(OffsetNumberIsValid(ItemPointerGetOffsetNumber(&segment->first)));
        Assert(ndecoded == 0 || ginCompareItemPointers(&segment->first, &result[ndecoded - 1]) > 0);
        result[ndecoded] = segment->first;
        ndecoded++;
 
        val = itemptr_to_uint64(&segment->first);
        ptr = segment->bytes;
        endptr = segment->bytes + segment->nbytes;
        while (ptr < endptr)
        {
            /* enlarge output array if needed */
            if (ndecoded >= nallocated)
            {
                nallocated *= 2;
                result = repalloc(result, nallocated * sizeof(ItemPointerData));
            }
 
            val += decode_varbyte(&ptr);
 
            uint64_to_itemptr(val, &result[ndecoded]);
            ndecoded++;
        }
        segment = GinNextPostingListSegment(segment);
    }
 
    if (ndecoded_out)
        *ndecoded_out = ndecoded;
    return result;
}

References Assert, GinPostingList::bytes, decode_varbyte(), fb(), GinPostingList::first, ginCompareItemPointers(), GinNextPostingListSegment, ItemPointerGetOffsetNumber(), itemptr_to_uint64(), len, GinPostingList::nbytes, OffsetNumberIsValid, palloc(), repalloc(), uint64_to_itemptr(), and val.

Referenced by _gin_parse_tuple_items(), GinDataLeafPageGetItems(), ginPostingListDecode(), and ginPostingListDecodeAllSegmentsToTbm().

ginPostingListDecodeAllSegmentsToTbm()

int ginPostingListDecodeAllSegmentsToTbm ( GinPostingList *  ptr, int  len, TIDBitmap *  tbm  )

extern

Definition at line 358 of file ginpostinglist.c.

{
    int         ndecoded;
    ItemPointer items;
 
    items = ginPostingListDecodeAllSegments(ptr, len, &ndecoded);
    tbm_add_tuples(tbm, items, ndecoded, false);
    pfree(items);
 
    return ndecoded;
}

References fb(), ginPostingListDecodeAllSegments(), items, len, pfree(), and tbm_add_tuples().

Referenced by GinDataLeafPageGetItemsToTbm().

ginPrepareEntryScan()

void ginPrepareEntryScan ( GinBtree  btree, OffsetNumber  attnum, Datum  key, GinNullCategory  category, GinState *  ginstate  )

extern

Definition at line 747 of file ginentrypage.c.

{
    memset(btree, 0, sizeof(GinBtreeData));
 
    btree->index = ginstate->index;
    btree->rootBlkno = GIN_ROOT_BLKNO;
    btree->ginstate = ginstate;
 
    btree->findChildPage = entryLocateEntry;
    btree->getLeftMostChild = entryGetLeftMostPage;
    btree->isMoveRight = entryIsMoveRight;
    btree->findItem = entryLocateLeafEntry;
    btree->findChildPtr = entryFindChildPtr;
    btree->beginPlaceToPage = entryBeginPlaceToPage;
    btree->execPlaceToPage = entryExecPlaceToPage;
    btree->fillRoot = ginEntryFillRoot;
    btree->prepareDownlink = entryPrepareDownlink;
 
    btree->isData = false;
    btree->fullScan = false;
    btree->isBuild = false;
 
    btree->entryAttnum = attnum;
    btree->entryKey = key;
    btree->entryCategory = category;
}

References attnum, GinBtreeData::beginPlaceToPage, GinBtreeData::entryAttnum, entryBeginPlaceToPage(), GinBtreeData::entryCategory, entryExecPlaceToPage(), entryFindChildPtr(), entryGetLeftMostPage(), entryIsMoveRight(), GinBtreeData::entryKey, entryLocateEntry(), entryLocateLeafEntry(), entryPrepareDownlink(), GinBtreeData::execPlaceToPage, fb(), GinBtreeData::fillRoot, GinBtreeData::findChildPage, GinBtreeData::findChildPtr, GinBtreeData::findItem, GinBtreeData::fullScan, GinBtreeData::getLeftMostChild, GIN_ROOT_BLKNO, ginEntryFillRoot(), GinBtreeData::ginstate, GinState::index, GinBtreeData::index, GinBtreeData::isBuild, GinBtreeData::isData, GinBtreeData::isMoveRight, GinBtreeData::prepareDownlink, and GinBtreeData::rootBlkno.

Referenced by ginEntryInsert(), and startScanEntry().

ginReadTuple()

ItemPointer ginReadTuple ( GinState *  ginstate, OffsetNumber  attnum, IndexTuple  itup, int *  nitems  )

extern

Definition at line 162 of file ginentrypage.c.

{
    Pointer     ptr = GinGetPosting(itup);
    int         nipd = GinGetNPosting(itup);
    ItemPointer ipd;
    int         ndecoded;
 
    if (GinItupIsCompressed(itup))
    {
        if (nipd > 0)
        {
            ipd = ginPostingListDecode(ptr, &ndecoded);
            if (nipd != ndecoded)
                elog(ERROR, "number of items mismatch in GIN entry tuple, %d in tuple header, %d decoded",
                     nipd, ndecoded);
        }
        else
        {
            ipd = palloc(0);
        }
    }
    else
    {
        ipd = palloc_array(ItemPointerData, nipd);
        memcpy(ipd, ptr, sizeof(ItemPointerData) * nipd);
    }
    *nitems = nipd;
    return ipd;
}

References elog, ERROR, fb(), GinGetNPosting, GinGetPosting, GinItupIsCompressed, ginPostingListDecode(), nitems, palloc(), and palloc_array.

Referenced by addItemPointersToLeafTuple(), collectMatchBitmap(), and startScanEntry().

ginrescan()

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

extern

Definition at line 491 of file ginscan.c.

{
    GinScanOpaque so = (GinScanOpaque) scan->opaque;
 
    ginFreeScanKeys(so);
 
    if (scankey && scan->numberOfKeys > 0)
        memcpy(scan->keyData, scankey, scan->numberOfKeys * sizeof(ScanKeyData));
}

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

Referenced by ginhandler().

ginScanBeginPostingTree()

GinBtreeStack * ginScanBeginPostingTree ( GinBtree  btree, Relation  index, BlockNumber  rootBlkno  )

extern

Definition at line 1936 of file gindatapage.c.

{
    GinBtreeStack *stack;
 
    ginPrepareDataScan(btree, index, rootBlkno);
 
    btree->fullScan = true;
 
    stack = ginFindLeafPage(btree, true, false);
 
    return stack;
}

References GinBtreeData::fullScan, ginFindLeafPage(), and ginPrepareDataScan().

Referenced by scanPostingTree(), and startScanEntry().

ginStepRight()

Buffer ginStepRight ( Buffer  buffer, Relation  index, int  lockmode  )

extern

Definition at line 177 of file ginbtree.c.

{
    Buffer      nextbuffer;
    Page        page = BufferGetPage(buffer);
    bool        isLeaf = GinPageIsLeaf(page);
    bool        isData = GinPageIsData(page);
    BlockNumber blkno = GinPageGetOpaque(page)->rightlink;
 
    nextbuffer = ReadBuffer(index, blkno);
    LockBuffer(nextbuffer, lockmode);
    UnlockReleaseBuffer(buffer);
 
    /* Sanity check that the page we stepped to is of similar kind. */
    page = BufferGetPage(nextbuffer);
    if (isLeaf != GinPageIsLeaf(page) || isData != GinPageIsData(page))
        elog(ERROR, "right sibling of GIN page is of different type");
 
    return nextbuffer;
}

References BufferGetPage(), elog, ERROR, fb(), GinPageGetOpaque, GinPageIsData, GinPageIsLeaf, LockBuffer(), ReadBuffer(), and UnlockReleaseBuffer().

Referenced by entryLoadMoreItems(), ginFindLeafPage(), ginFindParents(), ginFinishSplit(), moveRightIfItNeeded(), and scanPostingTree().

ginTraverseLock()

int ginTraverseLock ( Buffer  buffer, bool  searchMode  )

extern

Definition at line 39 of file ginbtree.c.

{
    Page        page;
    int         access = GIN_SHARE;
 
    LockBuffer(buffer, GIN_SHARE);
    page = BufferGetPage(buffer);
    if (GinPageIsLeaf(page))
    {
        if (searchMode == false)
        {
            /* we should relock our page */
            LockBuffer(buffer, GIN_UNLOCK);
            LockBuffer(buffer, GIN_EXCLUSIVE);
 
            /* But root can become non-leaf during relock */
            if (!GinPageIsLeaf(page))
            {
                /* restore old lock type (very rare) */
                LockBuffer(buffer, GIN_UNLOCK);
                LockBuffer(buffer, GIN_SHARE);
            }
            else
                access = GIN_EXCLUSIVE;
        }
    }
 
    return access;
}

References BufferGetPage(), GIN_EXCLUSIVE, GIN_SHARE, GIN_UNLOCK, GinPageIsLeaf, and LockBuffer().

Referenced by ginFindLeafPage().

gintuple_get_attrnum()

OffsetNumber gintuple_get_attrnum ( GinState *  ginstate, IndexTuple  tuple  )

extern

Definition at line 233 of file ginutil.c.

{
    OffsetNumber colN;
 
    if (ginstate->oneCol)
    {
        /* column number is not stored explicitly */
        colN = FirstOffsetNumber;
    }
    else
    {
        Datum       res;
        bool        isnull;
 
        /*
         * First attribute is always int16, so we can safely use any tuple
         * descriptor to obtain first attribute of tuple
         */
        res = index_getattr(tuple, FirstOffsetNumber, ginstate->tupdesc[0],
                            &isnull);
        Assert(!isnull);
 
        colN = DatumGetUInt16(res);
        Assert(colN >= FirstOffsetNumber && colN <= ginstate->origTupdesc->natts);
    }
 
    return colN;
}

References Assert, DatumGetUInt16(), fb(), FirstOffsetNumber, index_getattr(), GinState::oneCol, and GinState::tupdesc.

Referenced by addItemPointersToLeafTuple(), collectMatchBitmap(), collectMatchesForHeapRow(), entryIsMoveRight(), entryLocateEntry(), entryLocateLeafEntry(), gin_check_parent_keys_consistency(), gintuple_get_key(), ginVacuumEntryPage(), matchPartialInPendingList(), and processPendingPage().

gintuple_get_key()

Datum gintuple_get_key ( GinState *  ginstate, IndexTuple  tuple, GinNullCategory *  category  )

extern

Definition at line 266 of file ginutil.c.

{
    Datum       res;
    bool        isnull;
 
    if (ginstate->oneCol)
    {
        /*
         * Single column index doesn't store attribute numbers in tuples
         */
        res = index_getattr(tuple, FirstOffsetNumber, ginstate->origTupdesc,
                            &isnull);
    }
    else
    {
        /*
         * Since the datum type depends on which index column it's from, we
         * must be careful to use the right tuple descriptor here.
         */
        OffsetNumber colN = gintuple_get_attrnum(ginstate, tuple);
 
        res = index_getattr(tuple, OffsetNumberNext(FirstOffsetNumber),
                            ginstate->tupdesc[colN - 1],
                            &isnull);
    }
 
    if (isnull)
        *category = GinGetNullCategory(tuple, ginstate);
    else
        *category = GIN_CAT_NORM_KEY;
 
    return res;
}

References fb(), FirstOffsetNumber, GIN_CAT_NORM_KEY, GinGetNullCategory, gintuple_get_attrnum(), index_getattr(), OffsetNumberNext, GinState::oneCol, GinState::origTupdesc, and GinState::tupdesc.

Referenced by addItemPointersToLeafTuple(), collectMatchBitmap(), collectMatchesForHeapRow(), entryIsMoveRight(), entryLocateEntry(), entryLocateLeafEntry(), gin_check_parent_keys_consistency(), ginVacuumEntryPage(), matchPartialInPendingList(), and processPendingPage().

ginvacuumcleanup()

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

extern

Definition at line 725 of file ginvacuum.c.

{
    Relation    index = info->index;
    bool        needLock;
    BlockNumber npages,
                blkno;
    BlockNumber totFreePages;
    GinState    ginstate;
    GinStatsData idxStat;
    BlockRangeReadStreamPrivate p;
    ReadStream *stream;
 
    /*
     * In an autovacuum analyze, we want to clean up pending insertions.
     * Otherwise, an ANALYZE-only call is a no-op.
     */
    if (info->analyze_only)
    {
        if (AmAutoVacuumWorkerProcess())
        {
            initGinState(&ginstate, index);
            ginInsertCleanup(&ginstate, false, true, true, stats);
        }
        return stats;
    }
 
    /*
     * Set up all-zero stats and cleanup pending inserts if ginbulkdelete
     * wasn't called
     */
    if (stats == NULL)
    {
        stats = palloc0_object(IndexBulkDeleteResult);
        initGinState(&ginstate, index);
        ginInsertCleanup(&ginstate, !AmAutoVacuumWorkerProcess(),
                         false, true, stats);
    }
 
    memset(&idxStat, 0, sizeof(idxStat));
 
    /*
     * XXX we always report the heap tuple count as the number of index
     * entries.  This is bogus if the index is partial, but it's real hard to
     * tell how many distinct heap entries are referenced by a GIN index.
     */
    stats->num_index_tuples = Max(info->num_heap_tuples, 0);
    stats->estimated_count = info->estimated_count;
 
    /*
     * Need lock unless it's local to this backend.
     */
    needLock = !RELATION_IS_LOCAL(index);
 
    if (needLock)
        LockRelationForExtension(index, ExclusiveLock);
    npages = RelationGetNumberOfBlocks(index);
    if (needLock)
        UnlockRelationForExtension(index, ExclusiveLock);
 
    totFreePages = 0;
 
    /* Scan all blocks starting from the root using streaming reads */
    p.current_blocknum = GIN_ROOT_BLKNO;
    p.last_exclusive = npages;
 
    /*
     * It is safe to use batchmode as block_range_read_stream_cb takes no
     * locks.
     */
    stream = read_stream_begin_relation(READ_STREAM_MAINTENANCE |
                                        READ_STREAM_FULL |
                                        READ_STREAM_USE_BATCHING,
                                        info->strategy,
                                        index,
                                        MAIN_FORKNUM,
                                        block_range_read_stream_cb,
                                        &p,
                                        0);
 
    for (blkno = GIN_ROOT_BLKNO; blkno < npages; blkno++)
    {
        Buffer      buffer;
        Page        page;
 
        vacuum_delay_point(false);
 
        buffer = read_stream_next_buffer(stream, NULL);
 
        LockBuffer(buffer, GIN_SHARE);
        page = BufferGetPage(buffer);
 
        if (GinPageIsRecyclable(page))
        {
            Assert(blkno != GIN_ROOT_BLKNO);
            RecordFreeIndexPage(index, blkno);
            totFreePages++;
        }
        else if (GinPageIsData(page))
        {
            idxStat.nDataPages++;
        }
        else if (!GinPageIsList(page))
        {
            idxStat.nEntryPages++;
 
            if (GinPageIsLeaf(page))
                idxStat.nEntries += PageGetMaxOffsetNumber(page);
        }
 
        UnlockReleaseBuffer(buffer);
    }
 
    Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
    read_stream_end(stream);
 
    /* Update the metapage with accurate page and entry counts */
    idxStat.nTotalPages = npages;
    ginUpdateStats(info->index, &idxStat, false);
 
    /* Finally, vacuum the FSM */
    IndexFreeSpaceMapVacuum(info->index);
 
    stats->pages_free = totFreePages;
 
    if (needLock)
        LockRelationForExtension(index, ExclusiveLock);
    stats->num_pages = RelationGetNumberOfBlocks(index);
    if (needLock)
        UnlockRelationForExtension(index, ExclusiveLock);
 
    return stats;
}

References AmAutoVacuumWorkerProcess, IndexVacuumInfo::analyze_only, Assert, block_range_read_stream_cb(), DataPageDeleteStack::buffer, BufferGetPage(), BlockRangeReadStreamPrivate::current_blocknum, IndexVacuumInfo::estimated_count, IndexBulkDeleteResult::estimated_count, ExclusiveLock, fb(), GIN_ROOT_BLKNO, GIN_SHARE, ginInsertCleanup(), GinPageIsData, GinPageIsLeaf, GinPageIsList, GinPageIsRecyclable(), ginUpdateStats(), IndexVacuumInfo::index, IndexFreeSpaceMapVacuum(), initGinState(), InvalidBuffer, BlockRangeReadStreamPrivate::last_exclusive, LockBuffer(), LockRelationForExtension(), MAIN_FORKNUM, Max, IndexVacuumInfo::num_heap_tuples, IndexBulkDeleteResult::num_index_tuples, IndexBulkDeleteResult::num_pages, PageGetMaxOffsetNumber(), IndexBulkDeleteResult::pages_free, palloc0_object, read_stream_begin_relation(), read_stream_end(), READ_STREAM_FULL, READ_STREAM_MAINTENANCE, read_stream_next_buffer(), READ_STREAM_USE_BATCHING, RecordFreeIndexPage(), RELATION_IS_LOCAL, RelationGetNumberOfBlocks, IndexVacuumInfo::strategy, UnlockRelationForExtension(), UnlockReleaseBuffer(), and vacuum_delay_point().

Referenced by ginhandler().

ginVacuumItemPointers()

ItemPointer ginVacuumItemPointers ( GinVacuumState *  gvs, ItemPointerData *  items, int  nitem, int *  nremaining  )

extern

Definition at line 48 of file ginvacuum.c.

{
    int         i,
                remaining = 0;
    ItemPointer tmpitems = NULL;
 
    /*
     * Iterate over TIDs array
     */
    for (i = 0; i < nitem; i++)
    {
        if (gvs->callback(items + i, gvs->callback_state))
        {
            gvs->result->tuples_removed += 1;
            if (!tmpitems)
            {
                /*
                 * First TID to be deleted: allocate memory to hold the
                 * remaining items.
                 */
                tmpitems = palloc_array(ItemPointerData, nitem);
                memcpy(tmpitems, items, sizeof(ItemPointerData) * i);
            }
        }
        else
        {
            gvs->result->num_index_tuples += 1;
            if (tmpitems)
                tmpitems[remaining] = items[i];
            remaining++;
        }
    }
 
    *nremaining = remaining;
    return tmpitems;
}

References fb(), i, items, palloc_array, and remaining.

Referenced by ginVacuumEntryPage(), and ginVacuumPostingTreeLeaf().

ginVacuumPostingTreeLeaf()

void ginVacuumPostingTreeLeaf ( Relation  indexrel, Buffer  buffer, GinVacuumState *  gvs  )

extern

Definition at line 738 of file gindatapage.c.

{
    Page        page = BufferGetPage(buffer);
    disassembledLeaf *leaf;
    bool        removedsomething = false;
    dlist_iter  iter;
 
    leaf = disassembleLeaf(page);
 
    /* Vacuum each segment. */
    dlist_foreach(iter, &leaf->segments)
    {
        leafSegmentInfo *seginfo = dlist_container(leafSegmentInfo, node, iter.cur);
        int         oldsegsize;
        ItemPointer cleaned;
        int         ncleaned;
 
        if (!seginfo->items)
            seginfo->items = ginPostingListDecode(seginfo->seg,
                                                  &seginfo->nitems);
        if (seginfo->seg)
            oldsegsize = SizeOfGinPostingList(seginfo->seg);
        else
            oldsegsize = GinDataPageMaxDataSize;
 
        cleaned = ginVacuumItemPointers(gvs,
                                        seginfo->items,
                                        seginfo->nitems,
                                        &ncleaned);
        pfree(seginfo->items);
        seginfo->items = NULL;
        seginfo->nitems = 0;
        if (cleaned)
        {
            if (ncleaned > 0)
            {
                int         npacked;
 
                seginfo->seg = ginCompressPostingList(cleaned,
                                                      ncleaned,
                                                      oldsegsize,
                                                      &npacked);
                /* Removing an item never increases the size of the segment */
                if (npacked != ncleaned)
                    elog(ERROR, "could not fit vacuumed posting list");
                seginfo->action = GIN_SEGMENT_REPLACE;
            }
            else
            {
                seginfo->seg = NULL;
                seginfo->items = NULL;
                seginfo->action = GIN_SEGMENT_DELETE;
            }
            seginfo->nitems = ncleaned;
 
            removedsomething = true;
        }
    }
 
    /*
     * If we removed any items, reconstruct the page from the pieces.
     *
     * We don't try to re-encode the segments here, even though some of them
     * might be really small now that we've removed some items from them. It
     * seems like a waste of effort, as there isn't really any benefit from
     * larger segments per se; larger segments only help to pack more items in
     * the same space. We might as well delay doing that until the next
     * insertion, which will need to re-encode at least part of the page
     * anyway.
     *
     * Also note if the page was in uncompressed, pre-9.4 format before, it is
     * now represented as one huge segment that contains all the items. It
     * might make sense to split that, to speed up random access, but we don't
     * bother. You'll have to REINDEX anyway if you want the full gain of the
     * new tighter index format.
     */
    if (removedsomething)
    {
        bool        modified;
 
        /*
         * Make sure we have a palloc'd copy of all segments, after the first
         * segment that is modified. (dataPlaceToPageLeafRecompress requires
         * this).
         */
        modified = false;
        dlist_foreach(iter, &leaf->segments)
        {
            leafSegmentInfo *seginfo = dlist_container(leafSegmentInfo, node,
                                                       iter.cur);
 
            if (seginfo->action != GIN_SEGMENT_UNMODIFIED)
                modified = true;
            if (modified && seginfo->action != GIN_SEGMENT_DELETE)
            {
                int         segsize = SizeOfGinPostingList(seginfo->seg);
                GinPostingList *tmp = (GinPostingList *) palloc(segsize);
 
                memcpy(tmp, seginfo->seg, segsize);
                seginfo->seg = tmp;
            }
        }
 
        if (RelationNeedsWAL(indexrel))
            computeLeafRecompressWALData(leaf);
 
        /* Apply changes to page */
        START_CRIT_SECTION();
 
        dataPlaceToPageLeafRecompress(buffer, leaf);
 
        MarkBufferDirty(buffer);
 
        if (RelationNeedsWAL(indexrel))
        {
            XLogRecPtr  recptr;
 
            XLogBeginInsert();
            XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
            XLogRegisterBufData(0, leaf->walinfo, leaf->walinfolen);
            recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_VACUUM_DATA_LEAF_PAGE);
            PageSetLSN(page, recptr);
        }
 
        END_CRIT_SECTION();
    }
}

References BufferGetPage(), computeLeafRecompressWALData(), dlist_iter::cur, dataPlaceToPageLeafRecompress(), disassembleLeaf(), dlist_container, dlist_foreach, elog, END_CRIT_SECTION, ERROR, fb(), GIN_SEGMENT_DELETE, GIN_SEGMENT_REPLACE, GIN_SEGMENT_UNMODIFIED, ginCompressPostingList(), GinDataPageMaxDataSize, ginPostingListDecode(), ginVacuumItemPointers(), MarkBufferDirty(), PageSetLSN(), palloc(), pfree(), REGBUF_STANDARD, RelationNeedsWAL, SizeOfGinPostingList, START_CRIT_SECTION, XLOG_GIN_VACUUM_DATA_LEAF_PAGE, XLogBeginInsert(), XLogInsert(), XLogRegisterBufData(), and XLogRegisterBuffer().

Referenced by ginVacuumPostingTreeLeaves().

ginvalidate()

bool ginvalidate ( Oid  opclassoid )

extern

Definition at line 31 of file ginvalidate.c.

{
    bool        result = true;
    HeapTuple   classtup;
    Form_pg_opclass classform;
    Oid         opfamilyoid;
    Oid         opcintype;
    Oid         opckeytype;
    char       *opclassname;
    char       *opfamilyname;
    CatCList   *proclist,
               *oprlist;
    List       *grouplist;
    OpFamilyOpFuncGroup *opclassgroup;
    int         i;
    ListCell   *lc;
 
    /* Fetch opclass information */
    classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassoid));
    if (!HeapTupleIsValid(classtup))
        elog(ERROR, "cache lookup failed for operator class %u", opclassoid);
    classform = (Form_pg_opclass) GETSTRUCT(classtup);
 
    opfamilyoid = classform->opcfamily;
    opcintype = classform->opcintype;
    opckeytype = classform->opckeytype;
    if (!OidIsValid(opckeytype))
        opckeytype = opcintype;
    opclassname = NameStr(classform->opcname);
 
    /* Fetch opfamily information */
    opfamilyname = get_opfamily_name(opfamilyoid, false);
 
    /* Fetch all operators and support functions of the opfamily */
    oprlist = SearchSysCacheList1(AMOPSTRATEGY, ObjectIdGetDatum(opfamilyoid));
    proclist = SearchSysCacheList1(AMPROCNUM, ObjectIdGetDatum(opfamilyoid));
 
    /* Check individual support functions */
    for (i = 0; i < proclist->n_members; i++)
    {
        HeapTuple   proctup = &proclist->members[i]->tuple;
        Form_pg_amproc procform = (Form_pg_amproc) GETSTRUCT(proctup);
        bool        ok;
 
        /*
         * All GIN support functions should be registered with matching
         * left/right types
         */
        if (procform->amproclefttype != procform->amprocrighttype)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains support function %s with different left and right input types",
                            opfamilyname, "gin",
                            format_procedure(procform->amproc))));
            result = false;
        }
 
        /*
         * We can't check signatures except within the specific opclass, since
         * we need to know the associated opckeytype in many cases.
         */
        if (procform->amproclefttype != opcintype)
            continue;
 
        /* Check procedure numbers and function signatures */
        switch (procform->amprocnum)
        {
            case GIN_COMPARE_PROC:
                ok = check_amproc_signature(procform->amproc, INT4OID, false,
                                            2, 2, opckeytype, opckeytype);
                break;
            case GIN_EXTRACTVALUE_PROC:
                /* Some opclasses omit nullFlags */
                ok = check_amproc_signature(procform->amproc, INTERNALOID, false,
                                            2, 3, opcintype, INTERNALOID,
                                            INTERNALOID);
                break;
            case GIN_EXTRACTQUERY_PROC:
                /* Some opclasses omit nullFlags and searchMode */
                ok = check_amproc_signature(procform->amproc, INTERNALOID, false,
                                            5, 7, opcintype, INTERNALOID,
                                            INT2OID, INTERNALOID, INTERNALOID,
                                            INTERNALOID, INTERNALOID);
                break;
            case GIN_CONSISTENT_PROC:
                /* Some opclasses omit queryKeys and nullFlags */
                ok = check_amproc_signature(procform->amproc, BOOLOID, false,
                                            6, 8, INTERNALOID, INT2OID,
                                            opcintype, INT4OID,
                                            INTERNALOID, INTERNALOID,
                                            INTERNALOID, INTERNALOID);
                break;
            case GIN_COMPARE_PARTIAL_PROC:
                ok = check_amproc_signature(procform->amproc, INT4OID, false,
                                            4, 4, opckeytype, opckeytype,
                                            INT2OID, INTERNALOID);
                break;
            case GIN_TRICONSISTENT_PROC:
                ok = check_amproc_signature(procform->amproc, CHAROID, false,
                                            7, 7, INTERNALOID, INT2OID,
                                            opcintype, INT4OID,
                                            INTERNALOID, INTERNALOID,
                                            INTERNALOID);
                break;
            case GIN_OPTIONS_PROC:
                ok = check_amoptsproc_signature(procform->amproc);
                break;
            default:
                ereport(INFO,
                        (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                         errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d",
                                opfamilyname, "gin",
                                format_procedure(procform->amproc),
                                procform->amprocnum)));
                result = false;
                continue;       /* don't want additional message */
        }
 
        if (!ok)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d",
                            opfamilyname, "gin",
                            format_procedure(procform->amproc),
                            procform->amprocnum)));
            result = false;
        }
    }
 
    /* Check individual operators */
    for (i = 0; i < oprlist->n_members; i++)
    {
        HeapTuple   oprtup = &oprlist->members[i]->tuple;
        Form_pg_amop oprform = (Form_pg_amop) GETSTRUCT(oprtup);
 
        /* TODO: Check that only allowed strategy numbers exist */
        if (oprform->amopstrategy < 1 || oprform->amopstrategy > 63)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d",
                            opfamilyname, "gin",
                            format_operator(oprform->amopopr),
                            oprform->amopstrategy)));
            result = false;
        }
 
        /* gin doesn't support ORDER BY operators */
        if (oprform->amoppurpose != AMOP_SEARCH ||
            OidIsValid(oprform->amopsortfamily))
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s",
                            opfamilyname, "gin",
                            format_operator(oprform->amopopr))));
            result = false;
        }
 
        /* Check operator signature --- same for all gin strategies */
        if (!check_amop_signature(oprform->amopopr, BOOLOID,
                                  oprform->amoplefttype,
                                  oprform->amoprighttype))
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature",
                            opfamilyname, "gin",
                            format_operator(oprform->amopopr))));
            result = false;
        }
    }
 
    /* Now check for inconsistent groups of operators/functions */
    grouplist = identify_opfamily_groups(oprlist, proclist);
    opclassgroup = NULL;
    foreach(lc, grouplist)
    {
        OpFamilyOpFuncGroup *thisgroup = (OpFamilyOpFuncGroup *) lfirst(lc);
 
        /* Remember the group exactly matching the test opclass */
        if (thisgroup->lefttype == opcintype &&
            thisgroup->righttype == opcintype)
            opclassgroup = thisgroup;
 
        /*
         * There is not a lot we can do to check the operator sets, since each
         * GIN opclass is more or less a law unto itself, and some contain
         * only operators that are binary-compatible with the opclass datatype
         * (meaning that empty operator sets can be OK).  That case also means
         * that we shouldn't insist on nonempty function sets except for the
         * opclass's own group.
         */
    }
 
    /* Check that the originally-named opclass is complete */
    for (i = 1; i <= GINNProcs; i++)
    {
        if (opclassgroup &&
            (opclassgroup->functionset & (((uint64) 1) << i)) != 0)
            continue;           /* got it */
        if (i == GIN_COMPARE_PROC || i == GIN_COMPARE_PARTIAL_PROC ||
            i == GIN_OPTIONS_PROC)
            continue;           /* optional method */
        if (i == GIN_CONSISTENT_PROC || i == GIN_TRICONSISTENT_PROC)
            continue;           /* don't need both, see check below loop */
        ereport(INFO,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("operator class \"%s\" of access method %s is missing support function %d",
                        opclassname, "gin", i)));
        result = false;
    }
    if (!opclassgroup ||
        ((opclassgroup->functionset & (1 << GIN_CONSISTENT_PROC)) == 0 &&
         (opclassgroup->functionset & (1 << GIN_TRICONSISTENT_PROC)) == 0))
    {
        ereport(INFO,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("operator class \"%s\" of access method %s is missing support function %d or %d",
                        opclassname, "gin",
                        GIN_CONSISTENT_PROC, GIN_TRICONSISTENT_PROC)));
        result = false;
    }
 
 
    ReleaseCatCacheList(proclist);
    ReleaseCatCacheList(oprlist);
    ReleaseSysCache(classtup);
 
    return result;
}

References check_amop_signature(), check_amoptsproc_signature(), check_amproc_signature(), elog, ereport, errcode(), errmsg, ERROR, fb(), Form_pg_amop, Form_pg_amproc, Form_pg_opclass, format_operator(), format_procedure(), get_opfamily_name(), GETSTRUCT(), GIN_COMPARE_PARTIAL_PROC, GIN_COMPARE_PROC, GIN_CONSISTENT_PROC, GIN_EXTRACTQUERY_PROC, GIN_EXTRACTVALUE_PROC, GIN_OPTIONS_PROC, GIN_TRICONSISTENT_PROC, GINNProcs, HeapTupleIsValid, i, identify_opfamily_groups(), INFO, lfirst, NameStr, ObjectIdGetDatum(), OidIsValid, ReleaseCatCacheList(), ReleaseSysCache(), SearchSysCache1(), and SearchSysCacheList1.

Referenced by ginhandler().

initGinState()

void initGinState ( GinState *  state, Relation  index  )

extern

Definition at line 103 of file ginutil.c.

{
    TupleDesc   origTupdesc = RelationGetDescr(index);
    int         i;
 
    MemSet(state, 0, sizeof(GinState));
 
    state->index = index;
    state->oneCol = (origTupdesc->natts == 1);
    state->origTupdesc = origTupdesc;
 
    for (i = 0; i < origTupdesc->natts; i++)
    {
        Form_pg_attribute attr = TupleDescAttr(origTupdesc, i);
 
        if (state->oneCol)
            state->tupdesc[i] = state->origTupdesc;
        else
        {
            state->tupdesc[i] = CreateTemplateTupleDesc(2);
 
            TupleDescInitEntry(state->tupdesc[i], (AttrNumber) 1, NULL,
                               INT2OID, -1, 0);
            TupleDescInitEntry(state->tupdesc[i], (AttrNumber) 2, NULL,
                               attr->atttypid,
                               attr->atttypmod,
                               attr->attndims);
            TupleDescInitEntryCollation(state->tupdesc[i], (AttrNumber) 2,
                                        attr->attcollation);
            TupleDescFinalize(state->tupdesc[i]);
        }
 
        /*
         * If the compare proc isn't specified in the opclass definition, look
         * up the index key type's default btree comparator.
         */
        if (index_getprocid(index, i + 1, GIN_COMPARE_PROC) != InvalidOid)
        {
            fmgr_info_copy(&(state->compareFn[i]),
                           index_getprocinfo(index, i + 1, GIN_COMPARE_PROC),
                           CurrentMemoryContext);
        }
        else
        {
            TypeCacheEntry *typentry;
 
            typentry = lookup_type_cache(attr->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(attr->atttypid))));
            fmgr_info_copy(&(state->compareFn[i]),
                           &(typentry->cmp_proc_finfo),
                           CurrentMemoryContext);
        }
 
        /* Opclass must always provide extract procs */
        fmgr_info_copy(&(state->extractValueFn[i]),
                       index_getprocinfo(index, i + 1, GIN_EXTRACTVALUE_PROC),
                       CurrentMemoryContext);
        fmgr_info_copy(&(state->extractQueryFn[i]),
                       index_getprocinfo(index, i + 1, GIN_EXTRACTQUERY_PROC),
                       CurrentMemoryContext);
 
        /*
         * Check opclass capability to do tri-state or binary logic consistent
         * check.
         */
        if (index_getprocid(index, i + 1, GIN_TRICONSISTENT_PROC) != InvalidOid)
        {
            fmgr_info_copy(&(state->triConsistentFn[i]),
                           index_getprocinfo(index, i + 1, GIN_TRICONSISTENT_PROC),
                           CurrentMemoryContext);
        }
 
        if (index_getprocid(index, i + 1, GIN_CONSISTENT_PROC) != InvalidOid)
        {
            fmgr_info_copy(&(state->consistentFn[i]),
                           index_getprocinfo(index, i + 1, GIN_CONSISTENT_PROC),
                           CurrentMemoryContext);
        }
 
        if (state->consistentFn[i].fn_oid == InvalidOid &&
            state->triConsistentFn[i].fn_oid == InvalidOid)
        {
            elog(ERROR, "missing GIN support function (%d or %d) for attribute %d of index \"%s\"",
                 GIN_CONSISTENT_PROC, GIN_TRICONSISTENT_PROC,
                 i + 1, RelationGetRelationName(index));
        }
 
        /*
         * Check opclass capability to do partial match.
         */
        if (index_getprocid(index, i + 1, GIN_COMPARE_PARTIAL_PROC) != InvalidOid)
        {
            fmgr_info_copy(&(state->comparePartialFn[i]),
                           index_getprocinfo(index, i + 1, GIN_COMPARE_PARTIAL_PROC),
                           CurrentMemoryContext);
            state->canPartialMatch[i] = true;
        }
        else
        {
            state->canPartialMatch[i] = false;
        }
 
        /*
         * If the index column has a specified collation, we should honor that
         * while doing comparisons.  However, we may have a collatable storage
         * type for a noncollatable indexed data type (for instance, hstore
         * uses text index entries).  If there's no index collation then
         * specify default collation in case the support functions need
         * collation.  This is harmless if the support functions don't care
         * about collation, so we just do it unconditionally.  (We could
         * alternatively call get_typcollation, but that seems like expensive
         * overkill --- there aren't going to be any cases where a GIN storage
         * type has a nondefault collation.)
         */
        if (OidIsValid(index->rd_indcollation[i]))
            state->supportCollation[i] = index->rd_indcollation[i];
        else
            state->supportCollation[i] = DEFAULT_COLLATION_OID;
    }
}

References TypeCacheEntry::cmp_proc_finfo, CreateTemplateTupleDesc(), CurrentMemoryContext, elog, ereport, errcode(), errmsg, ERROR, fb(), fmgr_info_copy(), FmgrInfo::fn_oid, format_type_be(), GIN_COMPARE_PARTIAL_PROC, GIN_COMPARE_PROC, GIN_CONSISTENT_PROC, GIN_EXTRACTQUERY_PROC, GIN_EXTRACTVALUE_PROC, GIN_TRICONSISTENT_PROC, i, index_getprocid(), index_getprocinfo(), InvalidOid, lookup_type_cache(), MemSet, TupleDescData::natts, OidIsValid, RelationGetDescr, RelationGetRelationName, TupleDescAttr(), TupleDescFinalize(), TupleDescInitEntry(), TupleDescInitEntryCollation(), and TYPECACHE_CMP_PROC_FINFO.

Referenced by _gin_parallel_build_main(), gin_check_parent_keys_consistency(), gin_clean_pending_list(), ginbeginscan(), ginbuild(), ginbulkdelete(), gininsert(), and ginvacuumcleanup().