gin.h File Reference

#include "access/xlogreader.h"
#include "lib/stringinfo.h"
#include "storage/block.h"
#include "storage/dsm.h"
#include "storage/shm_toc.h"
#include "utils/relcache.h"

Include dependency graph for gin.h:

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

Go to the source code of this file.

Data Structures
struct	GinStatsData

Macros
#define	GIN_COMPARE_PROC   1
#define	GIN_EXTRACTVALUE_PROC   2
#define	GIN_EXTRACTQUERY_PROC   3
#define	GIN_CONSISTENT_PROC   4
#define	GIN_COMPARE_PARTIAL_PROC   5
#define	GIN_TRICONSISTENT_PROC   6
#define	GIN_OPTIONS_PROC   7
#define	GINNProcs   7
#define	GIN_SEARCH_MODE_DEFAULT   0
#define	GIN_SEARCH_MODE_INCLUDE_EMPTY   1
#define	GIN_SEARCH_MODE_ALL   2
#define	GIN_SEARCH_MODE_EVERYTHING   3 /* for internal use only */
#define	PROGRESS_GIN_PHASE_INDEXBUILD_TABLESCAN   2
#define	PROGRESS_GIN_PHASE_PERFORMSORT_1   3
#define	PROGRESS_GIN_PHASE_MERGE_1   4
#define	PROGRESS_GIN_PHASE_PERFORMSORT_2   5
#define	PROGRESS_GIN_PHASE_MERGE_2   6
#define	GIN_FALSE   0 /* item is not present / does not match */
#define	GIN_TRUE   1 /* item is present / matches */
#define	GIN_MAYBE
#define	PG_RETURN_GIN_TERNARY_VALUE(x)   return GinTernaryValueGetDatum(x)

Typedefs
typedef struct GinStatsData	GinStatsData
typedef char	GinTernaryValue

Functions
	StaticAssertDecl (sizeof(GinTernaryValue)==sizeof(bool), "sizes of GinTernaryValue and bool are not equal")
static GinTernaryValue	DatumGetGinTernaryValue (Datum X)
static Datum	GinTernaryValueGetDatum (GinTernaryValue X)
void	ginGetStats (Relation index, GinStatsData *stats)
void	ginUpdateStats (Relation index, const GinStatsData *stats, bool is_build)
void	_gin_parallel_build_main (dsm_segment *seg, shm_toc *toc)

Variables
PGDLLIMPORT int	GinFuzzySearchLimit
PGDLLIMPORT int	gin_pending_list_limit

Macro Definition Documentation

GIN_COMPARE_PARTIAL_PROC

#define GIN_COMPARE_PARTIAL_PROC   5

Definition at line 28 of file gin.h.

GIN_COMPARE_PROC

#define GIN_COMPARE_PROC   1

Definition at line 24 of file gin.h.

GIN_CONSISTENT_PROC

#define GIN_CONSISTENT_PROC   4

Definition at line 27 of file gin.h.

GIN_EXTRACTQUERY_PROC

#define GIN_EXTRACTQUERY_PROC   3

Definition at line 26 of file gin.h.

GIN_EXTRACTVALUE_PROC

#define GIN_EXTRACTVALUE_PROC   2

Definition at line 25 of file gin.h.

GIN_FALSE

#define GIN_FALSE   0 /* item is not present / does not match */

Definition at line 76 of file gin.h.

GIN_MAYBE

#define GIN_MAYBE

Value:

                                 2      /* don't know if item is present / don't know
                                 * if matches */

Definition at line 78 of file gin.h.

{
    return (GinTernaryValue) X;
}
 
static inline Datum
GinTernaryValueGetDatum(GinTernaryValue X)
{
    return (Datum) X;
}
 
#define PG_RETURN_GIN_TERNARY_VALUE(x) return GinTernaryValueGetDatum(x)
 
/* GUC parameters */
extern PGDLLIMPORT int GinFuzzySearchLimit;
extern PGDLLIMPORT int gin_pending_list_limit;
 
/* ginutil.c */
extern void ginGetStats(Relation index, GinStatsData *stats);
extern void ginUpdateStats(Relation index, const GinStatsData *stats,
                           bool is_build);
 
extern void _gin_parallel_build_main(dsm_segment *seg, shm_toc *toc);
 
#endif                          /* GIN_H */

GIN_OPTIONS_PROC

#define GIN_OPTIONS_PROC   7

Definition at line 30 of file gin.h.

GIN_SEARCH_MODE_ALL

#define GIN_SEARCH_MODE_ALL   2

Definition at line 38 of file gin.h.

GIN_SEARCH_MODE_DEFAULT

#define GIN_SEARCH_MODE_DEFAULT   0

Definition at line 36 of file gin.h.

GIN_SEARCH_MODE_EVERYTHING

#define GIN_SEARCH_MODE_EVERYTHING   3 /* for internal use only */

Definition at line 39 of file gin.h.

GIN_SEARCH_MODE_INCLUDE_EMPTY

#define GIN_SEARCH_MODE_INCLUDE_EMPTY   1

Definition at line 37 of file gin.h.

GIN_TRICONSISTENT_PROC

#define GIN_TRICONSISTENT_PROC   6

Definition at line 29 of file gin.h.

GIN_TRUE

#define GIN_TRUE   1 /* item is present / matches */

Definition at line 77 of file gin.h.

GINNProcs

#define GINNProcs   7

Definition at line 31 of file gin.h.

PG_RETURN_GIN_TERNARY_VALUE

#define PG_RETURN_GIN_TERNARY_VALUE

(

x

)

return GinTernaryValueGetDatum(x)

Definition at line 92 of file gin.h.

PROGRESS_GIN_PHASE_INDEXBUILD_TABLESCAN

#define PROGRESS_GIN_PHASE_INDEXBUILD_TABLESCAN   2

Definition at line 46 of file gin.h.

PROGRESS_GIN_PHASE_MERGE_1

#define PROGRESS_GIN_PHASE_MERGE_1   4

Definition at line 48 of file gin.h.

PROGRESS_GIN_PHASE_MERGE_2

#define PROGRESS_GIN_PHASE_MERGE_2   6

Definition at line 50 of file gin.h.

PROGRESS_GIN_PHASE_PERFORMSORT_1

#define PROGRESS_GIN_PHASE_PERFORMSORT_1   3

Definition at line 47 of file gin.h.

PROGRESS_GIN_PHASE_PERFORMSORT_2

#define PROGRESS_GIN_PHASE_PERFORMSORT_2   5

Definition at line 49 of file gin.h.

Typedef Documentation

GinStatsData

typedef struct GinStatsData GinStatsData

GinTernaryValue

typedef char GinTernaryValue

Definition at line 71 of file gin.h.

Function Documentation

_gin_parallel_build_main()

void _gin_parallel_build_main ( dsm_segment *  seg, shm_toc *  toc  )

extern

Definition at line 2101 of file gininsert.c.

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

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

DatumGetGinTernaryValue()

static GinTernaryValue DatumGetGinTernaryValue ( Datum  X )

inlinestatic

Definition at line 81 of file gin.h.

{
    return (GinTernaryValue) X;

References fb().

Referenced by directTriConsistentFn(), and shimBoolConsistentFn().

ginGetStats()

void ginGetStats ( Relation  index, GinStatsData *  stats  )

extern

Definition at line 591 of file ginutil.c.

{
    Buffer      metabuffer;
    Page        metapage;
    GinMetaPageData *metadata;
 
    metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
    LockBuffer(metabuffer, GIN_SHARE);
    metapage = BufferGetPage(metabuffer);
    metadata = GinPageGetMeta(metapage);
 
    stats->nPendingPages = metadata->nPendingPages;
    stats->nTotalPages = metadata->nTotalPages;
    stats->nEntryPages = metadata->nEntryPages;
    stats->nDataPages = metadata->nDataPages;
    stats->nEntries = metadata->nEntries;
    stats->ginVersion = metadata->ginVersion;
 
    UnlockReleaseBuffer(metabuffer);
}

References BufferGetPage(), fb(), GIN_METAPAGE_BLKNO, GIN_SHARE, GinPageGetMeta, GinStatsData::ginVersion, GinMetaPageData::ginVersion, LockBuffer(), GinStatsData::nDataPages, GinMetaPageData::nDataPages, GinStatsData::nEntries, GinMetaPageData::nEntries, GinStatsData::nEntryPages, GinMetaPageData::nEntryPages, GinStatsData::nPendingPages, GinMetaPageData::nPendingPages, GinStatsData::nTotalPages, GinMetaPageData::nTotalPages, ReadBuffer(), and UnlockReleaseBuffer().

Referenced by gincostestimate(), and ginNewScanKey().

GinTernaryValueGetDatum()

static Datum GinTernaryValueGetDatum ( GinTernaryValue  X )

inlinestatic

Definition at line 87 of file gin.h.

{
    return (Datum) X;

References fb().

ginUpdateStats()

void ginUpdateStats ( Relation  index, const GinStatsData *  stats, bool  is_build  )

extern

Definition at line 618 of file ginutil.c.

{
    Buffer      metabuffer;
    Page        metapage;
    GinMetaPageData *metadata;
 
    metabuffer = ReadBuffer(index, GIN_METAPAGE_BLKNO);
    LockBuffer(metabuffer, GIN_EXCLUSIVE);
    metapage = BufferGetPage(metabuffer);
    metadata = GinPageGetMeta(metapage);
 
    START_CRIT_SECTION();
 
    metadata->nTotalPages = stats->nTotalPages;
    metadata->nEntryPages = stats->nEntryPages;
    metadata->nDataPages = stats->nDataPages;
    metadata->nEntries = stats->nEntries;
 
    /*
     * 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;
 
    MarkBufferDirty(metabuffer);
 
    if (RelationNeedsWAL(index) && !is_build)
    {
        XLogRecPtr  recptr;
        ginxlogUpdateMeta data;
 
        data.locator = index->rd_locator;
        data.ntuples = 0;
        data.newRightlink = data.prevTail = InvalidBlockNumber;
        memcpy(&data.metadata, metadata, sizeof(GinMetaPageData));
 
        XLogBeginInsert();
        XLogRegisterData(&data, sizeof(ginxlogUpdateMeta));
        XLogRegisterBuffer(0, metabuffer, REGBUF_WILL_INIT | REGBUF_STANDARD);
 
        recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_UPDATE_META_PAGE);
        PageSetLSN(metapage, recptr);
    }
 
    UnlockReleaseBuffer(metabuffer);
 
    END_CRIT_SECTION();
}

References BufferGetPage(), data, END_CRIT_SECTION, fb(), GIN_EXCLUSIVE, GIN_METAPAGE_BLKNO, GinPageGetMeta, InvalidBlockNumber, ginxlogUpdateMeta::locator, LockBuffer(), MarkBufferDirty(), GinStatsData::nDataPages, GinMetaPageData::nDataPages, GinStatsData::nEntries, GinMetaPageData::nEntries, GinStatsData::nEntryPages, GinMetaPageData::nEntryPages, GinStatsData::nTotalPages, GinMetaPageData::nTotalPages, PageSetLSN(), ReadBuffer(), REGBUF_STANDARD, REGBUF_WILL_INIT, RelationNeedsWAL, START_CRIT_SECTION, UnlockReleaseBuffer(), XLOG_GIN_UPDATE_META_PAGE, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by ginbuild(), and ginvacuumcleanup().

StaticAssertDecl()

StaticAssertDecl	(	sizeof(GinTernaryValue)	= =sizeof(bool),
		"sizes of GinTernaryValue and bool are not equal"
	)

Variable Documentation

gin_pending_list_limit

PGDLLIMPORT int gin_pending_list_limit

extern

Definition at line 39 of file ginfast.c.

GinFuzzySearchLimit

PGDLLIMPORT int GinFuzzySearchLimit

extern

Definition at line 27 of file ginget.c.

Referenced by startScan().