brin_internal.h File Reference

#include "access/amapi.h"
#include "storage/bufpage.h"
#include "utils/typcache.h"

Include dependency graph for brin_internal.h:

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

Go to the source code of this file.

Data Structures
struct	BrinOpcInfo
struct	BrinDesc

Macros
#define	SizeofBrinOpcInfo(ncols)    (offsetof(BrinOpcInfo, oi_typcache) + sizeof(TypeCacheEntry *) * ncols)
#define	BRIN_PROCNUM_OPCINFO   1
#define	BRIN_PROCNUM_ADDVALUE   2
#define	BRIN_PROCNUM_CONSISTENT   3
#define	BRIN_PROCNUM_UNION   4
#define	BRIN_MANDATORY_NPROCS   4
#define	BRIN_PROCNUM_OPTIONS   5 /* optional */
#define	BRIN_FIRST_OPTIONAL_PROCNUM   11
#define	BRIN_LAST_OPTIONAL_PROCNUM   15
#define	BRIN_elog(args)   ((void) 0)

Typedefs
typedef struct BrinOpcInfo	BrinOpcInfo
typedef struct BrinDesc	BrinDesc

Functions
BrinDesc *	brin_build_desc (Relation rel)
void	brin_free_desc (BrinDesc *bdesc)
IndexBuildResult *	brinbuild (Relation heap, Relation index, IndexInfo *indexInfo)
void	brinbuildempty (Relation index)
bool	brininsert (Relation idxRel, Datum *values, bool *nulls, ItemPointer heaptid, Relation heapRel, IndexUniqueCheck checkUnique, bool indexUnchanged, IndexInfo *indexInfo)
void	brininsertcleanup (Relation index, IndexInfo *indexInfo)
IndexScanDesc	brinbeginscan (Relation r, int nkeys, int norderbys)
int64	bringetbitmap (IndexScanDesc scan, TIDBitmap *tbm)
void	brinrescan (IndexScanDesc scan, ScanKey scankey, int nscankeys, ScanKey orderbys, int norderbys)
void	brinendscan (IndexScanDesc scan)
IndexBulkDeleteResult *	brinbulkdelete (IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
IndexBulkDeleteResult *	brinvacuumcleanup (IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
bytea *	brinoptions (Datum reloptions, bool validate)
bool	brinvalidate (Oid opclassoid)

Macro Definition Documentation

BRIN_elog

#define BRIN_elog

(

args

)

((void) 0)

Definition at line 85 of file brin_internal.h.

BRIN_FIRST_OPTIONAL_PROCNUM

#define BRIN_FIRST_OPTIONAL_PROCNUM   11

Definition at line 77 of file brin_internal.h.

BRIN_LAST_OPTIONAL_PROCNUM

#define BRIN_LAST_OPTIONAL_PROCNUM   15

Definition at line 78 of file brin_internal.h.

BRIN_MANDATORY_NPROCS

#define BRIN_MANDATORY_NPROCS   4

Definition at line 74 of file brin_internal.h.

BRIN_PROCNUM_ADDVALUE

#define BRIN_PROCNUM_ADDVALUE   2

Definition at line 71 of file brin_internal.h.

BRIN_PROCNUM_CONSISTENT

#define BRIN_PROCNUM_CONSISTENT   3

Definition at line 72 of file brin_internal.h.

BRIN_PROCNUM_OPCINFO

#define BRIN_PROCNUM_OPCINFO   1

Definition at line 70 of file brin_internal.h.

BRIN_PROCNUM_OPTIONS

#define BRIN_PROCNUM_OPTIONS   5 /* optional */

Definition at line 75 of file brin_internal.h.

BRIN_PROCNUM_UNION

#define BRIN_PROCNUM_UNION   4

Definition at line 73 of file brin_internal.h.

SizeofBrinOpcInfo

#define SizeofBrinOpcInfo

(

ncols

)

(offsetof(BrinOpcInfo, oi_typcache) + sizeof(TypeCacheEntry *) * ncols)

Definition at line 41 of file brin_internal.h.

Typedef Documentation

BrinDesc

typedef struct BrinDesc BrinDesc

BrinOpcInfo

typedef struct BrinOpcInfo BrinOpcInfo

Function Documentation

brin_build_desc()

BrinDesc * brin_build_desc

(

Relation

rel

)

Definition at line 1582 of file brin.c.

{
    BrinOpcInfo **opcinfo;
    BrinDesc   *bdesc;
    TupleDesc   tupdesc;
    int         totalstored = 0;
    int         keyno;
    long        totalsize;
    MemoryContext cxt;
    MemoryContext oldcxt;
 
    cxt = AllocSetContextCreate(CurrentMemoryContext,
                                "brin desc cxt",
                                ALLOCSET_SMALL_SIZES);
    oldcxt = MemoryContextSwitchTo(cxt);
    tupdesc = RelationGetDescr(rel);
 
    /*
     * Obtain BrinOpcInfo for each indexed column.  While at it, accumulate
     * the number of columns stored, since the number is opclass-defined.
     */
    opcinfo = palloc_array(BrinOpcInfo *, tupdesc->natts);
    for (keyno = 0; keyno < tupdesc->natts; keyno++)
    {
        FmgrInfo   *opcInfoFn;
        Form_pg_attribute attr = TupleDescAttr(tupdesc, keyno);
 
        opcInfoFn = index_getprocinfo(rel, keyno + 1, BRIN_PROCNUM_OPCINFO);
 
        opcinfo[keyno] = (BrinOpcInfo *)
            DatumGetPointer(FunctionCall1(opcInfoFn, ObjectIdGetDatum(attr->atttypid)));
        totalstored += opcinfo[keyno]->oi_nstored;
    }
 
    /* Allocate our result struct and fill it in */
    totalsize = offsetof(BrinDesc, bd_info) +
        sizeof(BrinOpcInfo *) * tupdesc->natts;
 
    bdesc = palloc(totalsize);
    bdesc->bd_context = cxt;
    bdesc->bd_index = rel;
    bdesc->bd_tupdesc = tupdesc;
    bdesc->bd_disktdesc = NULL; /* generated lazily */
    bdesc->bd_totalstored = totalstored;
 
    for (keyno = 0; keyno < tupdesc->natts; keyno++)
        bdesc->bd_info[keyno] = opcinfo[keyno];
    pfree(opcinfo);
 
    MemoryContextSwitchTo(oldcxt);
 
    return bdesc;
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, BrinDesc::bd_context, BrinDesc::bd_disktdesc, BrinDesc::bd_index, BrinDesc::bd_info, BrinDesc::bd_totalstored, BrinDesc::bd_tupdesc, BRIN_PROCNUM_OPCINFO, CurrentMemoryContext, DatumGetPointer(), FunctionCall1, index_getprocinfo(), MemoryContextSwitchTo(), TupleDescData::natts, ObjectIdGetDatum(), BrinOpcInfo::oi_nstored, palloc(), palloc_array, pfree(), RelationGetDescr, and TupleDescAttr().

Referenced by brin_page_items(), brinbeginscan(), initialize_brin_buildstate(), and initialize_brin_insertstate().

brin_free_desc()

void brin_free_desc

(

BrinDesc *

bdesc

)

Definition at line 1637 of file brin.c.

{
    /* make sure the tupdesc is still valid */
    Assert(bdesc->bd_tupdesc->tdrefcount >= 1);
    /* no need for retail pfree */
    MemoryContextDelete(bdesc->bd_context);
}

References Assert(), BrinDesc::bd_context, BrinDesc::bd_tupdesc, MemoryContextDelete(), and TupleDescData::tdrefcount.

Referenced by brin_page_items(), brinendscan(), and terminate_brin_buildstate().

brinbeginscan()

IndexScanDesc brinbeginscan	(	Relation	r,
		int	nkeys,
		int	norderbys
	)

Definition at line 540 of file brin.c.

{
    IndexScanDesc scan;
    BrinOpaque *opaque;
 
    scan = RelationGetIndexScan(r, nkeys, norderbys);
 
    opaque = palloc_object(BrinOpaque);
    opaque->bo_rmAccess = brinRevmapInitialize(r, &opaque->bo_pagesPerRange);
    opaque->bo_bdesc = brin_build_desc(r);
    scan->opaque = opaque;
 
    return scan;
}

References BrinOpaque::bo_bdesc, BrinOpaque::bo_pagesPerRange, BrinOpaque::bo_rmAccess, brin_build_desc(), brinRevmapInitialize(), IndexScanDescData::opaque, palloc_object, and RelationGetIndexScan().

Referenced by brinhandler().

brinbuild()

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

Definition at line 1106 of file brin.c.

{
    IndexBuildResult *result;
    double      reltuples;
    double      idxtuples;
    BrinRevmap *revmap;
    BrinBuildState *state;
    Buffer      meta;
    BlockNumber pagesPerRange;
 
    /*
     * We expect to be called exactly once for any index relation.
     */
    if (RelationGetNumberOfBlocks(index) != 0)
        elog(ERROR, "index \"%s\" already contains data",
             RelationGetRelationName(index));
 
    /*
     * Critical section not required, because on error the creation of the
     * whole relation will be rolled back.
     */
 
    meta = ExtendBufferedRel(BMR_REL(index), MAIN_FORKNUM, NULL,
                             EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK);
    Assert(BufferGetBlockNumber(meta) == BRIN_METAPAGE_BLKNO);
 
    brin_metapage_init(BufferGetPage(meta), BrinGetPagesPerRange(index),
                       BRIN_CURRENT_VERSION);
    MarkBufferDirty(meta);
 
    if (RelationNeedsWAL(index))
    {
        xl_brin_createidx xlrec;
        XLogRecPtr  recptr;
        Page        page;
 
        xlrec.version = BRIN_CURRENT_VERSION;
        xlrec.pagesPerRange = BrinGetPagesPerRange(index);
 
        XLogBeginInsert();
        XLogRegisterData(&xlrec, SizeOfBrinCreateIdx);
        XLogRegisterBuffer(0, meta, REGBUF_WILL_INIT | REGBUF_STANDARD);
 
        recptr = XLogInsert(RM_BRIN_ID, XLOG_BRIN_CREATE_INDEX);
 
        page = BufferGetPage(meta);
        PageSetLSN(page, recptr);
    }
 
    UnlockReleaseBuffer(meta);
 
    /*
     * Initialize our state, including the deformed tuple state.
     */
    revmap = brinRevmapInitialize(index, &pagesPerRange);
    state = initialize_brin_buildstate(index, revmap, pagesPerRange,
                                       RelationGetNumberOfBlocks(heap));
 
    /*
     * 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. That makes sense
     * for btree, but not for BRIN, which can do with much less memory. So
     * maybe make that somehow less strict, optionally?
     */
    if (indexInfo->ii_ParallelWorkers > 0)
        _brin_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_brin(maintenance_work_mem, coordinate,
                                       TUPLESORT_NONE);
 
        /* scan the relation and merge per-worker results */
        reltuples = _brin_parallel_merge(state);
 
        _brin_end_parallel(state->bs_leader, state);
    }
    else                        /* no parallel index build */
    {
        /*
         * Now scan the relation.  No syncscan allowed here because we want
         * the heap blocks in physical order (we want to produce the ranges
         * starting from block 0, and the callback also relies on this to not
         * generate summary for the same range twice).
         */
        reltuples = table_index_build_scan(heap, index, indexInfo, false, true,
                                           brinbuildCallback, state, NULL);
 
        /*
         * process the final batch
         *
         * XXX Note this does not update state->bs_currRangeStart, i.e. it
         * stays set to the last range added to the index. This is OK, because
         * that's what brin_fill_empty_ranges expects.
         */
        form_and_insert_tuple(state);
 
        /*
         * Backfill the final ranges with empty data.
         *
         * This saves us from doing what amounts to full table scans when the
         * index with a predicate like WHERE (nonnull_column IS NULL), or
         * other very selective predicates.
         */
        brin_fill_empty_ranges(state,
                               state->bs_currRangeStart,
                               state->bs_maxRangeStart);
    }
 
    /* release resources */
    idxtuples = state->bs_numtuples;
    brinRevmapTerminate(state->bs_rmAccess);
    terminate_brin_buildstate(state);
 
    /*
     * Return statistics
     */
    result = palloc_object(IndexBuildResult);
 
    result->heap_tuples = reltuples;
    result->index_tuples = idxtuples;
 
    return result;
}

References _brin_begin_parallel(), _brin_end_parallel(), _brin_parallel_merge(), Assert(), BMR_REL, BRIN_CURRENT_VERSION, brin_fill_empty_ranges(), BRIN_METAPAGE_BLKNO, brin_metapage_init(), brinbuildCallback(), BrinGetPagesPerRange, brinRevmapInitialize(), brinRevmapTerminate(), BufferGetBlockNumber(), BufferGetPage(), EB_LOCK_FIRST, EB_SKIP_EXTENSION_LOCK, elog, ERROR, ExtendBufferedRel(), form_and_insert_tuple(), IndexBuildResult::heap_tuples, IndexInfo::ii_Concurrent, IndexInfo::ii_ParallelWorkers, IndexBuildResult::index_tuples, initialize_brin_buildstate(), SortCoordinateData::isWorker, MAIN_FORKNUM, maintenance_work_mem, MarkBufferDirty(), SortCoordinateData::nParticipants, PageSetLSN(), xl_brin_createidx::pagesPerRange, palloc0_object, palloc_object, REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetNumberOfBlocks, RelationGetRelationName, RelationNeedsWAL, SortCoordinateData::sharedsort, SizeOfBrinCreateIdx, table_index_build_scan(), terminate_brin_buildstate(), tuplesort_begin_index_brin(), TUPLESORT_NONE, UnlockReleaseBuffer(), xl_brin_createidx::version, XLOG_BRIN_CREATE_INDEX, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by brinhandler().

brinbuildempty()

void brinbuildempty

(

Relation

index

)

Definition at line 1275 of file brin.c.

{
    Buffer      metabuf;
 
    /* An empty BRIN index has a metapage only. */
    metabuf = ExtendBufferedRel(BMR_REL(index), INIT_FORKNUM, NULL,
                                EB_LOCK_FIRST | EB_SKIP_EXTENSION_LOCK);
 
    /* Initialize and xlog metabuffer. */
    START_CRIT_SECTION();
    brin_metapage_init(BufferGetPage(metabuf), BrinGetPagesPerRange(index),
                       BRIN_CURRENT_VERSION);
    MarkBufferDirty(metabuf);
    log_newpage_buffer(metabuf, true);
    END_CRIT_SECTION();
 
    UnlockReleaseBuffer(metabuf);
}

References BMR_REL, BRIN_CURRENT_VERSION, brin_metapage_init(), BrinGetPagesPerRange, BufferGetPage(), EB_LOCK_FIRST, EB_SKIP_EXTENSION_LOCK, END_CRIT_SECTION, ExtendBufferedRel(), INIT_FORKNUM, log_newpage_buffer(), MarkBufferDirty(), START_CRIT_SECTION, and UnlockReleaseBuffer().

Referenced by brinhandler().

brinbulkdelete()

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

Definition at line 1304 of file brin.c.

{
    /* allocate stats if first time through, else re-use existing struct */
    if (stats == NULL)
        stats = palloc0_object(IndexBulkDeleteResult);
 
    return stats;
}

References palloc0_object.

Referenced by brinhandler().

brinendscan()

void brinendscan

(

IndexScanDesc

scan

)

Definition at line 979 of file brin.c.

{
    BrinOpaque *opaque = (BrinOpaque *) scan->opaque;
 
    brinRevmapTerminate(opaque->bo_rmAccess);
    brin_free_desc(opaque->bo_bdesc);
    pfree(opaque);
}

References BrinOpaque::bo_bdesc, BrinOpaque::bo_rmAccess, brin_free_desc(), brinRevmapTerminate(), IndexScanDescData::opaque, and pfree().

Referenced by brinhandler().

bringetbitmap()

int64 bringetbitmap	(	IndexScanDesc	scan,
		TIDBitmap *	tbm
	)

Definition at line 568 of file brin.c.

{
    Relation    idxRel = scan->indexRelation;
    Buffer      buf = InvalidBuffer;
    BrinDesc   *bdesc;
    Oid         heapOid;
    Relation    heapRel;
    BrinOpaque *opaque;
    BlockNumber nblocks;
    int64       totalpages = 0;
    FmgrInfo   *consistentFn;
    MemoryContext oldcxt;
    MemoryContext perRangeCxt;
    BrinMemTuple *dtup;
    BrinTuple  *btup = NULL;
    Size        btupsz = 0;
    ScanKey   **keys,
              **nullkeys;
    int        *nkeys,
               *nnullkeys;
    char       *ptr;
    Size        len;
    char       *tmp PG_USED_FOR_ASSERTS_ONLY;
 
    opaque = (BrinOpaque *) scan->opaque;
    bdesc = opaque->bo_bdesc;
    pgstat_count_index_scan(idxRel);
    if (scan->instrument)
        scan->instrument->nsearches++;
 
    /*
     * We need to know the size of the table so that we know how long to
     * iterate on the revmap.
     */
    heapOid = IndexGetRelation(RelationGetRelid(idxRel), false);
    heapRel = table_open(heapOid, AccessShareLock);
    nblocks = RelationGetNumberOfBlocks(heapRel);
    table_close(heapRel, AccessShareLock);
 
    /*
     * Make room for the consistent support procedures of indexed columns.  We
     * don't look them up here; we do that lazily the first time we see a scan
     * key reference each of them.  We rely on zeroing fn_oid to InvalidOid.
     */
    consistentFn = palloc0_array(FmgrInfo, bdesc->bd_tupdesc->natts);
 
    /*
     * Make room for per-attribute lists of scan keys that we'll pass to the
     * consistent support procedure. We don't know which attributes have scan
     * keys, so we allocate space for all attributes. That may use more memory
     * but it's probably cheaper than determining which attributes are used.
     *
     * We keep null and regular keys separate, so that we can pass just the
     * regular keys to the consistent function easily.
     *
     * To reduce the allocation overhead, we allocate one big chunk and then
     * carve it into smaller arrays ourselves. All the pieces have exactly the
     * same lifetime, so that's OK.
     *
     * XXX The widest index can have 32 attributes, so the amount of wasted
     * memory is negligible. We could invent a more compact approach (with
     * just space for used attributes) but that would make the matching more
     * complex so it's not a good trade-off.
     */
    len =
        MAXALIGN(sizeof(ScanKey *) * bdesc->bd_tupdesc->natts) +    /* regular keys */
        MAXALIGN(sizeof(ScanKey) * scan->numberOfKeys) * bdesc->bd_tupdesc->natts +
        MAXALIGN(sizeof(int) * bdesc->bd_tupdesc->natts) +
        MAXALIGN(sizeof(ScanKey *) * bdesc->bd_tupdesc->natts) +    /* NULL keys */
        MAXALIGN(sizeof(ScanKey) * scan->numberOfKeys) * bdesc->bd_tupdesc->natts +
        MAXALIGN(sizeof(int) * bdesc->bd_tupdesc->natts);
 
    ptr = palloc(len);
    tmp = ptr;
 
    keys = (ScanKey **) ptr;
    ptr += MAXALIGN(sizeof(ScanKey *) * bdesc->bd_tupdesc->natts);
 
    nullkeys = (ScanKey **) ptr;
    ptr += MAXALIGN(sizeof(ScanKey *) * bdesc->bd_tupdesc->natts);
 
    nkeys = (int *) ptr;
    ptr += MAXALIGN(sizeof(int) * bdesc->bd_tupdesc->natts);
 
    nnullkeys = (int *) ptr;
    ptr += MAXALIGN(sizeof(int) * bdesc->bd_tupdesc->natts);
 
    for (int i = 0; i < bdesc->bd_tupdesc->natts; i++)
    {
        keys[i] = (ScanKey *) ptr;
        ptr += MAXALIGN(sizeof(ScanKey) * scan->numberOfKeys);
 
        nullkeys[i] = (ScanKey *) ptr;
        ptr += MAXALIGN(sizeof(ScanKey) * scan->numberOfKeys);
    }
 
    Assert(tmp + len == ptr);
 
    /* zero the number of keys */
    memset(nkeys, 0, sizeof(int) * bdesc->bd_tupdesc->natts);
    memset(nnullkeys, 0, sizeof(int) * bdesc->bd_tupdesc->natts);
 
    /* Preprocess the scan keys - split them into per-attribute arrays. */
    for (int keyno = 0; keyno < scan->numberOfKeys; keyno++)
    {
        ScanKey     key = &scan->keyData[keyno];
        AttrNumber  keyattno = key->sk_attno;
 
        /*
         * The collation of the scan key must match the collation used in the
         * index column (but only if the search is not IS NULL/ IS NOT NULL).
         * Otherwise we shouldn't be using this index ...
         */
        Assert((key->sk_flags & SK_ISNULL) ||
               (key->sk_collation ==
                TupleDescAttr(bdesc->bd_tupdesc,
                              keyattno - 1)->attcollation));
 
        /*
         * First time we see this index attribute, so init as needed.
         *
         * This is a bit of an overkill - we don't know how many scan keys are
         * there for this attribute, so we simply allocate the largest number
         * possible (as if all keys were for this attribute). This may waste a
         * bit of memory, but we only expect small number of scan keys in
         * general, so this should be negligible, and repeated repalloc calls
         * are not free either.
         */
        if (consistentFn[keyattno - 1].fn_oid == InvalidOid)
        {
            FmgrInfo   *tmp;
 
            /* First time we see this attribute, so no key/null keys. */
            Assert(nkeys[keyattno - 1] == 0);
            Assert(nnullkeys[keyattno - 1] == 0);
 
            tmp = index_getprocinfo(idxRel, keyattno,
                                    BRIN_PROCNUM_CONSISTENT);
            fmgr_info_copy(&consistentFn[keyattno - 1], tmp,
                           CurrentMemoryContext);
        }
 
        /* Add key to the proper per-attribute array. */
        if (key->sk_flags & SK_ISNULL)
        {
            nullkeys[keyattno - 1][nnullkeys[keyattno - 1]] = key;
            nnullkeys[keyattno - 1]++;
        }
        else
        {
            keys[keyattno - 1][nkeys[keyattno - 1]] = key;
            nkeys[keyattno - 1]++;
        }
    }
 
    /* allocate an initial in-memory tuple, out of the per-range memcxt */
    dtup = brin_new_memtuple(bdesc);
 
    /*
     * Setup and use a per-range memory context, which is reset every time we
     * loop below.  This avoids having to free the tuples within the loop.
     */
    perRangeCxt = AllocSetContextCreate(CurrentMemoryContext,
                                        "bringetbitmap cxt",
                                        ALLOCSET_DEFAULT_SIZES);
    oldcxt = MemoryContextSwitchTo(perRangeCxt);
 
    /*
     * Now scan the revmap.  We start by querying for heap page 0,
     * incrementing by the number of pages per range; this gives us a full
     * view of the table.  We make use of uint64 for heapBlk as a BlockNumber
     * could wrap for tables with close to 2^32 pages.
     */
    for (uint64 heapBlk = 0; heapBlk < nblocks; heapBlk += opaque->bo_pagesPerRange)
    {
        bool        addrange;
        bool        gottuple = false;
        BrinTuple  *tup;
        OffsetNumber off;
        Size        size;
 
        CHECK_FOR_INTERRUPTS();
 
        MemoryContextReset(perRangeCxt);
 
        tup = brinGetTupleForHeapBlock(opaque->bo_rmAccess, (BlockNumber) heapBlk, &buf,
                                       &off, &size, BUFFER_LOCK_SHARE);
        if (tup)
        {
            gottuple = true;
            btup = brin_copy_tuple(tup, size, btup, &btupsz);
            LockBuffer(buf, BUFFER_LOCK_UNLOCK);
        }
 
        /*
         * For page ranges with no indexed tuple, we must return the whole
         * range; otherwise, compare it to the scan keys.
         */
        if (!gottuple)
        {
            addrange = true;
        }
        else
        {
            dtup = brin_deform_tuple(bdesc, btup, dtup);
            if (dtup->bt_placeholder)
            {
                /*
                 * Placeholder tuples are always returned, regardless of the
                 * values stored in them.
                 */
                addrange = true;
            }
            else
            {
                int         attno;
 
                /*
                 * Compare scan keys with summary values stored for the range.
                 * If scan keys are matched, the page range must be added to
                 * the bitmap.  We initially assume the range needs to be
                 * added; in particular this serves the case where there are
                 * no keys.
                 */
                addrange = true;
                for (attno = 1; attno <= bdesc->bd_tupdesc->natts; attno++)
                {
                    BrinValues *bval;
                    Datum       add;
                    Oid         collation;
 
                    /*
                     * skip attributes without any scan keys (both regular and
                     * IS [NOT] NULL)
                     */
                    if (nkeys[attno - 1] == 0 && nnullkeys[attno - 1] == 0)
                        continue;
 
                    bval = &dtup->bt_columns[attno - 1];
 
                    /*
                     * If the BRIN tuple indicates that this range is empty,
                     * we can skip it: there's nothing to match.  We don't
                     * need to examine the next columns.
                     */
                    if (dtup->bt_empty_range)
                    {
                        addrange = false;
                        break;
                    }
 
                    /*
                     * First check if there are any IS [NOT] NULL scan keys,
                     * and if we're violating them. In that case we can
                     * terminate early, without invoking the support function.
                     *
                     * As there may be more keys, we can only determine
                     * mismatch within this loop.
                     */
                    if (bdesc->bd_info[attno - 1]->oi_regular_nulls &&
                        !check_null_keys(bval, nullkeys[attno - 1],
                                         nnullkeys[attno - 1]))
                    {
                        /*
                         * If any of the IS [NOT] NULL keys failed, the page
                         * range as a whole can't pass. So terminate the loop.
                         */
                        addrange = false;
                        break;
                    }
 
                    /*
                     * So either there are no IS [NOT] NULL keys, or all
                     * passed. If there are no regular scan keys, we're done -
                     * the page range matches. If there are regular keys, but
                     * the page range is marked as 'all nulls' it can't
                     * possibly pass (we're assuming the operators are
                     * strict).
                     */
 
                    /* No regular scan keys - page range as a whole passes. */
                    if (!nkeys[attno - 1])
                        continue;
 
                    Assert((nkeys[attno - 1] > 0) &&
                           (nkeys[attno - 1] <= scan->numberOfKeys));
 
                    /* If it is all nulls, it cannot possibly be consistent. */
                    if (bval->bv_allnulls)
                    {
                        addrange = false;
                        break;
                    }
 
                    /*
                     * Collation from the first key (has to be the same for
                     * all keys for the same attribute).
                     */
                    collation = keys[attno - 1][0]->sk_collation;
 
                    /*
                     * Check whether the scan key is consistent with the page
                     * range values; if so, have the pages in the range added
                     * to the output bitmap.
                     *
                     * The opclass may or may not support processing of
                     * multiple scan keys. We can determine that based on the
                     * number of arguments - functions with extra parameter
                     * (number of scan keys) do support this, otherwise we
                     * have to simply pass the scan keys one by one.
                     */
                    if (consistentFn[attno - 1].fn_nargs >= 4)
                    {
                        /* Check all keys at once */
                        add = FunctionCall4Coll(&consistentFn[attno - 1],
                                                collation,
                                                PointerGetDatum(bdesc),
                                                PointerGetDatum(bval),
                                                PointerGetDatum(keys[attno - 1]),
                                                Int32GetDatum(nkeys[attno - 1]));
                        addrange = DatumGetBool(add);
                    }
                    else
                    {
                        /*
                         * Check keys one by one
                         *
                         * When there are multiple scan keys, failure to meet
                         * the criteria for a single one of them is enough to
                         * discard the range as a whole, so break out of the
                         * loop as soon as a false return value is obtained.
                         */
                        int         keyno;
 
                        for (keyno = 0; keyno < nkeys[attno - 1]; keyno++)
                        {
                            add = FunctionCall3Coll(&consistentFn[attno - 1],
                                                    keys[attno - 1][keyno]->sk_collation,
                                                    PointerGetDatum(bdesc),
                                                    PointerGetDatum(bval),
                                                    PointerGetDatum(keys[attno - 1][keyno]));
                            addrange = DatumGetBool(add);
                            if (!addrange)
                                break;
                        }
                    }
 
                    /*
                     * If we found a scan key eliminating the range, no need
                     * to check additional ones.
                     */
                    if (!addrange)
                        break;
                }
            }
        }
 
        /* add the pages in the range to the output bitmap, if needed */
        if (addrange)
        {
            uint64      pageno;
 
            for (pageno = heapBlk;
                 pageno <= Min(nblocks, heapBlk + opaque->bo_pagesPerRange) - 1;
                 pageno++)
            {
                MemoryContextSwitchTo(oldcxt);
                tbm_add_page(tbm, pageno);
                totalpages++;
                MemoryContextSwitchTo(perRangeCxt);
            }
        }
    }
 
    MemoryContextSwitchTo(oldcxt);
    MemoryContextDelete(perRangeCxt);
 
    if (buf != InvalidBuffer)
        ReleaseBuffer(buf);
 
    /*
     * XXX We have an approximation of the number of *pages* that our scan
     * returns, but we don't have a precise idea of the number of heap tuples
     * involved.
     */
    return totalpages * 10;
}

References AccessShareLock, addrange(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), BrinDesc::bd_info, BrinDesc::bd_tupdesc, BrinOpaque::bo_bdesc, BrinOpaque::bo_pagesPerRange, BrinOpaque::bo_rmAccess, brin_copy_tuple(), brin_deform_tuple(), brin_new_memtuple(), BRIN_PROCNUM_CONSISTENT, brinGetTupleForHeapBlock(), BrinMemTuple::bt_columns, BrinMemTuple::bt_empty_range, BrinMemTuple::bt_placeholder, buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BrinValues::bv_allnulls, CHECK_FOR_INTERRUPTS, check_null_keys(), CurrentMemoryContext, DatumGetBool(), fmgr_info_copy(), FunctionCall3Coll(), FunctionCall4Coll(), i, index_getprocinfo(), IndexGetRelation(), IndexScanDescData::indexRelation, IndexScanDescData::instrument, Int32GetDatum(), InvalidBuffer, InvalidOid, sort-test::key, IndexScanDescData::keyData, len, LockBuffer(), MAXALIGN, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), Min, TupleDescData::natts, IndexScanInstrumentation::nsearches, IndexScanDescData::numberOfKeys, BrinOpcInfo::oi_regular_nulls, IndexScanDescData::opaque, palloc(), palloc0_array, PG_USED_FOR_ASSERTS_ONLY, pgstat_count_index_scan, PointerGetDatum(), RelationGetNumberOfBlocks, RelationGetRelid, ReleaseBuffer(), ScanKeyData::sk_collation, SK_ISNULL, table_close(), table_open(), tbm_add_page(), and TupleDescAttr().

Referenced by brinhandler().

brininsert()

bool brininsert	(	Relation	idxRel,
		Datum *	values,
		bool *	nulls,
		ItemPointer	heaptid,
		Relation	heapRel,
		IndexUniqueCheck	checkUnique,
		bool	indexUnchanged,
		IndexInfo *	indexInfo
	)

Definition at line 345 of file brin.c.

{
    BlockNumber pagesPerRange;
    BlockNumber origHeapBlk;
    BlockNumber heapBlk;
    BrinInsertState *bistate = (BrinInsertState *) indexInfo->ii_AmCache;
    BrinRevmap *revmap;
    BrinDesc   *bdesc;
    Buffer      buf = InvalidBuffer;
    MemoryContext tupcxt = NULL;
    MemoryContext oldcxt = CurrentMemoryContext;
    bool        autosummarize = BrinGetAutoSummarize(idxRel);
 
    /*
     * If first time through in this statement, initialize the insert state
     * that we keep for all the inserts in the command.
     */
    if (!bistate)
        bistate = initialize_brin_insertstate(idxRel, indexInfo);
 
    revmap = bistate->bis_rmAccess;
    bdesc = bistate->bis_desc;
    pagesPerRange = bistate->bis_pages_per_range;
 
    /*
     * origHeapBlk is the block number where the insertion occurred.  heapBlk
     * is the first block in the corresponding page range.
     */
    origHeapBlk = ItemPointerGetBlockNumber(heaptid);
    heapBlk = (origHeapBlk / pagesPerRange) * pagesPerRange;
 
    for (;;)
    {
        bool        need_insert = false;
        OffsetNumber off;
        BrinTuple  *brtup;
        BrinMemTuple *dtup;
 
        CHECK_FOR_INTERRUPTS();
 
        /*
         * If auto-summarization is enabled and we just inserted the first
         * tuple into the first block of a new non-first page range, request a
         * summarization run of the previous range.
         */
        if (autosummarize &&
            heapBlk > 0 &&
            heapBlk == origHeapBlk &&
            ItemPointerGetOffsetNumber(heaptid) == FirstOffsetNumber)
        {
            BlockNumber lastPageRange = heapBlk - 1;
            BrinTuple  *lastPageTuple;
 
            lastPageTuple =
                brinGetTupleForHeapBlock(revmap, lastPageRange, &buf, &off,
                                         NULL, BUFFER_LOCK_SHARE);
            if (!lastPageTuple)
            {
                bool        recorded;
 
                recorded = AutoVacuumRequestWork(AVW_BRINSummarizeRange,
                                                 RelationGetRelid(idxRel),
                                                 lastPageRange);
                if (!recorded)
                    ereport(LOG,
                            (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                             errmsg("request for BRIN range summarization for index \"%s\" page %u was not recorded",
                                    RelationGetRelationName(idxRel),
                                    lastPageRange)));
            }
            else
                LockBuffer(buf, BUFFER_LOCK_UNLOCK);
        }
 
        brtup = brinGetTupleForHeapBlock(revmap, heapBlk, &buf, &off,
                                         NULL, BUFFER_LOCK_SHARE);
 
        /* if range is unsummarized, there's nothing to do */
        if (!brtup)
            break;
 
        /* First time through in this brininsert call? */
        if (tupcxt == NULL)
        {
            tupcxt = AllocSetContextCreate(CurrentMemoryContext,
                                           "brininsert cxt",
                                           ALLOCSET_DEFAULT_SIZES);
            MemoryContextSwitchTo(tupcxt);
        }
 
        dtup = brin_deform_tuple(bdesc, brtup, NULL);
 
        need_insert = add_values_to_range(idxRel, bdesc, dtup, values, nulls);
 
        if (!need_insert)
        {
            /*
             * The tuple is consistent with the new values, so there's nothing
             * to do.
             */
            LockBuffer(buf, BUFFER_LOCK_UNLOCK);
        }
        else
        {
            Page        page = BufferGetPage(buf);
            ItemId      lp = PageGetItemId(page, off);
            Size        origsz;
            BrinTuple  *origtup;
            Size        newsz;
            BrinTuple  *newtup;
            bool        samepage;
 
            /*
             * Make a copy of the old tuple, so that we can compare it after
             * re-acquiring the lock.
             */
            origsz = ItemIdGetLength(lp);
            origtup = brin_copy_tuple(brtup, origsz, NULL, NULL);
 
            /*
             * Before releasing the lock, check if we can attempt a same-page
             * update.  Another process could insert a tuple concurrently in
             * the same page though, so downstream we must be prepared to cope
             * if this turns out to not be possible after all.
             */
            newtup = brin_form_tuple(bdesc, heapBlk, dtup, &newsz);
            samepage = brin_can_do_samepage_update(buf, origsz, newsz);
            LockBuffer(buf, BUFFER_LOCK_UNLOCK);
 
            /*
             * Try to update the tuple.  If this doesn't work for whatever
             * reason, we need to restart from the top; the revmap might be
             * pointing at a different tuple for this block now, so we need to
             * recompute to ensure both our new heap tuple and the other
             * inserter's are covered by the combined tuple.  It might be that
             * we don't need to update at all.
             */
            if (!brin_doupdate(idxRel, pagesPerRange, revmap, heapBlk,
                               buf, off, origtup, origsz, newtup, newsz,
                               samepage))
            {
                /* no luck; start over */
                MemoryContextReset(tupcxt);
                continue;
            }
        }
 
        /* success! */
        break;
    }
 
    if (BufferIsValid(buf))
        ReleaseBuffer(buf);
    MemoryContextSwitchTo(oldcxt);
    if (tupcxt != NULL)
        MemoryContextDelete(tupcxt);
 
    return false;
}

References add_values_to_range(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AutoVacuumRequestWork(), AVW_BRINSummarizeRange, BrinInsertState::bis_desc, BrinInsertState::bis_pages_per_range, BrinInsertState::bis_rmAccess, brin_can_do_samepage_update(), brin_copy_tuple(), brin_deform_tuple(), brin_doupdate(), brin_form_tuple(), BrinGetAutoSummarize, brinGetTupleForHeapBlock(), buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage(), BufferIsValid(), CHECK_FOR_INTERRUPTS, CurrentMemoryContext, ereport, errcode(), errmsg(), FirstOffsetNumber, IndexInfo::ii_AmCache, initialize_brin_insertstate(), InvalidBuffer, ItemIdGetLength, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), LOG, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), PageGetItemId(), RelationGetRelationName, RelationGetRelid, ReleaseBuffer(), and values.

Referenced by brinhandler().

brininsertcleanup()

void brininsertcleanup	(	Relation	index,
		IndexInfo *	indexInfo
	)

Definition at line 513 of file brin.c.

{
    BrinInsertState *bistate = (BrinInsertState *) indexInfo->ii_AmCache;
 
    /* bail out if cache not initialized */
    if (bistate == NULL)
        return;
 
    /* do this first to avoid dangling pointer if we fail partway through */
    indexInfo->ii_AmCache = NULL;
 
    /*
     * Clean up the revmap. Note that the brinDesc has already been cleaned up
     * as part of its own memory context.
     */
    brinRevmapTerminate(bistate->bis_rmAccess);
    pfree(bistate);
}

References BrinInsertState::bis_rmAccess, brinRevmapTerminate(), if(), IndexInfo::ii_AmCache, and pfree().

Referenced by brinhandler().

brinoptions()

bytea * brinoptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 1349 of file brin.c.

{
    static const relopt_parse_elt tab[] = {
        {"pages_per_range", RELOPT_TYPE_INT, offsetof(BrinOptions, pagesPerRange)},
        {"autosummarize", RELOPT_TYPE_BOOL, offsetof(BrinOptions, autosummarize)}
    };
 
    return (bytea *) build_reloptions(reloptions, validate,
                                      RELOPT_KIND_BRIN,
                                      sizeof(BrinOptions),
                                      tab, lengthof(tab));
}

References build_reloptions(), lengthof, RELOPT_KIND_BRIN, RELOPT_TYPE_BOOL, RELOPT_TYPE_INT, and validate().

Referenced by brinhandler().

brinrescan()

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

Definition at line 960 of file brin.c.

{
    /*
     * Other index AMs preprocess the scan keys at this point, or sometime
     * early during the scan; this lets them optimize by removing redundant
     * keys, or doing early returns when they are impossible to satisfy; see
     * _bt_preprocess_keys for an example.  Something like that could be added
     * here someday, too.
     */
 
    if (scankey && scan->numberOfKeys > 0)
        memcpy(scan->keyData, scankey, scan->numberOfKeys * sizeof(ScanKeyData));
}

References IndexScanDescData::keyData, and IndexScanDescData::numberOfKeys.

Referenced by brinhandler().

brinvacuumcleanup()

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

Definition at line 1319 of file brin.c.

{
    Relation    heapRel;
 
    /* No-op in ANALYZE ONLY mode */
    if (info->analyze_only)
        return stats;
 
    if (!stats)
        stats = palloc0_object(IndexBulkDeleteResult);
    stats->num_pages = RelationGetNumberOfBlocks(info->index);
    /* rest of stats is initialized by zeroing */
 
    heapRel = table_open(IndexGetRelation(RelationGetRelid(info->index), false),
                         AccessShareLock);
 
    brin_vacuum_scan(info->index, info->strategy);
 
    brinsummarize(info->index, heapRel, BRIN_ALL_BLOCKRANGES, false,
                  &stats->num_index_tuples, &stats->num_index_tuples);
 
    table_close(heapRel, AccessShareLock);
 
    return stats;
}

References AccessShareLock, IndexVacuumInfo::analyze_only, BRIN_ALL_BLOCKRANGES, brin_vacuum_scan(), brinsummarize(), IndexVacuumInfo::index, IndexGetRelation(), IndexBulkDeleteResult::num_index_tuples, IndexBulkDeleteResult::num_pages, palloc0_object, RelationGetNumberOfBlocks, RelationGetRelid, IndexVacuumInfo::strategy, table_close(), and table_open().

Referenced by brinhandler().

brinvalidate()

bool brinvalidate

(

Oid

opclassoid

)

Definition at line 37 of file brin_validate.c.

{
    bool        result = true;
    HeapTuple   classtup;
    Form_pg_opclass classform;
    Oid         opfamilyoid;
    Oid         opcintype;
    char       *opclassname;
    char       *opfamilyname;
    CatCList   *proclist,
               *oprlist;
    uint64      allfuncs = 0;
    uint64      allops = 0;
    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;
    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;
 
        /* Check procedure numbers and function signatures */
        switch (procform->amprocnum)
        {
            case BRIN_PROCNUM_OPCINFO:
                ok = check_amproc_signature(procform->amproc, INTERNALOID, true,
                                            1, 1, INTERNALOID);
                break;
            case BRIN_PROCNUM_ADDVALUE:
                ok = check_amproc_signature(procform->amproc, BOOLOID, true,
                                            4, 4, INTERNALOID, INTERNALOID,
                                            INTERNALOID, INTERNALOID);
                break;
            case BRIN_PROCNUM_CONSISTENT:
                ok = check_amproc_signature(procform->amproc, BOOLOID, true,
                                            3, 4, INTERNALOID, INTERNALOID,
                                            INTERNALOID, INT4OID);
                break;
            case BRIN_PROCNUM_UNION:
                ok = check_amproc_signature(procform->amproc, BOOLOID, true,
                                            3, 3, INTERNALOID, INTERNALOID,
                                            INTERNALOID);
                break;
            case BRIN_PROCNUM_OPTIONS:
                ok = check_amoptsproc_signature(procform->amproc);
                break;
            default:
                /* Complain if it's not a valid optional proc number */
                if (procform->amprocnum < BRIN_FIRST_OPTIONAL_PROCNUM ||
                    procform->amprocnum > BRIN_LAST_OPTIONAL_PROCNUM)
                {
                    ereport(INFO,
                            (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                             errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d",
                                    opfamilyname, "brin",
                                    format_procedure(procform->amproc),
                                    procform->amprocnum)));
                    result = false;
                    continue;   /* omit bad proc numbers from allfuncs */
                }
                /* Can't check signatures of optional procs, so assume OK */
                ok = true;
                break;
        }
 
        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, "brin",
                            format_procedure(procform->amproc),
                            procform->amprocnum)));
            result = false;
        }
 
        /* Track all valid procedure numbers seen in opfamily */
        allfuncs |= ((uint64) 1) << procform->amprocnum;
    }
 
    /* 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);
 
        /* 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, "brin",
                            format_operator(oprform->amopopr),
                            oprform->amopstrategy)));
            result = false;
        }
        else
        {
            /*
             * The set of operators supplied varies across BRIN opfamilies.
             * Our plan is to identify all operator strategy numbers used in
             * the opfamily and then complain about datatype combinations that
             * are missing any operator(s).  However, consider only numbers
             * that appear in some non-cross-type case, since cross-type
             * operators may have unique strategies.  (This is not a great
             * heuristic, in particular an erroneous number used in a
             * cross-type operator will not get noticed; but the core BRIN
             * opfamilies are messy enough to make it necessary.)
             */
            if (oprform->amoplefttype == oprform->amoprighttype)
                allops |= ((uint64) 1) << oprform->amopstrategy;
        }
 
        /* brin 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, "brin",
                            format_operator(oprform->amopopr))));
            result = false;
        }
 
        /* Check operator signature --- same for all brin 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, "brin",
                            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;
 
        /*
         * Some BRIN opfamilies expect cross-type support functions to exist,
         * and some don't.  We don't know exactly which are which, so if we
         * find a cross-type operator for which there are no support functions
         * at all, let it pass.  (Don't expect that all operators exist for
         * such cross-type cases, either.)
         */
        if (thisgroup->functionset == 0 &&
            thisgroup->lefttype != thisgroup->righttype)
            continue;
 
        /*
         * Else complain if there seems to be an incomplete set of either
         * operators or support functions for this datatype pair.
         */
        if (thisgroup->operatorset != allops)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s is missing operator(s) for types %s and %s",
                            opfamilyname, "brin",
                            format_type_be(thisgroup->lefttype),
                            format_type_be(thisgroup->righttype))));
            result = false;
        }
        if (thisgroup->functionset != allfuncs)
        {
            ereport(INFO,
                    (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                     errmsg("operator family \"%s\" of access method %s is missing support function(s) for types %s and %s",
                            opfamilyname, "brin",
                            format_type_be(thisgroup->lefttype),
                            format_type_be(thisgroup->righttype))));
            result = false;
        }
    }
 
    /* Check that the originally-named opclass is complete */
    if (!opclassgroup || opclassgroup->operatorset != allops)
    {
        ereport(INFO,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("operator class \"%s\" of access method %s is missing operator(s)",
                        opclassname, "brin")));
        result = false;
    }
    for (i = 1; i <= BRIN_MANDATORY_NPROCS; i++)
    {
        if (opclassgroup &&
            (opclassgroup->functionset & (((int64) 1) << i)) != 0)
            continue;           /* got it */
        ereport(INFO,
                (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                 errmsg("operator class \"%s\" of access method %s is missing support function %d",
                        opclassname, "brin", i)));
        result = false;
    }
 
    ReleaseCatCacheList(proclist);
    ReleaseCatCacheList(oprlist);
    ReleaseSysCache(classtup);
 
    return result;
}

References BRIN_FIRST_OPTIONAL_PROCNUM, BRIN_LAST_OPTIONAL_PROCNUM, BRIN_MANDATORY_NPROCS, BRIN_PROCNUM_ADDVALUE, BRIN_PROCNUM_CONSISTENT, BRIN_PROCNUM_OPCINFO, BRIN_PROCNUM_OPTIONS, BRIN_PROCNUM_UNION, check_amop_signature(), check_amoptsproc_signature(), check_amproc_signature(), elog, ereport, errcode(), errmsg(), ERROR, format_operator(), format_procedure(), format_type_be(), OpFamilyOpFuncGroup::functionset, get_opfamily_name(), GETSTRUCT(), HeapTupleIsValid, i, identify_opfamily_groups(), INFO, OpFamilyOpFuncGroup::lefttype, lfirst, catclist::members, catclist::n_members, NameStr, ObjectIdGetDatum(), OidIsValid, OpFamilyOpFuncGroup::operatorset, ReleaseCatCacheList(), ReleaseSysCache(), OpFamilyOpFuncGroup::righttype, SearchSysCache1(), SearchSysCacheList1, and catctup::tuple.

Referenced by brinhandler().