PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
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

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

Definition at line 73 of file brin_internal.h.

Referenced by brinvalidate().

#define BRIN_LAST_OPTIONAL_PROCNUM   15

Definition at line 74 of file brin_internal.h.

Referenced by brinhandler(), and brinvalidate().

#define BRIN_MANDATORY_NPROCS   4

Definition at line 71 of file brin_internal.h.

Referenced by brinvalidate().

#define BRIN_PROCNUM_ADDVALUE   2

Definition at line 68 of file brin_internal.h.

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

#define BRIN_PROCNUM_CONSISTENT   3

Definition at line 69 of file brin_internal.h.

Referenced by bringetbitmap(), and brinvalidate().

#define BRIN_PROCNUM_OPCINFO   1

Definition at line 67 of file brin_internal.h.

Referenced by brin_build_desc(), and brinvalidate().

#define BRIN_PROCNUM_UNION   4

Definition at line 70 of file brin_internal.h.

Referenced by brinvalidate(), and union_tuples().

#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

Function Documentation

BrinDesc* brin_build_desc ( Relation  rel)

Definition at line 997 of file brin.c.

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate(), tupleDesc::attrs, 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(), tupleDesc::natts, NULL, offsetof, BrinOpcInfo::oi_nstored, palloc(), pfree(), RelationGetDescr, and totalsize.

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

998 {
999  BrinOpcInfo **opcinfo;
1000  BrinDesc *bdesc;
1001  TupleDesc tupdesc;
1002  int totalstored = 0;
1003  int keyno;
1004  long totalsize;
1005  MemoryContext cxt;
1006  MemoryContext oldcxt;
1007 
1009  "brin desc cxt",
1011  oldcxt = MemoryContextSwitchTo(cxt);
1012  tupdesc = RelationGetDescr(rel);
1013 
1014  /*
1015  * Obtain BrinOpcInfo for each indexed column. While at it, accumulate
1016  * the number of columns stored, since the number is opclass-defined.
1017  */
1018  opcinfo = (BrinOpcInfo **) palloc(sizeof(BrinOpcInfo *) * tupdesc->natts);
1019  for (keyno = 0; keyno < tupdesc->natts; keyno++)
1020  {
1021  FmgrInfo *opcInfoFn;
1022 
1023  opcInfoFn = index_getprocinfo(rel, keyno + 1, BRIN_PROCNUM_OPCINFO);
1024 
1025  opcinfo[keyno] = (BrinOpcInfo *)
1026  DatumGetPointer(FunctionCall1(opcInfoFn,
1027  tupdesc->attrs[keyno]->atttypid));
1028  totalstored += opcinfo[keyno]->oi_nstored;
1029  }
1030 
1031  /* Allocate our result struct and fill it in */
1032  totalsize = offsetof(BrinDesc, bd_info) +
1033  sizeof(BrinOpcInfo *) * tupdesc->natts;
1034 
1035  bdesc = palloc(totalsize);
1036  bdesc->bd_context = cxt;
1037  bdesc->bd_index = rel;
1038  bdesc->bd_tupdesc = tupdesc;
1039  bdesc->bd_disktdesc = NULL; /* generated lazily */
1040  bdesc->bd_totalstored = totalstored;
1041 
1042  for (keyno = 0; keyno < tupdesc->natts; keyno++)
1043  bdesc->bd_info[keyno] = opcinfo[keyno];
1044  pfree(opcinfo);
1045 
1046  MemoryContextSwitchTo(oldcxt);
1047 
1048  return bdesc;
1049 }
Definition: fmgr.h:56
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:855
#define RelationGetDescr(relation)
Definition: rel.h:428
#define ALLOCSET_SMALL_SIZES
Definition: memutils.h:175
Form_pg_attribute * attrs
Definition: tupdesc.h:74
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
#define BRIN_PROCNUM_OPCINFO
Definition: brin_internal.h:67
int natts
Definition: tupdesc.h:73
void pfree(void *pointer)
Definition: mcxt.c:950
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
MemoryContext CurrentMemoryContext
Definition: mcxt.c:37
static uint64 totalsize
MemoryContext AllocSetContextCreate(MemoryContext parent, const char *name, Size minContextSize, Size initBlockSize, Size maxBlockSize)
Definition: aset.c:322
BrinOpcInfo * bd_info[FLEXIBLE_ARRAY_MEMBER]
Definition: brin_internal.h:59
#define NULL
Definition: c.h:229
#define DatumGetPointer(X)
Definition: postgres.h:555
MemoryContext bd_context
Definition: brin_internal.h:44
void * palloc(Size size)
Definition: mcxt.c:849
TupleDesc bd_disktdesc
Definition: brin_internal.h:53
#define FunctionCall1(flinfo, arg1)
Definition: fmgr.h:602
#define offsetof(type, field)
Definition: c.h:555
void brin_free_desc ( BrinDesc bdesc)

Definition at line 1052 of file brin.c.

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

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

1053 {
1054  /* make sure the tupdesc is still valid */
1055  Assert(bdesc->bd_tupdesc->tdrefcount >= 1);
1056  /* no need for retail pfree */
1058 }
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:200
TupleDesc bd_tupdesc
Definition: brin_internal.h:50
#define Assert(condition)
Definition: c.h:676
MemoryContext bd_context
Definition: brin_internal.h:44
int tdrefcount
Definition: tupdesc.h:80
IndexScanDesc brinbeginscan ( Relation  r,
int  nkeys,
int  norderbys 
)

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

325 {
326  IndexScanDesc scan;
327  BrinOpaque *opaque;
328 
329  scan = RelationGetIndexScan(r, nkeys, norderbys);
330 
331  opaque = (BrinOpaque *) palloc(sizeof(BrinOpaque));
332  opaque->bo_rmAccess = brinRevmapInitialize(r, &opaque->bo_pagesPerRange,
333  scan->xs_snapshot);
334  opaque->bo_bdesc = brin_build_desc(r);
335  scan->opaque = opaque;
336 
337  return scan;
338 }
Snapshot xs_snapshot
Definition: relscan.h:91
BlockNumber bo_pagesPerRange
Definition: brin.c:59
BrinRevmap * bo_rmAccess
Definition: brin.c:60
BrinDesc * bo_bdesc
Definition: brin.c:61
BrinDesc * brin_build_desc(Relation rel)
Definition: brin.c:997
BrinRevmap * brinRevmapInitialize(Relation idxrel, BlockNumber *pagesPerRange, Snapshot snapshot)
Definition: brin_revmap.c:71
void * palloc(Size size)
Definition: mcxt.c:849
IndexScanDesc RelationGetIndexScan(Relation indexRelation, int nkeys, int norderbys)
Definition: genam.c:78
IndexBuildResult* brinbuild ( Relation  heap,
Relation  index,
struct IndexInfo indexInfo 
)

Definition at line 645 of file brin.c.

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

Referenced by brinhandler().

646 {
648  double reltuples;
649  double idxtuples;
650  BrinRevmap *revmap;
652  Buffer meta;
653  BlockNumber pagesPerRange;
654 
655  /*
656  * We expect to be called exactly once for any index relation.
657  */
658  if (RelationGetNumberOfBlocks(index) != 0)
659  elog(ERROR, "index \"%s\" already contains data",
660  RelationGetRelationName(index));
661 
662  /*
663  * Critical section not required, because on error the creation of the
664  * whole relation will be rolled back.
665  */
666 
667  meta = ReadBuffer(index, P_NEW);
670 
673  MarkBufferDirty(meta);
674 
675  if (RelationNeedsWAL(index))
676  {
677  xl_brin_createidx xlrec;
678  XLogRecPtr recptr;
679  Page page;
680 
682  xlrec.pagesPerRange = BrinGetPagesPerRange(index);
683 
684  XLogBeginInsert();
685  XLogRegisterData((char *) &xlrec, SizeOfBrinCreateIdx);
687 
688  recptr = XLogInsert(RM_BRIN_ID, XLOG_BRIN_CREATE_INDEX);
689 
690  page = BufferGetPage(meta);
691  PageSetLSN(page, recptr);
692  }
693 
694  UnlockReleaseBuffer(meta);
695 
696  /*
697  * Initialize our state, including the deformed tuple state.
698  */
699  revmap = brinRevmapInitialize(index, &pagesPerRange, NULL);
700  state = initialize_brin_buildstate(index, revmap, pagesPerRange);
701 
702  /*
703  * Now scan the relation. No syncscan allowed here because we want the
704  * heap blocks in physical order.
705  */
706  reltuples = IndexBuildHeapScan(heap, index, indexInfo, false,
707  brinbuildCallback, (void *) state);
708 
709  /* process the final batch */
710  form_and_insert_tuple(state);
711 
712  /* release resources */
713  idxtuples = state->bs_numtuples;
716 
717  /*
718  * Return statistics
719  */
720  result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
721 
722  result->heap_tuples = reltuples;
723  result->index_tuples = idxtuples;
724 
725  return result;
726 }
#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:1450
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:32
static void brinbuildCallback(Relation index, HeapTuple htup, Datum *values, bool *isnull, bool tupleIsAlive, void *brstate)
Definition: brin.c:583
return result
Definition: formatting.c:1633
uint32 BlockNumber
Definition: block.h:31
static void form_and_insert_tuple(BrinBuildState *state)
Definition: brin.c:1337
#define P_NEW
Definition: bufmgr.h:82
#define BUFFER_LOCK_EXCLUSIVE
Definition: bufmgr.h:89
#define BrinGetPagesPerRange(relation)
Definition: brin.h:40
void brin_metapage_init(Page page, BlockNumber pagesPerRange, uint16 version)
Definition: brin_pageops.c:476
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3332
#define ERROR
Definition: elog.h:43
BrinRevmap * bs_rmAccess
Definition: brin.c:49
#define RelationGetRelationName(relation)
Definition: rel.h:436
#define BufferGetPage(buffer)
Definition: bufmgr.h:160
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:3546
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:199
#define NULL
Definition: c.h:229
uint64 XLogRecPtr
Definition: xlogdefs.h:21
#define Assert(condition)
Definition: c.h:676
Definition: regguts.h:298
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
Definition: bufmgr.c:594
BrinRevmap * brinRevmapInitialize(Relation idxrel, BlockNumber *pagesPerRange, Snapshot snapshot)
Definition: brin_revmap.c:71
#define RelationNeedsWAL(relation)
Definition: rel.h:505
int bs_numtuples
Definition: brin.c:45
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:2605
double IndexBuildHeapScan(Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo, bool allow_sync, IndexBuildCallback callback, void *callback_state)
Definition: index.c:2172
void * palloc(Size size)
Definition: mcxt.c:849
BlockNumber pagesPerRange
Definition: brin_xlog.h:52
static BrinBuildState * initialize_brin_buildstate(Relation idxRel, BrinRevmap *revmap, BlockNumber pagesPerRange)
Definition: brin.c:1085
#define elog
Definition: elog.h:219
void XLogBeginInsert(void)
Definition: xloginsert.c:120
#define PageSetLSN(page, lsn)
Definition: bufpage.h:364
int Buffer
Definition: buf.h:23
Pointer Page
Definition: bufpage.h:74
double index_tuples
Definition: genam.h:33
double heap_tuples
Definition: genam.h:32
static void terminate_brin_buildstate(BrinBuildState *state)
Definition: brin.c:1110
void brinbuildempty ( Relation  index)

Definition at line 729 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(), NULL, P_NEW, RBM_NORMAL, ReadBufferExtended(), START_CRIT_SECTION, and UnlockReleaseBuffer().

Referenced by brinhandler().

730 {
731  Buffer metabuf;
732 
733  /* An empty BRIN index has a metapage only. */
734  metabuf =
737 
738  /* Initialize and xlog metabuffer. */
742  MarkBufferDirty(metabuf);
743  log_newpage_buffer(metabuf, false);
745 
746  UnlockReleaseBuffer(metabuf);
747 }
#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:1450
Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy)
Definition: bufmgr.c:640
#define END_CRIT_SECTION()
Definition: miscadmin.h:133
#define START_CRIT_SECTION()
Definition: miscadmin.h:131
#define P_NEW
Definition: bufmgr.h:82
#define BUFFER_LOCK_EXCLUSIVE
Definition: bufmgr.h:89
#define BrinGetPagesPerRange(relation)
Definition: brin.h:40
void brin_metapage_init(Page page, BlockNumber pagesPerRange, uint16 version)
Definition: brin_pageops.c:476
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3332
#define BufferGetPage(buffer)
Definition: bufmgr.h:160
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:3546
#define NULL
Definition: c.h:229
int Buffer
Definition: buf.h:23
IndexBulkDeleteResult* brinbulkdelete ( IndexVacuumInfo info,
IndexBulkDeleteResult stats,
IndexBulkDeleteCallback  callback,
void *  callback_state 
)

Definition at line 759 of file brin.c.

References NULL, and palloc0().

Referenced by brinhandler().

761 {
762  /* allocate stats if first time through, else re-use existing struct */
763  if (stats == NULL)
765 
766  return stats;
767 }
void * palloc0(Size size)
Definition: mcxt.c:878
#define NULL
Definition: c.h:229
void brinendscan ( IndexScanDesc  scan)

Definition at line 566 of file brin.c.

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

Referenced by brinhandler().

567 {
568  BrinOpaque *opaque = (BrinOpaque *) scan->opaque;
569 
571  brin_free_desc(opaque->bo_bdesc);
572  pfree(opaque);
573 }
void brin_free_desc(BrinDesc *bdesc)
Definition: brin.c:1052
void brinRevmapTerminate(BrinRevmap *revmap)
Definition: brin_revmap.c:103
void pfree(void *pointer)
Definition: mcxt.c:950
BrinRevmap * bo_rmAccess
Definition: brin.c:60
BrinDesc * bo_bdesc
Definition: brin.c:61
int64 bringetbitmap ( IndexScanDesc  scan,
TIDBitmap tbm 
)

Definition at line 353 of file brin.c.

References AccessShareLock, addrange(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate(), Assert, tupleDesc::attrs, 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(), heap_close, heap_open(), index_getprocinfo(), IndexGetRelation(), IndexScanDescData::indexRelation, InvalidBuffer, InvalidOid, IndexScanDescData::keyData, LockBuffer(), MemoryContextDelete(), MemoryContextResetAndDeleteChildren, MemoryContextSwitchTo(), tupleDesc::natts, NULL, IndexScanDescData::numberOfKeys, IndexScanDescData::opaque, palloc0(), pgstat_count_index_scan, PointerGetDatum, RelationGetNumberOfBlocks, RelationGetRelid, ReleaseBuffer(), ScanKeyData::sk_attno, ScanKeyData::sk_collation, ScanKeyData::sk_flags, SK_ISNULL, tbm_add_page(), and IndexScanDescData::xs_snapshot.

Referenced by brinhandler().

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

Definition at line 139 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, FirstOffsetNumber, FunctionCall4Coll(), IndexInfo::ii_AmCache, IndexInfo::ii_Context, index_getprocinfo(), InvalidBuffer, ItemIdGetLength, ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, LockBuffer(), MemoryContextDelete(), MemoryContextResetAndDeleteChildren, MemoryContextSwitchTo(), tupleDesc::natts, NULL, PageGetItemId, PointerGetDatum, RelationData::rd_indcollation, RelationGetRelid, ReleaseBuffer(), and result.

Referenced by brinhandler().

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

Definition at line 804 of file brin.c.

References allocateReloptStruct(), fillRelOptions(), lengthof, NULL, offsetof, options, parseRelOptions(), pfree(), RELOPT_KIND_BRIN, RELOPT_TYPE_BOOL, and RELOPT_TYPE_INT.

Referenced by brinhandler().

805 {
807  BrinOptions *rdopts;
808  int numoptions;
809  static const relopt_parse_elt tab[] = {
810  {"pages_per_range", RELOPT_TYPE_INT, offsetof(BrinOptions, pagesPerRange)},
811  {"autosummarize", RELOPT_TYPE_BOOL, offsetof(BrinOptions, autosummarize)}
812  };
813 
814  options = parseRelOptions(reloptions, validate, RELOPT_KIND_BRIN,
815  &numoptions);
816 
817  /* if none set, we're done */
818  if (numoptions == 0)
819  return NULL;
820 
821  rdopts = allocateReloptStruct(sizeof(BrinOptions), options, numoptions);
822 
823  fillRelOptions((void *) rdopts, sizeof(BrinOptions), options, numoptions,
824  validate, tab, lengthof(tab));
825 
826  pfree(options);
827 
828  return (bytea *) rdopts;
829 }
#define lengthof(array)
Definition: c.h:562
void pfree(void *pointer)
Definition: mcxt.c:950
void * allocateReloptStruct(Size base, relopt_value *options, int numoptions)
Definition: reloptions.c:1215
static char ** options
void fillRelOptions(void *rdopts, Size basesize, relopt_value *options, int numoptions, bool validate, const relopt_parse_elt *elems, int numelems)
Definition: reloptions.c:1239
#define NULL
Definition: c.h:229
Definition: c.h:439
relopt_value * parseRelOptions(Datum options, bool validate, relopt_kind kind, int *numrelopts)
Definition: reloptions.c:1020
#define offsetof(type, field)
Definition: c.h:555
void brinrescan ( IndexScanDesc  scan,
ScanKey  scankey,
int  nscankeys,
ScanKey  orderbys,
int  norderbys 
)

Definition at line 546 of file brin.c.

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

Referenced by brinhandler().

548 {
549  /*
550  * Other index AMs preprocess the scan keys at this point, or sometime
551  * early during the scan; this lets them optimize by removing redundant
552  * keys, or doing early returns when they are impossible to satisfy; see
553  * _bt_preprocess_keys for an example. Something like that could be added
554  * here someday, too.
555  */
556 
557  if (scankey && scan->numberOfKeys > 0)
558  memmove(scan->keyData, scankey,
559  scan->numberOfKeys * sizeof(ScanKeyData));
560 }
#define memmove(d, s, c)
Definition: c.h:1059
ScanKey keyData
Definition: relscan.h:94
IndexBulkDeleteResult* brinvacuumcleanup ( IndexVacuumInfo info,
IndexBulkDeleteResult stats 
)

Definition at line 774 of file brin.c.

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

Referenced by brinhandler().

775 {
776  Relation heapRel;
777 
778  /* No-op in ANALYZE ONLY mode */
779  if (info->analyze_only)
780  return stats;
781 
782  if (!stats)
784  stats->num_pages = RelationGetNumberOfBlocks(info->index);
785  /* rest of stats is initialized by zeroing */
786 
787  heapRel = heap_open(IndexGetRelation(RelationGetRelid(info->index), false),
789 
790  brin_vacuum_scan(info->index, info->strategy);
791 
792  brinsummarize(info->index, heapRel, BRIN_ALL_BLOCKRANGES,
793  &stats->num_index_tuples, &stats->num_index_tuples);
794 
795  heap_close(heapRel, AccessShareLock);
796 
797  return stats;
798 }
Oid IndexGetRelation(Oid indexId, bool missing_ok)
Definition: index.c:3278
bool analyze_only
Definition: genam.h:47
BufferAccessStrategy strategy
Definition: genam.h:51
#define AccessShareLock
Definition: lockdefs.h:36
Relation index
Definition: genam.h:46
#define heap_close(r, l)
Definition: heapam.h:97
BlockNumber num_pages
Definition: genam.h:73
static void brin_vacuum_scan(Relation idxrel, BufferAccessStrategy strategy)
Definition: brin.c:1399
void * palloc0(Size size)
Definition: mcxt.c:878
Relation heap_open(Oid relationId, LOCKMODE lockmode)
Definition: heapam.c:1290
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:199
static void brinsummarize(Relation index, Relation heapRel, BlockNumber pageRange, double *numSummarized, double *numExisting)
Definition: brin.c:1241
#define BRIN_ALL_BLOCKRANGES
Definition: brin.c:64
double num_index_tuples
Definition: genam.h:76
#define RelationGetRelid(relation)
Definition: rel.h:416
bool brinvalidate ( Oid  opclassoid)

Definition at line 38 of file brin_validate.c.

References AMOP_SEARCH, AMOPSTRATEGY, AMPROCNUM, BOOLOID, 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, INTERNALOID, OpFamilyOpFuncGroup::lefttype, lfirst, catclist::members, catclist::n_members, NameStr, NULL, ObjectIdGetDatum, OidIsValid, OpFamilyOpFuncGroup::operatorset, OPFAMILYOID, ReleaseCatCacheList(), ReleaseSysCache(), result, OpFamilyOpFuncGroup::righttype, SearchSysCache1, SearchSysCacheList1, and catctup::tuple.

Referenced by brinhandler().

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