PostgreSQL Source Code  git master
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_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

BrinDescbrin_build_desc (Relation rel)
 
void brin_free_desc (BrinDesc *bdesc)
 
IndexBuildResultbrinbuild (Relation heap, Relation index, struct IndexInfo *indexInfo)
 
void brinbuildempty (Relation index)
 
bool brininsert (Relation idxRel, Datum *values, bool *nulls, ItemPointer heaptid, Relation heapRel, IndexUniqueCheck checkUnique, struct 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)
 
IndexBulkDeleteResultbrinbulkdelete (IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
 
IndexBulkDeleteResultbrinvacuumcleanup (IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
 
byteabrinoptions (Datum reloptions, bool validate)
 
bool brinvalidate (Oid opclassoid)
 

Macro Definition Documentation

◆ BRIN_elog

#define BRIN_elog (   args)    ((void) 0)

◆ BRIN_FIRST_OPTIONAL_PROCNUM

#define BRIN_FIRST_OPTIONAL_PROCNUM   11

Definition at line 73 of file brin_internal.h.

Referenced by brinvalidate().

◆ BRIN_LAST_OPTIONAL_PROCNUM

#define BRIN_LAST_OPTIONAL_PROCNUM   15

Definition at line 74 of file brin_internal.h.

Referenced by brinhandler(), and brinvalidate().

◆ BRIN_MANDATORY_NPROCS

#define BRIN_MANDATORY_NPROCS   4

Definition at line 71 of file brin_internal.h.

Referenced by brinvalidate().

◆ BRIN_PROCNUM_ADDVALUE

#define BRIN_PROCNUM_ADDVALUE   2

Definition at line 68 of file brin_internal.h.

Referenced by brinbuildCallback(), brininsert(), and brinvalidate().

◆ BRIN_PROCNUM_CONSISTENT

#define BRIN_PROCNUM_CONSISTENT   3

Definition at line 69 of file brin_internal.h.

Referenced by bringetbitmap(), and brinvalidate().

◆ BRIN_PROCNUM_OPCINFO

#define BRIN_PROCNUM_OPCINFO   1

Definition at line 67 of file brin_internal.h.

Referenced by brin_build_desc(), and brinvalidate().

◆ BRIN_PROCNUM_UNION

#define BRIN_PROCNUM_UNION   4

Definition at line 70 of file brin_internal.h.

Referenced by brinvalidate(), and union_tuples().

◆ SizeofBrinOpcInfo

#define SizeofBrinOpcInfo (   ncols)    (offsetof(BrinOpcInfo, oi_typcache) + sizeof(TypeCacheEntry *) * ncols)

Definition at line 38 of file brin_internal.h.

Referenced by brin_inclusion_opcinfo(), and brin_minmax_opcinfo().

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 1012 of file brin.c.

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, offsetof, BrinOpcInfo::oi_nstored, palloc(), pfree(), RelationGetDescr, and TupleDescAttr.

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

1013 {
1014  BrinOpcInfo **opcinfo;
1015  BrinDesc *bdesc;
1016  TupleDesc tupdesc;
1017  int totalstored = 0;
1018  int keyno;
1019  long totalsize;
1020  MemoryContext cxt;
1021  MemoryContext oldcxt;
1022 
1024  "brin desc cxt",
1026  oldcxt = MemoryContextSwitchTo(cxt);
1027  tupdesc = RelationGetDescr(rel);
1028 
1029  /*
1030  * Obtain BrinOpcInfo for each indexed column. While at it, accumulate
1031  * the number of columns stored, since the number is opclass-defined.
1032  */
1033  opcinfo = (BrinOpcInfo **) palloc(sizeof(BrinOpcInfo *) * tupdesc->natts);
1034  for (keyno = 0; keyno < tupdesc->natts; keyno++)
1035  {
1036  FmgrInfo *opcInfoFn;
1037  Form_pg_attribute attr = TupleDescAttr(tupdesc, keyno);
1038 
1039  opcInfoFn = index_getprocinfo(rel, keyno + 1, BRIN_PROCNUM_OPCINFO);
1040 
1041  opcinfo[keyno] = (BrinOpcInfo *)
1042  DatumGetPointer(FunctionCall1(opcInfoFn, attr->atttypid));
1043  totalstored += opcinfo[keyno]->oi_nstored;
1044  }
1045 
1046  /* Allocate our result struct and fill it in */
1047  totalsize = offsetof(BrinDesc, bd_info) +
1048  sizeof(BrinOpcInfo *) * tupdesc->natts;
1049 
1050  bdesc = palloc(totalsize);
1051  bdesc->bd_context = cxt;
1052  bdesc->bd_index = rel;
1053  bdesc->bd_tupdesc = tupdesc;
1054  bdesc->bd_disktdesc = NULL; /* generated lazily */
1055  bdesc->bd_totalstored = totalstored;
1056 
1057  for (keyno = 0; keyno < tupdesc->natts; keyno++)
1058  bdesc->bd_info[keyno] = opcinfo[keyno];
1059  pfree(opcinfo);
1060 
1061  MemoryContextSwitchTo(oldcxt);
1062 
1063  return bdesc;
1064 }
Definition: fmgr.h:56
#define AllocSetContextCreate
Definition: memutils.h:170
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:794
#define RelationGetDescr(relation)
Definition: rel.h:448
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
#define ALLOCSET_SMALL_SIZES
Definition: memutils.h:202
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define BRIN_PROCNUM_OPCINFO
Definition: brin_internal.h:67
void pfree(void *pointer)
Definition: mcxt.c:1056
Relation bd_index
Definition: brin_internal.h:47
uint16 oi_nstored
Definition: brin_internal.h:28
int bd_totalstored
Definition: brin_internal.h:56
TupleDesc bd_tupdesc
Definition: brin_internal.h:50
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:200
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
BrinOpcInfo * bd_info[FLEXIBLE_ARRAY_MEMBER]
Definition: brin_internal.h:59
#define DatumGetPointer(X)
Definition: postgres.h:549
MemoryContext bd_context
Definition: brin_internal.h:44
void * palloc(Size size)
Definition: mcxt.c:949
TupleDesc bd_disktdesc
Definition: brin_internal.h:53
#define FunctionCall1(flinfo, arg1)
Definition: fmgr.h:633
#define offsetof(type, field)
Definition: c.h:662

◆ brin_free_desc()

void brin_free_desc ( BrinDesc bdesc)

Definition at line 1067 of file brin.c.

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

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

1068 {
1069  /* make sure the tupdesc is still valid */
1070  Assert(bdesc->bd_tupdesc->tdrefcount >= 1);
1071  /* no need for retail pfree */
1073 }
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:211
TupleDesc bd_tupdesc
Definition: brin_internal.h:50
#define Assert(condition)
Definition: c.h:739
MemoryContext bd_context
Definition: brin_internal.h:44
int tdrefcount
Definition: tupdesc.h:84

◆ brinbeginscan()

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

Definition at line 339 of file brin.c.

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

Referenced by brinhandler().

340 {
341  IndexScanDesc scan;
342  BrinOpaque *opaque;
343 
344  scan = RelationGetIndexScan(r, nkeys, norderbys);
345 
346  opaque = (BrinOpaque *) palloc(sizeof(BrinOpaque));
347  opaque->bo_rmAccess = brinRevmapInitialize(r, &opaque->bo_pagesPerRange,
348  scan->xs_snapshot);
349  opaque->bo_bdesc = brin_build_desc(r);
350  scan->opaque = opaque;
351 
352  return scan;
353 }
struct SnapshotData * xs_snapshot
Definition: relscan.h:104
BlockNumber bo_pagesPerRange
Definition: brin.c:62
BrinRevmap * bo_rmAccess
Definition: brin.c:63
BrinDesc * bo_bdesc
Definition: brin.c:64
BrinDesc * brin_build_desc(Relation rel)
Definition: brin.c:1012
BrinRevmap * brinRevmapInitialize(Relation idxrel, BlockNumber *pagesPerRange, Snapshot snapshot)
Definition: brin_revmap.c:71
void * palloc(Size size)
Definition: mcxt.c:949
IndexScanDesc RelationGetIndexScan(Relation indexRelation, int nkeys, int norderbys)
Definition: genam.c:80

◆ brinbuild()

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

Definition at line 662 of file brin.c.

References Assert, BRIN_CURRENT_VERSION, BRIN_METAPAGE_BLKNO, brin_metapage_init(), brinbuildCallback(), BrinGetPagesPerRange, brinRevmapInitialize(), brinRevmapTerminate(), BUFFER_LOCK_EXCLUSIVE, BufferGetBlockNumber(), BufferGetPage, elog, ERROR, form_and_insert_tuple(), IndexBuildResult::heap_tuples, IndexBuildResult::index_tuples, initialize_brin_buildstate(), LockBuffer(), MarkBufferDirty(), P_NEW, PageSetLSN, xl_brin_createidx::pagesPerRange, palloc(), ReadBuffer(), REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetNumberOfBlocks, RelationGetRelationName, RelationNeedsWAL, reltuples, SizeOfBrinCreateIdx, table_index_build_scan(), terminate_brin_buildstate(), UnlockReleaseBuffer(), xl_brin_createidx::version, XLOG_BRIN_CREATE_INDEX, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by brinhandler().

663 {
664  IndexBuildResult *result;
665  double reltuples;
666  double idxtuples;
667  BrinRevmap *revmap;
669  Buffer meta;
670  BlockNumber pagesPerRange;
671 
672  /*
673  * We expect to be called exactly once for any index relation.
674  */
675  if (RelationGetNumberOfBlocks(index) != 0)
676  elog(ERROR, "index \"%s\" already contains data",
677  RelationGetRelationName(index));
678 
679  /*
680  * Critical section not required, because on error the creation of the
681  * whole relation will be rolled back.
682  */
683 
684  meta = ReadBuffer(index, P_NEW);
687 
690  MarkBufferDirty(meta);
691 
692  if (RelationNeedsWAL(index))
693  {
694  xl_brin_createidx xlrec;
695  XLogRecPtr recptr;
696  Page page;
697 
699  xlrec.pagesPerRange = BrinGetPagesPerRange(index);
700 
701  XLogBeginInsert();
702  XLogRegisterData((char *) &xlrec, SizeOfBrinCreateIdx);
704 
705  recptr = XLogInsert(RM_BRIN_ID, XLOG_BRIN_CREATE_INDEX);
706 
707  page = BufferGetPage(meta);
708  PageSetLSN(page, recptr);
709  }
710 
711  UnlockReleaseBuffer(meta);
712 
713  /*
714  * Initialize our state, including the deformed tuple state.
715  */
716  revmap = brinRevmapInitialize(index, &pagesPerRange, NULL);
717  state = initialize_brin_buildstate(index, revmap, pagesPerRange);
718 
719  /*
720  * Now scan the relation. No syncscan allowed here because we want the
721  * heap blocks in physical order.
722  */
723  reltuples = table_index_build_scan(heap, index, indexInfo, false, true,
724  brinbuildCallback, (void *) state, NULL);
725 
726  /* process the final batch */
727  form_and_insert_tuple(state);
728 
729  /* release resources */
730  idxtuples = state->bs_numtuples;
733 
734  /*
735  * Return statistics
736  */
737  result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
738 
739  result->heap_tuples = reltuples;
740  result->index_tuples = idxtuples;
741 
742  return result;
743 }
#define BRIN_CURRENT_VERSION
Definition: brin_page.h:72
#define BRIN_METAPAGE_BLKNO
Definition: brin_page.h:75
#define SizeOfBrinCreateIdx
Definition: brin_xlog.h:55
void brinRevmapTerminate(BrinRevmap *revmap)
Definition: brin_revmap.c:103
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:1458
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
Definition: xloginsert.c:213
#define XLOG_BRIN_CREATE_INDEX
Definition: brin_xlog.h:31
#define REGBUF_WILL_INIT
Definition: xloginsert.h:33
uint32 BlockNumber
Definition: block.h:31
static void form_and_insert_tuple(BrinBuildState *state)
Definition: brin.c:1394
#define P_NEW
Definition: bufmgr.h:81
#define BUFFER_LOCK_EXCLUSIVE
Definition: bufmgr.h:88
#define BrinGetPagesPerRange(relation)
Definition: brin.h:39
void brin_metapage_init(Page page, BlockNumber pagesPerRange, uint16 version)
Definition: brin_pageops.c:487
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3388
#define ERROR
Definition: elog.h:43
static double table_index_build_scan(Relation table_rel, Relation index_rel, struct IndexInfo *index_info, bool allow_sync, bool progress, IndexBuildCallback callback, void *callback_state, TableScanDesc scan)
Definition: tableam.h:1499
#define REGBUF_STANDARD
Definition: xloginsert.h:35
BrinRevmap * bs_rmAccess
Definition: brin.c:52
#define RelationGetRelationName(relation)
Definition: rel.h:456
static void brinbuildCallback(Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *brstate)
Definition: brin.c:599
#define BufferGetPage(buffer)
Definition: bufmgr.h:159
void XLogRegisterData(char *data, int len)
Definition: xloginsert.c:323
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:415
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:3602
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:198
uint64 XLogRecPtr
Definition: xlogdefs.h:21
#define Assert(condition)
Definition: c.h:739
Definition: regguts.h:298
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
Definition: bufmgr.c:596
BrinRevmap * brinRevmapInitialize(Relation idxrel, BlockNumber *pagesPerRange, Snapshot snapshot)
Definition: brin_revmap.c:71
#define RelationNeedsWAL(relation)
Definition: rel.h:524
int bs_numtuples
Definition: brin.c:48
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:2613
void * palloc(Size size)
Definition: mcxt.c:949
#define elog(elevel,...)
Definition: elog.h:228
BlockNumber pagesPerRange
Definition: brin_xlog.h:52
static BrinBuildState * initialize_brin_buildstate(Relation idxRel, BrinRevmap *revmap, BlockNumber pagesPerRange)
Definition: brin.c:1100
void XLogBeginInsert(void)
Definition: xloginsert.c:120
#define PageSetLSN(page, lsn)
Definition: bufpage.h:368
int Buffer
Definition: buf.h:23
float4 reltuples
Definition: pg_class.h:63
Pointer Page
Definition: bufpage.h:78
double index_tuples
Definition: genam.h:33
double heap_tuples
Definition: genam.h:32
static void terminate_brin_buildstate(BrinBuildState *state)
Definition: brin.c:1125

◆ brinbuildempty()

void brinbuildempty ( Relation  index)

Definition at line 746 of file brin.c.

References BRIN_CURRENT_VERSION, brin_metapage_init(), BrinGetPagesPerRange, BUFFER_LOCK_EXCLUSIVE, BufferGetPage, END_CRIT_SECTION, INIT_FORKNUM, LockBuffer(), log_newpage_buffer(), MarkBufferDirty(), P_NEW, RBM_NORMAL, ReadBufferExtended(), START_CRIT_SECTION, and UnlockReleaseBuffer().

Referenced by brinhandler().

747 {
748  Buffer metabuf;
749 
750  /* An empty BRIN index has a metapage only. */
751  metabuf =
754 
755  /* Initialize and xlog metabuffer. */
759  MarkBufferDirty(metabuf);
760  log_newpage_buffer(metabuf, true);
762 
763  UnlockReleaseBuffer(metabuf);
764 }
#define BRIN_CURRENT_VERSION
Definition: brin_page.h:72
XLogRecPtr log_newpage_buffer(Buffer buffer, bool page_std)
Definition: xloginsert.c:1009
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:1458
Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy)
Definition: bufmgr.c:642
#define END_CRIT_SECTION()
Definition: miscadmin.h:134
#define START_CRIT_SECTION()
Definition: miscadmin.h:132
#define P_NEW
Definition: bufmgr.h:81
#define BUFFER_LOCK_EXCLUSIVE
Definition: bufmgr.h:88
#define BrinGetPagesPerRange(relation)
Definition: brin.h:39
void brin_metapage_init(Page page, BlockNumber pagesPerRange, uint16 version)
Definition: brin_pageops.c:487
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3388
#define BufferGetPage(buffer)
Definition: bufmgr.h:159
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:3602
int Buffer
Definition: buf.h:23

◆ brinbulkdelete()

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

Definition at line 776 of file brin.c.

References palloc0().

Referenced by brinhandler().

778 {
779  /* allocate stats if first time through, else re-use existing struct */
780  if (stats == NULL)
782 
783  return stats;
784 }
void * palloc0(Size size)
Definition: mcxt.c:980

◆ brinendscan()

void brinendscan ( IndexScanDesc  scan)

Definition at line 582 of file brin.c.

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

Referenced by brinhandler().

583 {
584  BrinOpaque *opaque = (BrinOpaque *) scan->opaque;
585 
587  brin_free_desc(opaque->bo_bdesc);
588  pfree(opaque);
589 }
void brin_free_desc(BrinDesc *bdesc)
Definition: brin.c:1067
void brinRevmapTerminate(BrinRevmap *revmap)
Definition: brin_revmap.c:103
void pfree(void *pointer)
Definition: mcxt.c:1056
BrinRevmap * bo_rmAccess
Definition: brin.c:63
BrinDesc * bo_bdesc
Definition: brin.c:64

◆ bringetbitmap()

int64 bringetbitmap ( IndexScanDesc  scan,
TIDBitmap tbm 
)

Definition at line 368 of file brin.c.

References AccessShareLock, addrange(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, 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_placeholder, buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, CHECK_FOR_INTERRUPTS, CurrentMemoryContext, DatumGetBool, fmgr_info_copy(), FunctionCall3Coll(), index_getprocinfo(), IndexGetRelation(), IndexScanDescData::indexRelation, InvalidBuffer, InvalidOid, sort-test::key, IndexScanDescData::keyData, LockBuffer(), MemoryContextDelete(), MemoryContextResetAndDeleteChildren, MemoryContextSwitchTo(), TupleDescData::natts, IndexScanDescData::numberOfKeys, IndexScanDescData::opaque, palloc0(), pgstat_count_index_scan, PointerGetDatum, RelationGetNumberOfBlocks, RelationGetRelid, ReleaseBuffer(), ScanKeyData::sk_attno, ScanKeyData::sk_collation, ScanKeyData::sk_flags, SK_ISNULL, table_close(), table_open(), tbm_add_page(), TupleDescAttr, and IndexScanDescData::xs_snapshot.

Referenced by brinhandler().

369 {
370  Relation idxRel = scan->indexRelation;
372  BrinDesc *bdesc;
373  Oid heapOid;
374  Relation heapRel;
375  BrinOpaque *opaque;
376  BlockNumber nblocks;
377  BlockNumber heapBlk;
378  int totalpages = 0;
379  FmgrInfo *consistentFn;
380  MemoryContext oldcxt;
381  MemoryContext perRangeCxt;
382  BrinMemTuple *dtup;
383  BrinTuple *btup = NULL;
384  Size btupsz = 0;
385 
386  opaque = (BrinOpaque *) scan->opaque;
387  bdesc = opaque->bo_bdesc;
388  pgstat_count_index_scan(idxRel);
389 
390  /*
391  * We need to know the size of the table so that we know how long to
392  * iterate on the revmap.
393  */
394  heapOid = IndexGetRelation(RelationGetRelid(idxRel), false);
395  heapRel = table_open(heapOid, AccessShareLock);
396  nblocks = RelationGetNumberOfBlocks(heapRel);
397  table_close(heapRel, AccessShareLock);
398 
399  /*
400  * Make room for the consistent support procedures of indexed columns. We
401  * don't look them up here; we do that lazily the first time we see a scan
402  * key reference each of them. We rely on zeroing fn_oid to InvalidOid.
403  */
404  consistentFn = palloc0(sizeof(FmgrInfo) * bdesc->bd_tupdesc->natts);
405 
406  /* allocate an initial in-memory tuple, out of the per-range memcxt */
407  dtup = brin_new_memtuple(bdesc);
408 
409  /*
410  * Setup and use a per-range memory context, which is reset every time we
411  * loop below. This avoids having to free the tuples within the loop.
412  */
414  "bringetbitmap cxt",
416  oldcxt = MemoryContextSwitchTo(perRangeCxt);
417 
418  /*
419  * Now scan the revmap. We start by querying for heap page 0,
420  * incrementing by the number of pages per range; this gives us a full
421  * view of the table.
422  */
423  for (heapBlk = 0; heapBlk < nblocks; heapBlk += opaque->bo_pagesPerRange)
424  {
425  bool addrange;
426  bool gottuple = false;
427  BrinTuple *tup;
428  OffsetNumber off;
429  Size size;
430 
432 
434 
435  tup = brinGetTupleForHeapBlock(opaque->bo_rmAccess, heapBlk, &buf,
436  &off, &size, BUFFER_LOCK_SHARE,
437  scan->xs_snapshot);
438  if (tup)
439  {
440  gottuple = true;
441  btup = brin_copy_tuple(tup, size, btup, &btupsz);
443  }
444 
445  /*
446  * For page ranges with no indexed tuple, we must return the whole
447  * range; otherwise, compare it to the scan keys.
448  */
449  if (!gottuple)
450  {
451  addrange = true;
452  }
453  else
454  {
455  dtup = brin_deform_tuple(bdesc, btup, dtup);
456  if (dtup->bt_placeholder)
457  {
458  /*
459  * Placeholder tuples are always returned, regardless of the
460  * values stored in them.
461  */
462  addrange = true;
463  }
464  else
465  {
466  int keyno;
467 
468  /*
469  * Compare scan keys with summary values stored for the range.
470  * If scan keys are matched, the page range must be added to
471  * the bitmap. We initially assume the range needs to be
472  * added; in particular this serves the case where there are
473  * no keys.
474  */
475  addrange = true;
476  for (keyno = 0; keyno < scan->numberOfKeys; keyno++)
477  {
478  ScanKey key = &scan->keyData[keyno];
479  AttrNumber keyattno = key->sk_attno;
480  BrinValues *bval = &dtup->bt_columns[keyattno - 1];
481  Datum add;
482 
483  /*
484  * The collation of the scan key must match the collation
485  * used in the index column (but only if the search is not
486  * IS NULL/ IS NOT NULL). Otherwise we shouldn't be using
487  * this index ...
488  */
489  Assert((key->sk_flags & SK_ISNULL) ||
490  (key->sk_collation ==
491  TupleDescAttr(bdesc->bd_tupdesc,
492  keyattno - 1)->attcollation));
493 
494  /* First time this column? look up consistent function */
495  if (consistentFn[keyattno - 1].fn_oid == InvalidOid)
496  {
497  FmgrInfo *tmp;
498 
499  tmp = index_getprocinfo(idxRel, keyattno,
501  fmgr_info_copy(&consistentFn[keyattno - 1], tmp,
503  }
504 
505  /*
506  * Check whether the scan key is consistent with the page
507  * range values; if so, have the pages in the range added
508  * to the output bitmap.
509  *
510  * When there are multiple scan keys, failure to meet the
511  * criteria for a single one of them is enough to discard
512  * the range as a whole, so break out of the loop as soon
513  * as a false return value is obtained.
514  */
515  add = FunctionCall3Coll(&consistentFn[keyattno - 1],
516  key->sk_collation,
517  PointerGetDatum(bdesc),
518  PointerGetDatum(bval),
519  PointerGetDatum(key));
520  addrange = DatumGetBool(add);
521  if (!addrange)
522  break;
523  }
524  }
525  }
526 
527  /* add the pages in the range to the output bitmap, if needed */
528  if (addrange)
529  {
530  BlockNumber pageno;
531 
532  for (pageno = heapBlk;
533  pageno <= heapBlk + opaque->bo_pagesPerRange - 1;
534  pageno++)
535  {
536  MemoryContextSwitchTo(oldcxt);
537  tbm_add_page(tbm, pageno);
538  totalpages++;
539  MemoryContextSwitchTo(perRangeCxt);
540  }
541  }
542  }
543 
544  MemoryContextSwitchTo(oldcxt);
545  MemoryContextDelete(perRangeCxt);
546 
547  if (buf != InvalidBuffer)
548  ReleaseBuffer(buf);
549 
550  /*
551  * XXX We have an approximation of the number of *pages* that our scan
552  * returns, but we don't have a precise idea of the number of heap tuples
553  * involved.
554  */
555  return totalpages * 10;
556 }
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:86
Definition: fmgr.h:56
Oid IndexGetRelation(Oid indexId, bool missing_ok)
Definition: index.c:3380
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:211
#define AllocSetContextCreate
Definition: memutils.h:170
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:133
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:794
BrinTuple * brin_copy_tuple(BrinTuple *tuple, Size len, BrinTuple *dest, Size *destsz)
Definition: brin_tuple.c:320
BrinTuple * brinGetTupleForHeapBlock(BrinRevmap *revmap, BlockNumber heapBlk, Buffer *buf, OffsetNumber *off, Size *size, int mode, Snapshot snapshot)
Definition: brin_revmap.c:197
#define PointerGetDatum(X)
Definition: postgres.h:556
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92
static void addrange(struct cvec *cv, chr from, chr to)
Definition: regc_cvec.c:90
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define AccessShareLock
Definition: lockdefs.h:36
#define InvalidBuffer
Definition: buf.h:25
struct SnapshotData * xs_snapshot
Definition: relscan.h:104
uint32 BlockNumber
Definition: block.h:31
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3365
unsigned int Oid
Definition: postgres_ext.h:31
BrinMemTuple * brin_new_memtuple(BrinDesc *brdesc)
Definition: brin_tuple.c:356
BlockNumber bo_pagesPerRange
Definition: brin.c:62
Relation indexRelation
Definition: relscan.h:103
uint16 OffsetNumber
Definition: off.h:24
BrinMemTuple * brin_deform_tuple(BrinDesc *brdesc, BrinTuple *tuple, BrinMemTuple *dMemtuple)
Definition: brin_tuple.c:421
bool bt_placeholder
Definition: brin_tuple.h:38
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:192
void fmgr_info_copy(FmgrInfo *dstinfo, FmgrInfo *srcinfo, MemoryContext destcxt)
Definition: fmgr.c:610
BrinValues bt_columns[FLEXIBLE_ARRAY_MEMBER]
Definition: brin_tuple.h:46
static char * buf
Definition: pg_test_fsync.c:67
BrinRevmap * bo_rmAccess
Definition: brin.c:63
#define DatumGetBool(X)
Definition: postgres.h:393
#define pgstat_count_index_scan(rel)
Definition: pgstat.h:1373
TupleDesc bd_tupdesc
Definition: brin_internal.h:50
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
#define SK_ISNULL
Definition: skey.h:115
#define MemoryContextResetAndDeleteChildren(ctx)
Definition: memutils.h:67
BrinDesc * bo_bdesc
Definition: brin.c:64
void * palloc0(Size size)
Definition: mcxt.c:980
uintptr_t Datum
Definition: postgres.h:367
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:3602
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:198
#define InvalidOid
Definition: postgres_ext.h:36
Datum FunctionCall3Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3)
Definition: fmgr.c:1172
int sk_flags
Definition: skey.h:66
#define Assert(condition)
Definition: c.h:739
#define BRIN_PROCNUM_CONSISTENT
Definition: brin_internal.h:69
size_t Size
Definition: c.h:467
struct ScanKeyData * keyData
Definition: relscan.h:107
void tbm_add_page(TIDBitmap *tbm, BlockNumber pageno)
Definition: tidbitmap.c:442
Oid sk_collation
Definition: skey.h:70
#define BUFFER_LOCK_SHARE
Definition: bufmgr.h:87
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:39
int Buffer
Definition: buf.h:23
int16 AttrNumber
Definition: attnum.h:21
#define RelationGetRelid(relation)
Definition: rel.h:422
AttrNumber sk_attno
Definition: skey.h:67

◆ brininsert()

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

Definition at line 144 of file brin.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AutoVacuumRequestWork(), AVW_BRINSummarizeRange, BrinDesc::bd_tupdesc, brin_build_desc(), brin_can_do_samepage_update(), brin_copy_tuple(), brin_deform_tuple(), brin_doupdate(), brin_form_tuple(), BRIN_PROCNUM_ADDVALUE, BrinGetAutoSummarize, brinGetTupleForHeapBlock(), brinRevmapInitialize(), brinRevmapTerminate(), BrinMemTuple::bt_columns, buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage, BufferIsValid, CHECK_FOR_INTERRUPTS, CurrentMemoryContext, DatumGetBool, ereport, errcode(), errmsg(), FirstOffsetNumber, FunctionCall4Coll(), IndexInfo::ii_AmCache, IndexInfo::ii_Context, index_getprocinfo(), InvalidBuffer, ItemIdGetLength, ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, LockBuffer(), LOG, MemoryContextDelete(), MemoryContextResetAndDeleteChildren, MemoryContextSwitchTo(), TupleDescData::natts, PageGetItemId, PointerGetDatum, RelationData::rd_indcollation, RelationGetRelationName, RelationGetRelid, and ReleaseBuffer().

Referenced by brinhandler().

148 {
149  BlockNumber pagesPerRange;
150  BlockNumber origHeapBlk;
151  BlockNumber heapBlk;
152  BrinDesc *bdesc = (BrinDesc *) indexInfo->ii_AmCache;
153  BrinRevmap *revmap;
155  MemoryContext tupcxt = NULL;
157  bool autosummarize = BrinGetAutoSummarize(idxRel);
158 
159  revmap = brinRevmapInitialize(idxRel, &pagesPerRange, NULL);
160 
161  /*
162  * origHeapBlk is the block number where the insertion occurred. heapBlk
163  * is the first block in the corresponding page range.
164  */
165  origHeapBlk = ItemPointerGetBlockNumber(heaptid);
166  heapBlk = (origHeapBlk / pagesPerRange) * pagesPerRange;
167 
168  for (;;)
169  {
170  bool need_insert = false;
171  OffsetNumber off;
172  BrinTuple *brtup;
173  BrinMemTuple *dtup;
174  int keyno;
175 
177 
178  /*
179  * If auto-summarization is enabled and we just inserted the first
180  * tuple into the first block of a new non-first page range, request a
181  * summarization run of the previous range.
182  */
183  if (autosummarize &&
184  heapBlk > 0 &&
185  heapBlk == origHeapBlk &&
187  {
188  BlockNumber lastPageRange = heapBlk - 1;
189  BrinTuple *lastPageTuple;
190 
191  lastPageTuple =
192  brinGetTupleForHeapBlock(revmap, lastPageRange, &buf, &off,
193  NULL, BUFFER_LOCK_SHARE, NULL);
194  if (!lastPageTuple)
195  {
196  bool recorded;
197 
199  RelationGetRelid(idxRel),
200  lastPageRange);
201  if (!recorded)
202  ereport(LOG,
203  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
204  errmsg("request for BRIN range summarization for index \"%s\" page %u was not recorded",
205  RelationGetRelationName(idxRel),
206  lastPageRange)));
207  }
208  else
210  }
211 
212  brtup = brinGetTupleForHeapBlock(revmap, heapBlk, &buf, &off,
213  NULL, BUFFER_LOCK_SHARE, NULL);
214 
215  /* if range is unsummarized, there's nothing to do */
216  if (!brtup)
217  break;
218 
219  /* First time through in this statement? */
220  if (bdesc == NULL)
221  {
222  MemoryContextSwitchTo(indexInfo->ii_Context);
223  bdesc = brin_build_desc(idxRel);
224  indexInfo->ii_AmCache = (void *) bdesc;
225  MemoryContextSwitchTo(oldcxt);
226  }
227  /* First time through in this brininsert call? */
228  if (tupcxt == NULL)
229  {
231  "brininsert cxt",
233  MemoryContextSwitchTo(tupcxt);
234  }
235 
236  dtup = brin_deform_tuple(bdesc, brtup, NULL);
237 
238  /*
239  * Compare the key values of the new tuple to the stored index values;
240  * our deformed tuple will get updated if the new tuple doesn't fit
241  * the original range (note this means we can't break out of the loop
242  * early). Make a note of whether this happens, so that we know to
243  * insert the modified tuple later.
244  */
245  for (keyno = 0; keyno < bdesc->bd_tupdesc->natts; keyno++)
246  {
247  Datum result;
248  BrinValues *bval;
249  FmgrInfo *addValue;
250 
251  bval = &dtup->bt_columns[keyno];
252  addValue = index_getprocinfo(idxRel, keyno + 1,
254  result = FunctionCall4Coll(addValue,
255  idxRel->rd_indcollation[keyno],
256  PointerGetDatum(bdesc),
257  PointerGetDatum(bval),
258  values[keyno],
259  nulls[keyno]);
260  /* if that returned true, we need to insert the updated tuple */
261  need_insert |= DatumGetBool(result);
262  }
263 
264  if (!need_insert)
265  {
266  /*
267  * The tuple is consistent with the new values, so there's nothing
268  * to do.
269  */
271  }
272  else
273  {
274  Page page = BufferGetPage(buf);
275  ItemId lp = PageGetItemId(page, off);
276  Size origsz;
277  BrinTuple *origtup;
278  Size newsz;
279  BrinTuple *newtup;
280  bool samepage;
281 
282  /*
283  * Make a copy of the old tuple, so that we can compare it after
284  * re-acquiring the lock.
285  */
286  origsz = ItemIdGetLength(lp);
287  origtup = brin_copy_tuple(brtup, origsz, NULL, NULL);
288 
289  /*
290  * Before releasing the lock, check if we can attempt a same-page
291  * update. Another process could insert a tuple concurrently in
292  * the same page though, so downstream we must be prepared to cope
293  * if this turns out to not be possible after all.
294  */
295  newtup = brin_form_tuple(bdesc, heapBlk, dtup, &newsz);
296  samepage = brin_can_do_samepage_update(buf, origsz, newsz);
298 
299  /*
300  * Try to update the tuple. If this doesn't work for whatever
301  * reason, we need to restart from the top; the revmap might be
302  * pointing at a different tuple for this block now, so we need to
303  * recompute to ensure both our new heap tuple and the other
304  * inserter's are covered by the combined tuple. It might be that
305  * we don't need to update at all.
306  */
307  if (!brin_doupdate(idxRel, pagesPerRange, revmap, heapBlk,
308  buf, off, origtup, origsz, newtup, newsz,
309  samepage))
310  {
311  /* no luck; start over */
313  continue;
314  }
315  }
316 
317  /* success! */
318  break;
319  }
320 
321  brinRevmapTerminate(revmap);
322  if (BufferIsValid(buf))
324  MemoryContextSwitchTo(oldcxt);
325  if (tupcxt != NULL)
326  MemoryContextDelete(tupcxt);
327 
328  return false;
329 }
bool AutoVacuumRequestWork(AutoVacuumWorkItemType type, Oid relationId, BlockNumber blkno)
Definition: autovacuum.c:3219
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:86
MemoryContext ii_Context
Definition: execnodes.h:176
Definition: fmgr.h:56
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:211
#define AllocSetContextCreate
Definition: memutils.h:170
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:794
BrinTuple * brin_copy_tuple(BrinTuple *tuple, Size len, BrinTuple *dest, Size *destsz)
Definition: brin_tuple.c:320
void brinRevmapTerminate(BrinRevmap *revmap)
Definition: brin_revmap.c:103
BrinTuple * brinGetTupleForHeapBlock(BrinRevmap *revmap, BlockNumber heapBlk, Buffer *buf, OffsetNumber *off, Size *size, int mode, Snapshot snapshot)
Definition: brin_revmap.c:197
#define PointerGetDatum(X)
Definition: postgres.h:556
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define InvalidBuffer
Definition: buf.h:25
int errcode(int sqlerrcode)
Definition: elog.c:608
Datum FunctionCall4Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4)
Definition: fmgr.c:1197
uint32 BlockNumber
Definition: block.h:31
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3365
#define LOG
Definition: elog.h:26
bool brin_doupdate(Relation idxrel, BlockNumber pagesPerRange, BrinRevmap *revmap, BlockNumber heapBlk, Buffer oldbuf, OffsetNumber oldoff, const BrinTuple *origtup, Size origsz, const BrinTuple *newtup, Size newsz, bool samepage)
Definition: brin_pageops.c:54
uint16 OffsetNumber
Definition: off.h:24
BrinMemTuple * brin_deform_tuple(BrinDesc *brdesc, BrinTuple *tuple, BrinMemTuple *dMemtuple)
Definition: brin_tuple.c:421
#define BRIN_PROCNUM_ADDVALUE
Definition: brin_internal.h:68
#define ItemIdGetLength(itemId)
Definition: itemid.h:59
Oid * rd_indcollation
Definition: rel.h:168
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:192
BrinValues bt_columns[FLEXIBLE_ARRAY_MEMBER]
Definition: brin_tuple.h:46
static char * buf
Definition: pg_test_fsync.c:67
#define FirstOffsetNumber
Definition: off.h:27
#define DatumGetBool(X)
Definition: postgres.h:393
#define RelationGetRelationName(relation)
Definition: rel.h:456
TupleDesc bd_tupdesc
Definition: brin_internal.h:50
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
#define BufferGetPage(buffer)
Definition: bufmgr.h:159
#define ereport(elevel, rest)
Definition: elog.h:141
bool brin_can_do_samepage_update(Buffer buffer, Size origsz, Size newsz)
Definition: brin_pageops.c:324
void * ii_AmCache
Definition: execnodes.h:175
#define PageGetItemId(page, offsetNumber)
Definition: bufpage.h:235
#define MemoryContextResetAndDeleteChildren(ctx)
Definition: memutils.h:67
uintptr_t Datum
Definition: postgres.h:367
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:3602
BrinDesc * brin_build_desc(Relation rel)
Definition: brin.c:1012
size_t Size
Definition: c.h:467
BrinRevmap * brinRevmapInitialize(Relation idxrel, BlockNumber *pagesPerRange, Snapshot snapshot)
Definition: brin_revmap.c:71
#define BufferIsValid(bufnum)
Definition: bufmgr.h:113
#define ItemPointerGetOffsetNumber(pointer)
Definition: itemptr.h:117
static Datum values[MAXATTR]
Definition: bootstrap.c:167
#define BrinGetAutoSummarize(relation)
Definition: brin.h:45
int errmsg(const char *fmt,...)
Definition: elog.c:822
BrinTuple * brin_form_tuple(BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple, Size *size)
Definition: brin_tuple.c:88
#define BUFFER_LOCK_SHARE
Definition: bufmgr.h:87
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:99
#define ItemPointerGetBlockNumber(pointer)
Definition: itemptr.h:98
int Buffer
Definition: buf.h:23
#define RelationGetRelid(relation)
Definition: rel.h:422
Pointer Page
Definition: bufpage.h:78

◆ brinoptions()

bytea* brinoptions ( Datum  reloptions,
bool  validate 
)

Definition at line 821 of file brin.c.

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

Referenced by brinhandler().

822 {
823  static const relopt_parse_elt tab[] = {
824  {"pages_per_range", RELOPT_TYPE_INT, offsetof(BrinOptions, pagesPerRange)},
825  {"autosummarize", RELOPT_TYPE_BOOL, offsetof(BrinOptions, autosummarize)}
826  };
827 
828  return (bytea *) build_reloptions(reloptions, validate,
830  sizeof(BrinOptions),
831  tab, lengthof(tab));
832 }
#define lengthof(array)
Definition: c.h:669
void * build_reloptions(Datum reloptions, bool validate, relopt_kind kind, Size relopt_struct_size, const relopt_parse_elt *relopt_elems, int num_relopt_elems)
Definition: reloptions.c:1552
Definition: c.h:556
#define offsetof(type, field)
Definition: c.h:662

◆ brinrescan()

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

Definition at line 562 of file brin.c.

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

Referenced by brinhandler().

564 {
565  /*
566  * Other index AMs preprocess the scan keys at this point, or sometime
567  * early during the scan; this lets them optimize by removing redundant
568  * keys, or doing early returns when they are impossible to satisfy; see
569  * _bt_preprocess_keys for an example. Something like that could be added
570  * here someday, too.
571  */
572 
573  if (scankey && scan->numberOfKeys > 0)
574  memmove(scan->keyData, scankey,
575  scan->numberOfKeys * sizeof(ScanKeyData));
576 }
#define memmove(d, s, c)
Definition: c.h:1267
struct ScanKeyData * keyData
Definition: relscan.h:107

◆ brinvacuumcleanup()

IndexBulkDeleteResult* brinvacuumcleanup ( IndexVacuumInfo info,
IndexBulkDeleteResult stats 
)

Definition at line 791 of file brin.c.

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

Referenced by brinhandler().

792 {
793  Relation heapRel;
794 
795  /* No-op in ANALYZE ONLY mode */
796  if (info->analyze_only)
797  return stats;
798 
799  if (!stats)
801  stats->num_pages = RelationGetNumberOfBlocks(info->index);
802  /* rest of stats is initialized by zeroing */
803 
804  heapRel = table_open(IndexGetRelation(RelationGetRelid(info->index), false),
806 
807  brin_vacuum_scan(info->index, info->strategy);
808 
809  brinsummarize(info->index, heapRel, BRIN_ALL_BLOCKRANGES, false,
810  &stats->num_index_tuples, &stats->num_index_tuples);
811 
812  table_close(heapRel, AccessShareLock);
813 
814  return stats;
815 }
Oid IndexGetRelation(Oid indexId, bool missing_ok)
Definition: index.c:3380
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:133
bool analyze_only
Definition: genam.h:47
BufferAccessStrategy strategy
Definition: genam.h:52
#define AccessShareLock
Definition: lockdefs.h:36
Relation index
Definition: genam.h:46
BlockNumber num_pages
Definition: genam.h:74
static void brin_vacuum_scan(Relation idxrel, BufferAccessStrategy strategy)
Definition: brin.c:1456
static void brinsummarize(Relation index, Relation heapRel, BlockNumber pageRange, bool include_partial, double *numSummarized, double *numExisting)
Definition: brin.c:1297
void * palloc0(Size size)
Definition: mcxt.c:980
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:198
#define BRIN_ALL_BLOCKRANGES
Definition: brin.c:67
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:39
double num_index_tuples
Definition: genam.h:77
#define RelationGetRelid(relation)
Definition: rel.h:422

◆ brinvalidate()

bool brinvalidate ( Oid  opclassoid)

Definition at line 37 of file brin_validate.c.

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

Referenced by brinhandler().

38 {
39  bool result = true;
40  HeapTuple classtup;
41  Form_pg_opclass classform;
42  Oid opfamilyoid;
43  Oid opcintype;
44  char *opclassname;
45  HeapTuple familytup;
46  Form_pg_opfamily familyform;
47  char *opfamilyname;
48  CatCList *proclist,
49  *oprlist;
50  uint64 allfuncs = 0;
51  uint64 allops = 0;
52  List *grouplist;
53  OpFamilyOpFuncGroup *opclassgroup;
54  int i;
55  ListCell *lc;
56 
57  /* Fetch opclass information */
58  classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassoid));
59  if (!HeapTupleIsValid(classtup))
60  elog(ERROR, "cache lookup failed for operator class %u", opclassoid);
61  classform = (Form_pg_opclass) GETSTRUCT(classtup);
62 
63  opfamilyoid = classform->opcfamily;
64  opcintype = classform->opcintype;
65  opclassname = NameStr(classform->opcname);
66 
67  /* Fetch opfamily information */
68  familytup = SearchSysCache1(OPFAMILYOID, ObjectIdGetDatum(opfamilyoid));
69  if (!HeapTupleIsValid(familytup))
70  elog(ERROR, "cache lookup failed for operator family %u", opfamilyoid);
71  familyform = (Form_pg_opfamily) GETSTRUCT(familytup);
72 
73  opfamilyname = NameStr(familyform->opfname);
74 
75  /* Fetch all operators and support functions of the opfamily */
76  oprlist = SearchSysCacheList1(AMOPSTRATEGY, ObjectIdGetDatum(opfamilyoid));
77  proclist = SearchSysCacheList1(AMPROCNUM, ObjectIdGetDatum(opfamilyoid));
78 
79  /* Check individual support functions */
80  for (i = 0; i < proclist->n_members; i++)
81  {
82  HeapTuple proctup = &proclist->members[i]->tuple;
83  Form_pg_amproc procform = (Form_pg_amproc) GETSTRUCT(proctup);
84  bool ok;
85 
86  /* Check procedure numbers and function signatures */
87  switch (procform->amprocnum)
88  {
90  ok = check_amproc_signature(procform->amproc, INTERNALOID, true,
91  1, 1, INTERNALOID);
92  break;
94  ok = check_amproc_signature(procform->amproc, BOOLOID, true,
95  4, 4, INTERNALOID, INTERNALOID,
96  INTERNALOID, INTERNALOID);
97  break;
99  ok = check_amproc_signature(procform->amproc, BOOLOID, true,
100  3, 3, INTERNALOID, INTERNALOID,
101  INTERNALOID);
102  break;
103  case BRIN_PROCNUM_UNION:
104  ok = check_amproc_signature(procform->amproc, BOOLOID, true,
105  3, 3, INTERNALOID, INTERNALOID,
106  INTERNALOID);
107  break;
108  default:
109  /* Complain if it's not a valid optional proc number */
110  if (procform->amprocnum < BRIN_FIRST_OPTIONAL_PROCNUM ||
111  procform->amprocnum > BRIN_LAST_OPTIONAL_PROCNUM)
112  {
113  ereport(INFO,
114  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
115  errmsg("operator family \"%s\" of access method %s contains function %s with invalid support number %d",
116  opfamilyname, "brin",
117  format_procedure(procform->amproc),
118  procform->amprocnum)));
119  result = false;
120  continue; /* omit bad proc numbers from allfuncs */
121  }
122  /* Can't check signatures of optional procs, so assume OK */
123  ok = true;
124  break;
125  }
126 
127  if (!ok)
128  {
129  ereport(INFO,
130  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
131  errmsg("operator family \"%s\" of access method %s contains function %s with wrong signature for support number %d",
132  opfamilyname, "brin",
133  format_procedure(procform->amproc),
134  procform->amprocnum)));
135  result = false;
136  }
137 
138  /* Track all valid procedure numbers seen in opfamily */
139  allfuncs |= ((uint64) 1) << procform->amprocnum;
140  }
141 
142  /* Check individual operators */
143  for (i = 0; i < oprlist->n_members; i++)
144  {
145  HeapTuple oprtup = &oprlist->members[i]->tuple;
146  Form_pg_amop oprform = (Form_pg_amop) GETSTRUCT(oprtup);
147 
148  /* Check that only allowed strategy numbers exist */
149  if (oprform->amopstrategy < 1 || oprform->amopstrategy > 63)
150  {
151  ereport(INFO,
152  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
153  errmsg("operator family \"%s\" of access method %s contains operator %s with invalid strategy number %d",
154  opfamilyname, "brin",
155  format_operator(oprform->amopopr),
156  oprform->amopstrategy)));
157  result = false;
158  }
159  else
160  {
161  /*
162  * The set of operators supplied varies across BRIN opfamilies.
163  * Our plan is to identify all operator strategy numbers used in
164  * the opfamily and then complain about datatype combinations that
165  * are missing any operator(s). However, consider only numbers
166  * that appear in some non-cross-type case, since cross-type
167  * operators may have unique strategies. (This is not a great
168  * heuristic, in particular an erroneous number used in a
169  * cross-type operator will not get noticed; but the core BRIN
170  * opfamilies are messy enough to make it necessary.)
171  */
172  if (oprform->amoplefttype == oprform->amoprighttype)
173  allops |= ((uint64) 1) << oprform->amopstrategy;
174  }
175 
176  /* brin doesn't support ORDER BY operators */
177  if (oprform->amoppurpose != AMOP_SEARCH ||
178  OidIsValid(oprform->amopsortfamily))
179  {
180  ereport(INFO,
181  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
182  errmsg("operator family \"%s\" of access method %s contains invalid ORDER BY specification for operator %s",
183  opfamilyname, "brin",
184  format_operator(oprform->amopopr))));
185  result = false;
186  }
187 
188  /* Check operator signature --- same for all brin strategies */
189  if (!check_amop_signature(oprform->amopopr, BOOLOID,
190  oprform->amoplefttype,
191  oprform->amoprighttype))
192  {
193  ereport(INFO,
194  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
195  errmsg("operator family \"%s\" of access method %s contains operator %s with wrong signature",
196  opfamilyname, "brin",
197  format_operator(oprform->amopopr))));
198  result = false;
199  }
200  }
201 
202  /* Now check for inconsistent groups of operators/functions */
203  grouplist = identify_opfamily_groups(oprlist, proclist);
204  opclassgroup = NULL;
205  foreach(lc, grouplist)
206  {
207  OpFamilyOpFuncGroup *thisgroup = (OpFamilyOpFuncGroup *) lfirst(lc);
208 
209  /* Remember the group exactly matching the test opclass */
210  if (thisgroup->lefttype == opcintype &&
211  thisgroup->righttype == opcintype)
212  opclassgroup = thisgroup;
213 
214  /*
215  * Some BRIN opfamilies expect cross-type support functions to exist,
216  * and some don't. We don't know exactly which are which, so if we
217  * find a cross-type operator for which there are no support functions
218  * at all, let it pass. (Don't expect that all operators exist for
219  * such cross-type cases, either.)
220  */
221  if (thisgroup->functionset == 0 &&
222  thisgroup->lefttype != thisgroup->righttype)
223  continue;
224 
225  /*
226  * Else complain if there seems to be an incomplete set of either
227  * operators or support functions for this datatype pair.
228  */
229  if (thisgroup->operatorset != allops)
230  {
231  ereport(INFO,
232  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
233  errmsg("operator family \"%s\" of access method %s is missing operator(s) for types %s and %s",
234  opfamilyname, "brin",
235  format_type_be(thisgroup->lefttype),
236  format_type_be(thisgroup->righttype))));
237  result = false;
238  }
239  if (thisgroup->functionset != allfuncs)
240  {
241  ereport(INFO,
242  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
243  errmsg("operator family \"%s\" of access method %s is missing support function(s) for types %s and %s",
244  opfamilyname, "brin",
245  format_type_be(thisgroup->lefttype),
246  format_type_be(thisgroup->righttype))));
247  result = false;
248  }
249  }
250 
251  /* Check that the originally-named opclass is complete */
252  if (!opclassgroup || opclassgroup->operatorset != allops)
253  {
254  ereport(INFO,
255  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
256  errmsg("operator class \"%s\" of access method %s is missing operator(s)",
257  opclassname, "brin")));
258  result = false;
259  }
260  for (i = 1; i <= BRIN_MANDATORY_NPROCS; i++)
261  {
262  if (opclassgroup &&
263  (opclassgroup->functionset & (((int64) 1) << i)) != 0)
264  continue; /* got it */
265  ereport(INFO,
266  (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
267  errmsg("operator class \"%s\" of access method %s is missing support function %d",
268  opclassname, "brin", i)));
269  result = false;
270  }
271 
272  ReleaseCatCacheList(proclist);
273  ReleaseCatCacheList(oprlist);
274  ReleaseSysCache(familytup);
275  ReleaseSysCache(classtup);
276 
277  return result;
278 }
int n_members
Definition: catcache.h:176
#define GETSTRUCT(TUP)
Definition: htup_details.h:655
FormData_pg_amproc * Form_pg_amproc
Definition: pg_amproc.h:68
#define BRIN_PROCNUM_OPCINFO
Definition: brin_internal.h:67
int errcode(int sqlerrcode)
Definition: elog.c:608
#define INFO
Definition: elog.h:33
char * format_type_be(Oid type_oid)
Definition: format_type.c:326
char * format_operator(Oid operator_oid)
Definition: regproc.c:820
unsigned int Oid
Definition: postgres_ext.h:31
#define OidIsValid(objectId)
Definition: c.h:645
void ReleaseCatCacheList(CatCList *list)
Definition: catcache.c:1782
CatCTup * members[FLEXIBLE_ARRAY_MEMBER]
Definition: catcache.h:178
#define BRIN_PROCNUM_ADDVALUE
Definition: brin_internal.h:68
bool check_amproc_signature(Oid funcid, Oid restype, bool exact, int minargs, int maxargs,...)
Definition: amvalidate.c:150
#define ObjectIdGetDatum(X)
Definition: postgres.h:507
#define ERROR
Definition: elog.h:43
#define BRIN_MANDATORY_NPROCS
Definition: brin_internal.h:71
List * identify_opfamily_groups(CatCList *oprlist, CatCList *proclist)
Definition: amvalidate.c:41
#define SearchSysCacheList1(cacheId, key1)
Definition: syscache.h:210
#define ereport(elevel, rest)
Definition: elog.h:141
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:1116
FormData_pg_opfamily * Form_pg_opfamily
Definition: pg_opfamily.h:51
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:1164
char * format_procedure(Oid procedure_oid)
Definition: regproc.c:323
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define lfirst(lc)
Definition: pg_list.h:190
#define BRIN_PROCNUM_CONSISTENT
Definition: brin_internal.h:69
bool check_amop_signature(Oid opno, Oid restype, Oid lefttype, Oid righttype)
Definition: amvalidate.c:194
#define BRIN_FIRST_OPTIONAL_PROCNUM
Definition: brin_internal.h:73
#define BRIN_LAST_OPTIONAL_PROCNUM
Definition: brin_internal.h:74
#define BRIN_PROCNUM_UNION
Definition: brin_internal.h:70
int errmsg(const char *fmt,...)
Definition: elog.c:822
FormData_pg_amop * Form_pg_amop
Definition: pg_amop.h:88
#define elog(elevel,...)
Definition: elog.h:228
int i
#define NameStr(name)
Definition: c.h:616
HeapTupleData tuple
Definition: catcache.h:121
FormData_pg_opclass * Form_pg_opclass
Definition: pg_opclass.h:83
Definition: pg_list.h:50