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_PROCNUM_OPTIONS   5 /* optional */
 
#define BRIN_FIRST_OPTIONAL_PROCNUM   11
 
#define BRIN_LAST_OPTIONAL_PROCNUM   15
 
#define BRIN_elog(args)   ((void) 0)
 

Typedefs

typedef struct BrinOpcInfo BrinOpcInfo
 
typedef struct BrinDesc BrinDesc
 

Functions

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, bool indexUnchanged, struct IndexInfo *indexInfo)
 
void brininsertcleanup (Relation index, 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)

Definition at line 85 of file brin_internal.h.

◆ BRIN_FIRST_OPTIONAL_PROCNUM

#define BRIN_FIRST_OPTIONAL_PROCNUM   11

Definition at line 77 of file brin_internal.h.

◆ BRIN_LAST_OPTIONAL_PROCNUM

#define BRIN_LAST_OPTIONAL_PROCNUM   15

Definition at line 78 of file brin_internal.h.

◆ BRIN_MANDATORY_NPROCS

#define BRIN_MANDATORY_NPROCS   4

Definition at line 74 of file brin_internal.h.

◆ BRIN_PROCNUM_ADDVALUE

#define BRIN_PROCNUM_ADDVALUE   2

Definition at line 71 of file brin_internal.h.

◆ BRIN_PROCNUM_CONSISTENT

#define BRIN_PROCNUM_CONSISTENT   3

Definition at line 72 of file brin_internal.h.

◆ BRIN_PROCNUM_OPCINFO

#define BRIN_PROCNUM_OPCINFO   1

Definition at line 70 of file brin_internal.h.

◆ BRIN_PROCNUM_OPTIONS

#define BRIN_PROCNUM_OPTIONS   5 /* optional */

Definition at line 75 of file brin_internal.h.

◆ BRIN_PROCNUM_UNION

#define BRIN_PROCNUM_UNION   4

Definition at line 73 of file brin_internal.h.

◆ SizeofBrinOpcInfo

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

Definition at line 41 of file brin_internal.h.

Typedef Documentation

◆ BrinDesc

typedef struct BrinDesc BrinDesc

◆ BrinOpcInfo

typedef struct BrinOpcInfo BrinOpcInfo

Function Documentation

◆ brin_build_desc()

BrinDesc* brin_build_desc ( Relation  rel)

Definition at line 1570 of file brin.c.

1571 {
1572  BrinOpcInfo **opcinfo;
1573  BrinDesc *bdesc;
1574  TupleDesc tupdesc;
1575  int totalstored = 0;
1576  int keyno;
1577  long totalsize;
1578  MemoryContext cxt;
1579  MemoryContext oldcxt;
1580 
1582  "brin desc cxt",
1584  oldcxt = MemoryContextSwitchTo(cxt);
1585  tupdesc = RelationGetDescr(rel);
1586 
1587  /*
1588  * Obtain BrinOpcInfo for each indexed column. While at it, accumulate
1589  * the number of columns stored, since the number is opclass-defined.
1590  */
1591  opcinfo = palloc_array(BrinOpcInfo *, tupdesc->natts);
1592  for (keyno = 0; keyno < tupdesc->natts; keyno++)
1593  {
1594  FmgrInfo *opcInfoFn;
1595  Form_pg_attribute attr = TupleDescAttr(tupdesc, keyno);
1596 
1597  opcInfoFn = index_getprocinfo(rel, keyno + 1, BRIN_PROCNUM_OPCINFO);
1598 
1599  opcinfo[keyno] = (BrinOpcInfo *)
1600  DatumGetPointer(FunctionCall1(opcInfoFn, attr->atttypid));
1601  totalstored += opcinfo[keyno]->oi_nstored;
1602  }
1603 
1604  /* Allocate our result struct and fill it in */
1605  totalsize = offsetof(BrinDesc, bd_info) +
1606  sizeof(BrinOpcInfo *) * tupdesc->natts;
1607 
1608  bdesc = palloc(totalsize);
1609  bdesc->bd_context = cxt;
1610  bdesc->bd_index = rel;
1611  bdesc->bd_tupdesc = tupdesc;
1612  bdesc->bd_disktdesc = NULL; /* generated lazily */
1613  bdesc->bd_totalstored = totalstored;
1614 
1615  for (keyno = 0; keyno < tupdesc->natts; keyno++)
1616  bdesc->bd_info[keyno] = opcinfo[keyno];
1617  pfree(opcinfo);
1618 
1619  MemoryContextSwitchTo(oldcxt);
1620 
1621  return bdesc;
1622 }
#define BRIN_PROCNUM_OPCINFO
Definition: brin_internal.h:70
#define palloc_array(type, count)
Definition: fe_memutils.h:64
#define FunctionCall1(flinfo, arg1)
Definition: fmgr.h:660
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:860
void pfree(void *pointer)
Definition: mcxt.c:1520
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
void * palloc(Size size)
Definition: mcxt.c:1316
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_SMALL_SIZES
Definition: memutils.h:170
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:209
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312
MemoryContextSwitchTo(old_ctx)
#define RelationGetDescr(relation)
Definition: rel.h:531
int bd_totalstored
Definition: brin_internal.h:59
TupleDesc bd_tupdesc
Definition: brin_internal.h:53
BrinOpcInfo * bd_info[FLEXIBLE_ARRAY_MEMBER]
Definition: brin_internal.h:62
Relation bd_index
Definition: brin_internal.h:50
MemoryContext bd_context
Definition: brin_internal.h:47
TupleDesc bd_disktdesc
Definition: brin_internal.h:56
uint16 oi_nstored
Definition: brin_internal.h:28
Definition: fmgr.h:57
#define TupleDescAttr(tupdesc, i)
Definition: tupdesc.h:92

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

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

◆ brin_free_desc()

void brin_free_desc ( BrinDesc bdesc)

Definition at line 1625 of file brin.c.

1626 {
1627  /* make sure the tupdesc is still valid */
1628  Assert(bdesc->bd_tupdesc->tdrefcount >= 1);
1629  /* no need for retail pfree */
1631 }
#define Assert(condition)
Definition: c.h:858
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:454
int tdrefcount
Definition: tupdesc.h:84

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

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

◆ brinbeginscan()

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

Definition at line 528 of file brin.c.

529 {
530  IndexScanDesc scan;
531  BrinOpaque *opaque;
532 
533  scan = RelationGetIndexScan(r, nkeys, norderbys);
534 
535  opaque = palloc_object(BrinOpaque);
536  opaque->bo_rmAccess = brinRevmapInitialize(r, &opaque->bo_pagesPerRange);
537  opaque->bo_bdesc = brin_build_desc(r);
538  scan->opaque = opaque;
539 
540  return scan;
541 }
BrinDesc * brin_build_desc(Relation rel)
Definition: brin.c:1570
BrinRevmap * brinRevmapInitialize(Relation idxrel, BlockNumber *pagesPerRange)
Definition: brin_revmap.c:70
#define palloc_object(type)
Definition: fe_memutils.h:62
IndexScanDesc RelationGetIndexScan(Relation indexRelation, int nkeys, int norderbys)
Definition: genam.c:78
BlockNumber bo_pagesPerRange
Definition: brin.c:201
BrinDesc * bo_bdesc
Definition: brin.c:203
BrinRevmap * bo_rmAccess
Definition: brin.c:202

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

Referenced by brinhandler().

◆ brinbuild()

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

Definition at line 1093 of file brin.c.

1094 {
1095  IndexBuildResult *result;
1096  double reltuples;
1097  double idxtuples;
1098  BrinRevmap *revmap;
1100  Buffer meta;
1101  BlockNumber pagesPerRange;
1102 
1103  /*
1104  * We expect to be called exactly once for any index relation.
1105  */
1106  if (RelationGetNumberOfBlocks(index) != 0)
1107  elog(ERROR, "index \"%s\" already contains data",
1109 
1110  /*
1111  * Critical section not required, because on error the creation of the
1112  * whole relation will be rolled back.
1113  */
1114 
1118 
1121  MarkBufferDirty(meta);
1122 
1123  if (RelationNeedsWAL(index))
1124  {
1125  xl_brin_createidx xlrec;
1126  XLogRecPtr recptr;
1127  Page page;
1128 
1129  xlrec.version = BRIN_CURRENT_VERSION;
1131 
1132  XLogBeginInsert();
1133  XLogRegisterData((char *) &xlrec, SizeOfBrinCreateIdx);
1135 
1136  recptr = XLogInsert(RM_BRIN_ID, XLOG_BRIN_CREATE_INDEX);
1137 
1138  page = BufferGetPage(meta);
1139  PageSetLSN(page, recptr);
1140  }
1141 
1142  UnlockReleaseBuffer(meta);
1143 
1144  /*
1145  * Initialize our state, including the deformed tuple state.
1146  */
1147  revmap = brinRevmapInitialize(index, &pagesPerRange);
1148  state = initialize_brin_buildstate(index, revmap, pagesPerRange,
1150 
1151  /*
1152  * Attempt to launch parallel worker scan when required
1153  *
1154  * XXX plan_create_index_workers makes the number of workers dependent on
1155  * maintenance_work_mem, requiring 32MB for each worker. That makes sense
1156  * for btree, but not for BRIN, which can do with much less memory. So
1157  * maybe make that somehow less strict, optionally?
1158  */
1159  if (indexInfo->ii_ParallelWorkers > 0)
1160  _brin_begin_parallel(state, heap, index, indexInfo->ii_Concurrent,
1161  indexInfo->ii_ParallelWorkers);
1162 
1163  /*
1164  * If parallel build requested and at least one worker process was
1165  * successfully launched, set up coordination state, wait for workers to
1166  * complete. Then read all tuples from the shared tuplesort and insert
1167  * them into the index.
1168  *
1169  * In serial mode, simply scan the table and build the index one index
1170  * tuple at a time.
1171  */
1172  if (state->bs_leader)
1173  {
1174  SortCoordinate coordinate;
1175 
1176  coordinate = (SortCoordinate) palloc0(sizeof(SortCoordinateData));
1177  coordinate->isWorker = false;
1178  coordinate->nParticipants =
1179  state->bs_leader->nparticipanttuplesorts;
1180  coordinate->sharedsort = state->bs_leader->sharedsort;
1181 
1182  /*
1183  * Begin leader tuplesort.
1184  *
1185  * In cases where parallelism is involved, the leader receives the
1186  * same share of maintenance_work_mem as a serial sort (it is
1187  * generally treated in the same way as a serial sort once we return).
1188  * Parallel worker Tuplesortstates will have received only a fraction
1189  * of maintenance_work_mem, though.
1190  *
1191  * We rely on the lifetime of the Leader Tuplesortstate almost not
1192  * overlapping with any worker Tuplesortstate's lifetime. There may
1193  * be some small overlap, but that's okay because we rely on leader
1194  * Tuplesortstate only allocating a small, fixed amount of memory
1195  * here. When its tuplesort_performsort() is called (by our caller),
1196  * and significant amounts of memory are likely to be used, all
1197  * workers must have already freed almost all memory held by their
1198  * Tuplesortstates (they are about to go away completely, too). The
1199  * overall effect is that maintenance_work_mem always represents an
1200  * absolute high watermark on the amount of memory used by a CREATE
1201  * INDEX operation, regardless of the use of parallelism or any other
1202  * factor.
1203  */
1204  state->bs_sortstate =
1206  TUPLESORT_NONE);
1207 
1208  /* scan the relation and merge per-worker results */
1209  reltuples = _brin_parallel_merge(state);
1210 
1211  _brin_end_parallel(state->bs_leader, state);
1212  }
1213  else /* no parallel index build */
1214  {
1215  /*
1216  * Now scan the relation. No syncscan allowed here because we want
1217  * the heap blocks in physical order (we want to produce the ranges
1218  * starting from block 0, and the callback also relies on this to not
1219  * generate summary for the same range twice).
1220  */
1221  reltuples = table_index_build_scan(heap, index, indexInfo, false, true,
1222  brinbuildCallback, (void *) state, NULL);
1223 
1224  /*
1225  * process the final batch
1226  *
1227  * XXX Note this does not update state->bs_currRangeStart, i.e. it
1228  * stays set to the last range added to the index. This is OK, because
1229  * that's what brin_fill_empty_ranges expects.
1230  */
1232 
1233  /*
1234  * Backfill the final ranges with empty data.
1235  *
1236  * This saves us from doing what amounts to full table scans when the
1237  * index with a predicate like WHERE (nonnull_column IS NULL), or
1238  * other very selective predicates.
1239  */
1241  state->bs_currRangeStart,
1242  state->bs_maxRangeStart);
1243  }
1244 
1245  /* release resources */
1246  idxtuples = state->bs_numtuples;
1247  brinRevmapTerminate(state->bs_rmAccess);
1249 
1250  /*
1251  * Return statistics
1252  */
1253  result = palloc_object(IndexBuildResult);
1254 
1255  result->heap_tuples = reltuples;
1256  result->index_tuples = idxtuples;
1257 
1258  return result;
1259 }
uint32 BlockNumber
Definition: block.h:31
static double _brin_parallel_merge(BrinBuildState *state)
Definition: brin.c:2608
static void terminate_brin_buildstate(BrinBuildState *state)
Definition: brin.c:1705
static void form_and_insert_tuple(BrinBuildState *state)
Definition: brin.c:1974
static BrinBuildState * initialize_brin_buildstate(Relation idxRel, BrinRevmap *revmap, BlockNumber pagesPerRange, BlockNumber tablePages)
Definition: brin.c:1658
static void _brin_begin_parallel(BrinBuildState *buildstate, Relation heap, Relation index, bool isconcurrent, int request)
Definition: brin.c:2352
static void _brin_end_parallel(BrinLeader *brinleader, BrinBuildState *state)
Definition: brin.c:2536
static void brin_fill_empty_ranges(BrinBuildState *state, BlockNumber prevRange, BlockNumber nextRange)
Definition: brin.c:2978
static void brinbuildCallback(Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *brstate)
Definition: brin.c:983
#define BrinGetPagesPerRange(relation)
Definition: brin.h:40
#define BRIN_CURRENT_VERSION
Definition: brin_page.h:72
#define BRIN_METAPAGE_BLKNO
Definition: brin_page.h:75
void brin_metapage_init(Page page, BlockNumber pagesPerRange, uint16 version)
Definition: brin_pageops.c:486
void brinRevmapTerminate(BrinRevmap *revmap)
Definition: brin_revmap.c:100
#define SizeOfBrinCreateIdx
Definition: brin_xlog.h:55
#define XLOG_BRIN_CREATE_INDEX
Definition: brin_xlog.h:31
int Buffer
Definition: buf.h:23
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:3713
Buffer ExtendBufferedRel(BufferManagerRelation bmr, ForkNumber forkNum, BufferAccessStrategy strategy, uint32 flags)
Definition: bufmgr.c:845
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:4913
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:2520
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:277
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:404
@ EB_SKIP_EXTENSION_LOCK
Definition: bufmgr.h:74
@ EB_LOCK_FIRST
Definition: bufmgr.h:86
#define BMR_REL(p_rel)
Definition: bufmgr.h:107
Pointer Page
Definition: bufpage.h:78
static void PageSetLSN(Page page, XLogRecPtr lsn)
Definition: bufpage.h:388
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
int maintenance_work_mem
Definition: globals.c:130
void * palloc0(Size size)
Definition: mcxt.c:1346
#define RelationGetRelationName(relation)
Definition: rel.h:539
#define RelationNeedsWAL(relation)
Definition: rel.h:628
@ MAIN_FORKNUM
Definition: relpath.h:50
double heap_tuples
Definition: genam.h:32
double index_tuples
Definition: genam.h:33
int ii_ParallelWorkers
Definition: execnodes.h:205
bool ii_Concurrent
Definition: execnodes.h:202
Sharedsort * sharedsort
Definition: tuplesort.h:58
Definition: type.h:95
Definition: regguts.h:323
BlockNumber pagesPerRange
Definition: brin_xlog.h:52
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:1785
struct SortCoordinateData * SortCoordinate
Definition: tuplesort.h:61
#define TUPLESORT_NONE
Definition: tuplesort.h:93
Tuplesortstate * tuplesort_begin_index_brin(int workMem, SortCoordinate coordinate, int sortopt)
uint64 XLogRecPtr
Definition: xlogdefs.h:21
void XLogRegisterData(char *data, uint32 len)
Definition: xloginsert.c:364
XLogRecPtr XLogInsert(RmgrId rmid, uint8 info)
Definition: xloginsert.c:474
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
Definition: xloginsert.c:242
void XLogBeginInsert(void)
Definition: xloginsert.c:149
#define REGBUF_STANDARD
Definition: xloginsert.h:34
#define REGBUF_WILL_INIT
Definition: xloginsert.h:33

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

Referenced by brinhandler().

◆ brinbuildempty()

void brinbuildempty ( Relation  index)

Definition at line 1262 of file brin.c.

1263 {
1264  Buffer metabuf;
1265 
1266  /* An empty BRIN index has a metapage only. */
1267  metabuf = ExtendBufferedRel(BMR_REL(index), INIT_FORKNUM, NULL,
1269 
1270  /* Initialize and xlog metabuffer. */
1274  MarkBufferDirty(metabuf);
1275  log_newpage_buffer(metabuf, true);
1276  END_CRIT_SECTION();
1277 
1278  UnlockReleaseBuffer(metabuf);
1279 }
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
@ INIT_FORKNUM
Definition: relpath.h:53
XLogRecPtr log_newpage_buffer(Buffer buffer, bool page_std)
Definition: xloginsert.c:1237

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

Referenced by brinhandler().

◆ brinbulkdelete()

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

Definition at line 1291 of file brin.c.

1293 {
1294  /* allocate stats if first time through, else re-use existing struct */
1295  if (stats == NULL)
1297 
1298  return stats;
1299 }
#define palloc0_object(type)
Definition: fe_memutils.h:63

References palloc0_object.

Referenced by brinhandler().

◆ brinendscan()

void brinendscan ( IndexScanDesc  scan)

Definition at line 966 of file brin.c.

967 {
968  BrinOpaque *opaque = (BrinOpaque *) scan->opaque;
969 
971  brin_free_desc(opaque->bo_bdesc);
972  pfree(opaque);
973 }
void brin_free_desc(BrinDesc *bdesc)
Definition: brin.c:1625

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

Referenced by brinhandler().

◆ bringetbitmap()

int64 bringetbitmap ( IndexScanDesc  scan,
TIDBitmap tbm 
)

Definition at line 556 of file brin.c.

557 {
558  Relation idxRel = scan->indexRelation;
560  BrinDesc *bdesc;
561  Oid heapOid;
562  Relation heapRel;
563  BrinOpaque *opaque;
564  BlockNumber nblocks;
565  BlockNumber heapBlk;
566  int totalpages = 0;
567  FmgrInfo *consistentFn;
568  MemoryContext oldcxt;
569  MemoryContext perRangeCxt;
570  BrinMemTuple *dtup;
571  BrinTuple *btup = NULL;
572  Size btupsz = 0;
573  ScanKey **keys,
574  **nullkeys;
575  int *nkeys,
576  *nnullkeys;
577  char *ptr;
578  Size len;
579  char *tmp PG_USED_FOR_ASSERTS_ONLY;
580 
581  opaque = (BrinOpaque *) scan->opaque;
582  bdesc = opaque->bo_bdesc;
583  pgstat_count_index_scan(idxRel);
584 
585  /*
586  * We need to know the size of the table so that we know how long to
587  * iterate on the revmap.
588  */
589  heapOid = IndexGetRelation(RelationGetRelid(idxRel), false);
590  heapRel = table_open(heapOid, AccessShareLock);
591  nblocks = RelationGetNumberOfBlocks(heapRel);
592  table_close(heapRel, AccessShareLock);
593 
594  /*
595  * Make room for the consistent support procedures of indexed columns. We
596  * don't look them up here; we do that lazily the first time we see a scan
597  * key reference each of them. We rely on zeroing fn_oid to InvalidOid.
598  */
599  consistentFn = palloc0_array(FmgrInfo, bdesc->bd_tupdesc->natts);
600 
601  /*
602  * Make room for per-attribute lists of scan keys that we'll pass to the
603  * consistent support procedure. We don't know which attributes have scan
604  * keys, so we allocate space for all attributes. That may use more memory
605  * but it's probably cheaper than determining which attributes are used.
606  *
607  * We keep null and regular keys separate, so that we can pass just the
608  * regular keys to the consistent function easily.
609  *
610  * To reduce the allocation overhead, we allocate one big chunk and then
611  * carve it into smaller arrays ourselves. All the pieces have exactly the
612  * same lifetime, so that's OK.
613  *
614  * XXX The widest index can have 32 attributes, so the amount of wasted
615  * memory is negligible. We could invent a more compact approach (with
616  * just space for used attributes) but that would make the matching more
617  * complex so it's not a good trade-off.
618  */
619  len =
620  MAXALIGN(sizeof(ScanKey *) * bdesc->bd_tupdesc->natts) + /* regular keys */
621  MAXALIGN(sizeof(ScanKey) * scan->numberOfKeys) * bdesc->bd_tupdesc->natts +
622  MAXALIGN(sizeof(int) * bdesc->bd_tupdesc->natts) +
623  MAXALIGN(sizeof(ScanKey *) * bdesc->bd_tupdesc->natts) + /* NULL keys */
624  MAXALIGN(sizeof(ScanKey) * scan->numberOfKeys) * bdesc->bd_tupdesc->natts +
625  MAXALIGN(sizeof(int) * bdesc->bd_tupdesc->natts);
626 
627  ptr = palloc(len);
628  tmp = ptr;
629 
630  keys = (ScanKey **) ptr;
631  ptr += MAXALIGN(sizeof(ScanKey *) * bdesc->bd_tupdesc->natts);
632 
633  nullkeys = (ScanKey **) ptr;
634  ptr += MAXALIGN(sizeof(ScanKey *) * bdesc->bd_tupdesc->natts);
635 
636  nkeys = (int *) ptr;
637  ptr += MAXALIGN(sizeof(int) * bdesc->bd_tupdesc->natts);
638 
639  nnullkeys = (int *) ptr;
640  ptr += MAXALIGN(sizeof(int) * bdesc->bd_tupdesc->natts);
641 
642  for (int i = 0; i < bdesc->bd_tupdesc->natts; i++)
643  {
644  keys[i] = (ScanKey *) ptr;
645  ptr += MAXALIGN(sizeof(ScanKey) * scan->numberOfKeys);
646 
647  nullkeys[i] = (ScanKey *) ptr;
648  ptr += MAXALIGN(sizeof(ScanKey) * scan->numberOfKeys);
649  }
650 
651  Assert(tmp + len == ptr);
652 
653  /* zero the number of keys */
654  memset(nkeys, 0, sizeof(int) * bdesc->bd_tupdesc->natts);
655  memset(nnullkeys, 0, sizeof(int) * bdesc->bd_tupdesc->natts);
656 
657  /* Preprocess the scan keys - split them into per-attribute arrays. */
658  for (int keyno = 0; keyno < scan->numberOfKeys; keyno++)
659  {
660  ScanKey key = &scan->keyData[keyno];
661  AttrNumber keyattno = key->sk_attno;
662 
663  /*
664  * The collation of the scan key must match the collation used in the
665  * index column (but only if the search is not IS NULL/ IS NOT NULL).
666  * Otherwise we shouldn't be using this index ...
667  */
668  Assert((key->sk_flags & SK_ISNULL) ||
669  (key->sk_collation ==
670  TupleDescAttr(bdesc->bd_tupdesc,
671  keyattno - 1)->attcollation));
672 
673  /*
674  * First time we see this index attribute, so init as needed.
675  *
676  * This is a bit of an overkill - we don't know how many scan keys are
677  * there for this attribute, so we simply allocate the largest number
678  * possible (as if all keys were for this attribute). This may waste a
679  * bit of memory, but we only expect small number of scan keys in
680  * general, so this should be negligible, and repeated repalloc calls
681  * are not free either.
682  */
683  if (consistentFn[keyattno - 1].fn_oid == InvalidOid)
684  {
685  FmgrInfo *tmp;
686 
687  /* First time we see this attribute, so no key/null keys. */
688  Assert(nkeys[keyattno - 1] == 0);
689  Assert(nnullkeys[keyattno - 1] == 0);
690 
691  tmp = index_getprocinfo(idxRel, keyattno,
693  fmgr_info_copy(&consistentFn[keyattno - 1], tmp,
695  }
696 
697  /* Add key to the proper per-attribute array. */
698  if (key->sk_flags & SK_ISNULL)
699  {
700  nullkeys[keyattno - 1][nnullkeys[keyattno - 1]] = key;
701  nnullkeys[keyattno - 1]++;
702  }
703  else
704  {
705  keys[keyattno - 1][nkeys[keyattno - 1]] = key;
706  nkeys[keyattno - 1]++;
707  }
708  }
709 
710  /* allocate an initial in-memory tuple, out of the per-range memcxt */
711  dtup = brin_new_memtuple(bdesc);
712 
713  /*
714  * Setup and use a per-range memory context, which is reset every time we
715  * loop below. This avoids having to free the tuples within the loop.
716  */
718  "bringetbitmap cxt",
720  oldcxt = MemoryContextSwitchTo(perRangeCxt);
721 
722  /*
723  * Now scan the revmap. We start by querying for heap page 0,
724  * incrementing by the number of pages per range; this gives us a full
725  * view of the table.
726  */
727  for (heapBlk = 0; heapBlk < nblocks; heapBlk += opaque->bo_pagesPerRange)
728  {
729  bool addrange;
730  bool gottuple = false;
731  BrinTuple *tup;
732  OffsetNumber off;
733  Size size;
734 
736 
737  MemoryContextReset(perRangeCxt);
738 
739  tup = brinGetTupleForHeapBlock(opaque->bo_rmAccess, heapBlk, &buf,
740  &off, &size, BUFFER_LOCK_SHARE);
741  if (tup)
742  {
743  gottuple = true;
744  btup = brin_copy_tuple(tup, size, btup, &btupsz);
746  }
747 
748  /*
749  * For page ranges with no indexed tuple, we must return the whole
750  * range; otherwise, compare it to the scan keys.
751  */
752  if (!gottuple)
753  {
754  addrange = true;
755  }
756  else
757  {
758  dtup = brin_deform_tuple(bdesc, btup, dtup);
759  if (dtup->bt_placeholder)
760  {
761  /*
762  * Placeholder tuples are always returned, regardless of the
763  * values stored in them.
764  */
765  addrange = true;
766  }
767  else
768  {
769  int attno;
770 
771  /*
772  * Compare scan keys with summary values stored for the range.
773  * If scan keys are matched, the page range must be added to
774  * the bitmap. We initially assume the range needs to be
775  * added; in particular this serves the case where there are
776  * no keys.
777  */
778  addrange = true;
779  for (attno = 1; attno <= bdesc->bd_tupdesc->natts; attno++)
780  {
781  BrinValues *bval;
782  Datum add;
783  Oid collation;
784 
785  /*
786  * skip attributes without any scan keys (both regular and
787  * IS [NOT] NULL)
788  */
789  if (nkeys[attno - 1] == 0 && nnullkeys[attno - 1] == 0)
790  continue;
791 
792  bval = &dtup->bt_columns[attno - 1];
793 
794  /*
795  * If the BRIN tuple indicates that this range is empty,
796  * we can skip it: there's nothing to match. We don't
797  * need to examine the next columns.
798  */
799  if (dtup->bt_empty_range)
800  {
801  addrange = false;
802  break;
803  }
804 
805  /*
806  * First check if there are any IS [NOT] NULL scan keys,
807  * and if we're violating them. In that case we can
808  * terminate early, without invoking the support function.
809  *
810  * As there may be more keys, we can only determine
811  * mismatch within this loop.
812  */
813  if (bdesc->bd_info[attno - 1]->oi_regular_nulls &&
814  !check_null_keys(bval, nullkeys[attno - 1],
815  nnullkeys[attno - 1]))
816  {
817  /*
818  * If any of the IS [NOT] NULL keys failed, the page
819  * range as a whole can't pass. So terminate the loop.
820  */
821  addrange = false;
822  break;
823  }
824 
825  /*
826  * So either there are no IS [NOT] NULL keys, or all
827  * passed. If there are no regular scan keys, we're done -
828  * the page range matches. If there are regular keys, but
829  * the page range is marked as 'all nulls' it can't
830  * possibly pass (we're assuming the operators are
831  * strict).
832  */
833 
834  /* No regular scan keys - page range as a whole passes. */
835  if (!nkeys[attno - 1])
836  continue;
837 
838  Assert((nkeys[attno - 1] > 0) &&
839  (nkeys[attno - 1] <= scan->numberOfKeys));
840 
841  /* If it is all nulls, it cannot possibly be consistent. */
842  if (bval->bv_allnulls)
843  {
844  addrange = false;
845  break;
846  }
847 
848  /*
849  * Collation from the first key (has to be the same for
850  * all keys for the same attribute).
851  */
852  collation = keys[attno - 1][0]->sk_collation;
853 
854  /*
855  * Check whether the scan key is consistent with the page
856  * range values; if so, have the pages in the range added
857  * to the output bitmap.
858  *
859  * The opclass may or may not support processing of
860  * multiple scan keys. We can determine that based on the
861  * number of arguments - functions with extra parameter
862  * (number of scan keys) do support this, otherwise we
863  * have to simply pass the scan keys one by one.
864  */
865  if (consistentFn[attno - 1].fn_nargs >= 4)
866  {
867  /* Check all keys at once */
868  add = FunctionCall4Coll(&consistentFn[attno - 1],
869  collation,
870  PointerGetDatum(bdesc),
871  PointerGetDatum(bval),
872  PointerGetDatum(keys[attno - 1]),
873  Int32GetDatum(nkeys[attno - 1]));
874  addrange = DatumGetBool(add);
875  }
876  else
877  {
878  /*
879  * Check keys one by one
880  *
881  * When there are multiple scan keys, failure to meet
882  * the criteria for a single one of them is enough to
883  * discard the range as a whole, so break out of the
884  * loop as soon as a false return value is obtained.
885  */
886  int keyno;
887 
888  for (keyno = 0; keyno < nkeys[attno - 1]; keyno++)
889  {
890  add = FunctionCall3Coll(&consistentFn[attno - 1],
891  keys[attno - 1][keyno]->sk_collation,
892  PointerGetDatum(bdesc),
893  PointerGetDatum(bval),
894  PointerGetDatum(keys[attno - 1][keyno]));
895  addrange = DatumGetBool(add);
896  if (!addrange)
897  break;
898  }
899  }
900 
901  /*
902  * If we found a scan key eliminating the range, no need
903  * to check additional ones.
904  */
905  if (!addrange)
906  break;
907  }
908  }
909  }
910 
911  /* add the pages in the range to the output bitmap, if needed */
912  if (addrange)
913  {
914  BlockNumber pageno;
915 
916  for (pageno = heapBlk;
917  pageno <= Min(nblocks, heapBlk + opaque->bo_pagesPerRange) - 1;
918  pageno++)
919  {
920  MemoryContextSwitchTo(oldcxt);
921  tbm_add_page(tbm, pageno);
922  totalpages++;
923  MemoryContextSwitchTo(perRangeCxt);
924  }
925  }
926  }
927 
928  MemoryContextSwitchTo(oldcxt);
929  MemoryContextDelete(perRangeCxt);
930 
931  if (buf != InvalidBuffer)
933 
934  /*
935  * XXX We have an approximation of the number of *pages* that our scan
936  * returns, but we don't have a precise idea of the number of heap tuples
937  * involved.
938  */
939  return totalpages * 10;
940 }
int16 AttrNumber
Definition: attnum.h:21
static bool check_null_keys(BrinValues *bval, ScanKey *nullkeys, int nnullkeys)
Definition: brin.c:2288
#define BRIN_PROCNUM_CONSISTENT
Definition: brin_internal.h:72
BrinTuple * brinGetTupleForHeapBlock(BrinRevmap *revmap, BlockNumber heapBlk, Buffer *buf, OffsetNumber *off, Size *size, int mode)
Definition: brin_revmap.c:194
BrinMemTuple * brin_new_memtuple(BrinDesc *brdesc)
Definition: brin_tuple.c:482
BrinMemTuple * brin_deform_tuple(BrinDesc *brdesc, BrinTuple *tuple, BrinMemTuple *dMemtuple)
Definition: brin_tuple.c:553
BrinTuple * brin_copy_tuple(BrinTuple *tuple, Size len, BrinTuple *dest, Size *destsz)
Definition: brin_tuple.c:446
#define InvalidBuffer
Definition: buf.h:25
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:4896
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:5131
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:193
#define BUFFER_LOCK_SHARE
Definition: bufmgr.h:194
#define Min(x, y)
Definition: c.h:1004
#define MAXALIGN(LEN)
Definition: c.h:811
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:182
size_t Size
Definition: c.h:605
#define palloc0_array(type, count)
Definition: fe_memutils.h:65
Datum FunctionCall4Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4)
Definition: fmgr.c:1196
Datum FunctionCall3Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3)
Definition: fmgr.c:1171
void fmgr_info_copy(FmgrInfo *dstinfo, FmgrInfo *srcinfo, MemoryContext destcxt)
Definition: fmgr.c:580
Oid IndexGetRelation(Oid indexId, bool missing_ok)
Definition: index.c:3523
int i
Definition: isn.c:73
#define AccessShareLock
Definition: lockdefs.h:36
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:383
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
uint16 OffsetNumber
Definition: off.h:24
const void size_t len
static char * buf
Definition: pg_test_fsync.c:73
#define pgstat_count_index_scan(rel)
Definition: pgstat.h:625
static bool DatumGetBool(Datum X)
Definition: postgres.h:90
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int Oid
Definition: postgres_ext.h:31
static void addrange(struct cvec *cv, chr from, chr to)
Definition: regc_cvec.c:90
#define RelationGetRelid(relation)
Definition: rel.h:505
#define SK_ISNULL
Definition: skey.h:115
static pg_noinline void Size size
Definition: slab.c:607
BrinValues bt_columns[FLEXIBLE_ARRAY_MEMBER]
Definition: brin_tuple.h:55
bool bt_placeholder
Definition: brin_tuple.h:46
bool bt_empty_range
Definition: brin_tuple.h:47
bool oi_regular_nulls
Definition: brin_internal.h:31
bool bv_allnulls
Definition: brin_tuple.h:33
struct ScanKeyData * keyData
Definition: relscan.h:122
Relation indexRelation
Definition: relscan.h:118
Oid sk_collation
Definition: skey.h:70
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
void tbm_add_page(TIDBitmap *tbm, BlockNumber pageno)
Definition: tidbitmap.c:443

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

Referenced by brinhandler().

◆ brininsert()

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

Definition at line 335 of file brin.c.

340 {
341  BlockNumber pagesPerRange;
342  BlockNumber origHeapBlk;
343  BlockNumber heapBlk;
344  BrinInsertState *bistate = (BrinInsertState *) indexInfo->ii_AmCache;
345  BrinRevmap *revmap;
346  BrinDesc *bdesc;
348  MemoryContext tupcxt = NULL;
350  bool autosummarize = BrinGetAutoSummarize(idxRel);
351 
352  /*
353  * If first time through in this statement, initialize the insert state
354  * that we keep for all the inserts in the command.
355  */
356  if (!bistate)
357  bistate = initialize_brin_insertstate(idxRel, indexInfo);
358 
359  revmap = bistate->bis_rmAccess;
360  bdesc = bistate->bis_desc;
361  pagesPerRange = bistate->bis_pages_per_range;
362 
363  /*
364  * origHeapBlk is the block number where the insertion occurred. heapBlk
365  * is the first block in the corresponding page range.
366  */
367  origHeapBlk = ItemPointerGetBlockNumber(heaptid);
368  heapBlk = (origHeapBlk / pagesPerRange) * pagesPerRange;
369 
370  for (;;)
371  {
372  bool need_insert = false;
373  OffsetNumber off;
374  BrinTuple *brtup;
375  BrinMemTuple *dtup;
376 
378 
379  /*
380  * If auto-summarization is enabled and we just inserted the first
381  * tuple into the first block of a new non-first page range, request a
382  * summarization run of the previous range.
383  */
384  if (autosummarize &&
385  heapBlk > 0 &&
386  heapBlk == origHeapBlk &&
388  {
389  BlockNumber lastPageRange = heapBlk - 1;
390  BrinTuple *lastPageTuple;
391 
392  lastPageTuple =
393  brinGetTupleForHeapBlock(revmap, lastPageRange, &buf, &off,
394  NULL, BUFFER_LOCK_SHARE);
395  if (!lastPageTuple)
396  {
397  bool recorded;
398 
400  RelationGetRelid(idxRel),
401  lastPageRange);
402  if (!recorded)
403  ereport(LOG,
404  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
405  errmsg("request for BRIN range summarization for index \"%s\" page %u was not recorded",
406  RelationGetRelationName(idxRel),
407  lastPageRange)));
408  }
409  else
411  }
412 
413  brtup = brinGetTupleForHeapBlock(revmap, heapBlk, &buf, &off,
414  NULL, BUFFER_LOCK_SHARE);
415 
416  /* if range is unsummarized, there's nothing to do */
417  if (!brtup)
418  break;
419 
420  /* First time through in this brininsert call? */
421  if (tupcxt == NULL)
422  {
424  "brininsert cxt",
426  MemoryContextSwitchTo(tupcxt);
427  }
428 
429  dtup = brin_deform_tuple(bdesc, brtup, NULL);
430 
431  need_insert = add_values_to_range(idxRel, bdesc, dtup, values, nulls);
432 
433  if (!need_insert)
434  {
435  /*
436  * The tuple is consistent with the new values, so there's nothing
437  * to do.
438  */
440  }
441  else
442  {
443  Page page = BufferGetPage(buf);
444  ItemId lp = PageGetItemId(page, off);
445  Size origsz;
446  BrinTuple *origtup;
447  Size newsz;
448  BrinTuple *newtup;
449  bool samepage;
450 
451  /*
452  * Make a copy of the old tuple, so that we can compare it after
453  * re-acquiring the lock.
454  */
455  origsz = ItemIdGetLength(lp);
456  origtup = brin_copy_tuple(brtup, origsz, NULL, NULL);
457 
458  /*
459  * Before releasing the lock, check if we can attempt a same-page
460  * update. Another process could insert a tuple concurrently in
461  * the same page though, so downstream we must be prepared to cope
462  * if this turns out to not be possible after all.
463  */
464  newtup = brin_form_tuple(bdesc, heapBlk, dtup, &newsz);
465  samepage = brin_can_do_samepage_update(buf, origsz, newsz);
467 
468  /*
469  * Try to update the tuple. If this doesn't work for whatever
470  * reason, we need to restart from the top; the revmap might be
471  * pointing at a different tuple for this block now, so we need to
472  * recompute to ensure both our new heap tuple and the other
473  * inserter's are covered by the combined tuple. It might be that
474  * we don't need to update at all.
475  */
476  if (!brin_doupdate(idxRel, pagesPerRange, revmap, heapBlk,
477  buf, off, origtup, origsz, newtup, newsz,
478  samepage))
479  {
480  /* no luck; start over */
481  MemoryContextReset(tupcxt);
482  continue;
483  }
484  }
485 
486  /* success! */
487  break;
488  }
489 
490  if (BufferIsValid(buf))
492  MemoryContextSwitchTo(oldcxt);
493  if (tupcxt != NULL)
494  MemoryContextDelete(tupcxt);
495 
496  return false;
497 }
bool AutoVacuumRequestWork(AutoVacuumWorkItemType type, Oid relationId, BlockNumber blkno)
Definition: autovacuum.c:3204
@ AVW_BRINSummarizeRange
Definition: autovacuum.h:25
static Datum values[MAXATTR]
Definition: bootstrap.c:152
static bool add_values_to_range(Relation idxRel, BrinDesc *bdesc, BrinMemTuple *dtup, const Datum *values, const bool *nulls)
Definition: brin.c:2194
static BrinInsertState * initialize_brin_insertstate(Relation idxRel, IndexInfo *indexInfo)
Definition: brin.c:306
#define BrinGetAutoSummarize(relation)
Definition: brin.h:46
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:53
bool brin_can_do_samepage_update(Buffer buffer, Size origsz, Size newsz)
Definition: brin_pageops.c:323
BrinTuple * brin_form_tuple(BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple, Size *size)
Definition: brin_tuple.c:99
static bool BufferIsValid(Buffer bufnum)
Definition: bufmgr.h:355
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:240
int errcode(int sqlerrcode)
Definition: elog.c:857
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define LOG
Definition: elog.h:31
#define ereport(elevel,...)
Definition: elog.h:149
#define ItemIdGetLength(itemId)
Definition: itemid.h:59
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
Definition: itemptr.h:124
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition: itemptr.h:103
#define FirstOffsetNumber
Definition: off.h:27
BrinDesc * bis_desc
Definition: brin.c:192
BrinRevmap * bis_rmAccess
Definition: brin.c:191
BlockNumber bis_pages_per_range
Definition: brin.c:193
void * ii_AmCache
Definition: execnodes.h:207

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

Referenced by brinhandler().

◆ brininsertcleanup()

void brininsertcleanup ( Relation  index,
struct IndexInfo indexInfo 
)

Definition at line 503 of file brin.c.

504 {
505  BrinInsertState *bistate = (BrinInsertState *) indexInfo->ii_AmCache;
506 
507  /* bail out if cache not initialized */
508  if (indexInfo->ii_AmCache == NULL)
509  return;
510 
511  /*
512  * Clean up the revmap. Note that the brinDesc has already been cleaned up
513  * as part of its own memory context.
514  */
516  bistate->bis_rmAccess = NULL;
517  bistate->bis_desc = NULL;
518 }
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77

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

Referenced by brinhandler().

◆ brinoptions()

bytea* brinoptions ( Datum  reloptions,
bool  validate 
)

Definition at line 1336 of file brin.c.

1337 {
1338  static const relopt_parse_elt tab[] = {
1339  {"pages_per_range", RELOPT_TYPE_INT, offsetof(BrinOptions, pagesPerRange)},
1340  {"autosummarize", RELOPT_TYPE_BOOL, offsetof(BrinOptions, autosummarize)}
1341  };
1342 
1343  return (bytea *) build_reloptions(reloptions, validate,
1345  sizeof(BrinOptions),
1346  tab, lengthof(tab));
1347 }
#define lengthof(array)
Definition: c.h:788
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:1908
@ RELOPT_KIND_BRIN
Definition: reloptions.h:52
@ RELOPT_TYPE_INT
Definition: reloptions.h:32
@ RELOPT_TYPE_BOOL
Definition: reloptions.h:31
Definition: c.h:687

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

Referenced by brinhandler().

◆ brinrescan()

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

Definition at line 946 of file brin.c.

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

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

Referenced by brinhandler().

◆ brinvacuumcleanup()

IndexBulkDeleteResult* brinvacuumcleanup ( IndexVacuumInfo info,
IndexBulkDeleteResult stats 
)

Definition at line 1306 of file brin.c.

1307 {
1308  Relation heapRel;
1309 
1310  /* No-op in ANALYZE ONLY mode */
1311  if (info->analyze_only)
1312  return stats;
1313 
1314  if (!stats)
1316  stats->num_pages = RelationGetNumberOfBlocks(info->index);
1317  /* rest of stats is initialized by zeroing */
1318 
1319  heapRel = table_open(IndexGetRelation(RelationGetRelid(info->index), false),
1320  AccessShareLock);
1321 
1322  brin_vacuum_scan(info->index, info->strategy);
1323 
1324  brinsummarize(info->index, heapRel, BRIN_ALL_BLOCKRANGES, false,
1325  &stats->num_index_tuples, &stats->num_index_tuples);
1326 
1327  table_close(heapRel, AccessShareLock);
1328 
1329  return stats;
1330 }
static void brin_vacuum_scan(Relation idxrel, BufferAccessStrategy strategy)
Definition: brin.c:2161
#define BRIN_ALL_BLOCKRANGES
Definition: brin.c:206
static void brinsummarize(Relation index, Relation heapRel, BlockNumber pageRange, bool include_partial, double *numSummarized, double *numExisting)
Definition: brin.c:1876
BlockNumber num_pages
Definition: genam.h:77
double num_index_tuples
Definition: genam.h:79
Relation index
Definition: genam.h:46
bool analyze_only
Definition: genam.h:48
BufferAccessStrategy strategy
Definition: genam.h:53

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

Referenced by brinhandler().

◆ brinvalidate()

bool brinvalidate ( Oid  opclassoid)

Definition at line 37 of file brin_validate.c.

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

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

Referenced by brinhandler().