PostgreSQL Source Code  git master
blutils.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * blutils.c
4  * Bloom index utilities.
5  *
6  * Portions Copyright (c) 2016-2018, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1990-1993, Regents of the University of California
8  *
9  * IDENTIFICATION
10  * contrib/bloom/blutils.c
11  *
12  *-------------------------------------------------------------------------
13  */
14 #include "postgres.h"
15 
16 #include "access/amapi.h"
17 #include "access/generic_xlog.h"
18 #include "catalog/index.h"
19 #include "storage/lmgr.h"
20 #include "miscadmin.h"
21 #include "storage/bufmgr.h"
22 #include "storage/indexfsm.h"
23 #include "utils/memutils.h"
24 #include "access/reloptions.h"
25 #include "storage/freespace.h"
26 #include "storage/indexfsm.h"
27 
28 #include "bloom.h"
29 
30 /* Signature dealing macros - note i is assumed to be of type int */
31 #define GETWORD(x,i) ( *( (BloomSignatureWord *)(x) + ( (i) / SIGNWORDBITS ) ) )
32 #define CLRBIT(x,i) GETWORD(x,i) &= ~( 0x01 << ( (i) % SIGNWORDBITS ) )
33 #define SETBIT(x,i) GETWORD(x,i) |= ( 0x01 << ( (i) % SIGNWORDBITS ) )
34 #define GETBIT(x,i) ( (GETWORD(x,i) >> ( (i) % SIGNWORDBITS )) & 0x01 )
35 
37 
38 /* Kind of relation options for bloom index */
40 
41 /* parse table for fillRelOptions */
43 
44 static int32 myRand(void);
45 static void mySrand(uint32 seed);
46 
47 /*
48  * Module initialize function: initialize info about Bloom relation options.
49  *
50  * Note: keep this in sync with makeDefaultBloomOptions().
51  */
52 void
53 _PG_init(void)
54 {
55  int i;
56  char buf[16];
57 
59 
60  /* Option for length of signature */
62  "Length of signature in bits",
64  bl_relopt_tab[0].optname = "length";
65  bl_relopt_tab[0].opttype = RELOPT_TYPE_INT;
66  bl_relopt_tab[0].offset = offsetof(BloomOptions, bloomLength);
67 
68  /* Number of bits for each possible index column: col1, col2, ... */
69  for (i = 0; i < INDEX_MAX_KEYS; i++)
70  {
71  snprintf(buf, sizeof(buf), "col%d", i + 1);
73  "Number of bits generated for each index column",
75  bl_relopt_tab[i + 1].optname = MemoryContextStrdup(TopMemoryContext,
76  buf);
77  bl_relopt_tab[i + 1].opttype = RELOPT_TYPE_INT;
78  bl_relopt_tab[i + 1].offset = offsetof(BloomOptions, bitSize[0]) + sizeof(int) * i;
79  }
80 }
81 
82 /*
83  * Construct a default set of Bloom options.
84  */
85 static BloomOptions *
87 {
88  BloomOptions *opts;
89  int i;
90 
91  opts = (BloomOptions *) palloc0(sizeof(BloomOptions));
92  /* Convert DEFAULT_BLOOM_LENGTH from # of bits to # of words */
94  for (i = 0; i < INDEX_MAX_KEYS; i++)
95  opts->bitSize[i] = DEFAULT_BLOOM_BITS;
96  SET_VARSIZE(opts, sizeof(BloomOptions));
97  return opts;
98 }
99 
100 /*
101  * Bloom handler function: return IndexAmRoutine with access method parameters
102  * and callbacks.
103  */
104 Datum
106 {
107  IndexAmRoutine *amroutine = makeNode(IndexAmRoutine);
108 
109  amroutine->amstrategies = BLOOM_NSTRATEGIES;
110  amroutine->amsupport = BLOOM_NPROC;
111  amroutine->amcanorder = false;
112  amroutine->amcanorderbyop = false;
113  amroutine->amcanbackward = false;
114  amroutine->amcanunique = false;
115  amroutine->amcanmulticol = true;
116  amroutine->amoptionalkey = true;
117  amroutine->amsearcharray = false;
118  amroutine->amsearchnulls = false;
119  amroutine->amstorage = false;
120  amroutine->amclusterable = false;
121  amroutine->ampredlocks = false;
122  amroutine->amcanparallel = false;
123  amroutine->amcaninclude = false;
124  amroutine->amkeytype = InvalidOid;
125 
126  amroutine->ambuild = blbuild;
127  amroutine->ambuildempty = blbuildempty;
128  amroutine->aminsert = blinsert;
129  amroutine->ambulkdelete = blbulkdelete;
130  amroutine->amvacuumcleanup = blvacuumcleanup;
131  amroutine->amcanreturn = NULL;
132  amroutine->amcostestimate = blcostestimate;
133  amroutine->amoptions = bloptions;
134  amroutine->amproperty = NULL;
135  amroutine->amvalidate = blvalidate;
136  amroutine->ambeginscan = blbeginscan;
137  amroutine->amrescan = blrescan;
138  amroutine->amgettuple = NULL;
139  amroutine->amgetbitmap = blgetbitmap;
140  amroutine->amendscan = blendscan;
141  amroutine->ammarkpos = NULL;
142  amroutine->amrestrpos = NULL;
143  amroutine->amestimateparallelscan = NULL;
144  amroutine->aminitparallelscan = NULL;
145  amroutine->amparallelrescan = NULL;
146 
147  PG_RETURN_POINTER(amroutine);
148 }
149 
150 /*
151  * Fill BloomState structure for particular index.
152  */
153 void
155 {
156  int i;
157 
158  state->nColumns = index->rd_att->natts;
159 
160  /* Initialize hash function for each attribute */
161  for (i = 0; i < index->rd_att->natts; i++)
162  {
163  fmgr_info_copy(&(state->hashFn[i]),
164  index_getprocinfo(index, i + 1, BLOOM_HASH_PROC),
166  }
167 
168  /* Initialize amcache if needed with options from metapage */
169  if (!index->rd_amcache)
170  {
171  Buffer buffer;
172  Page page;
173  BloomMetaPageData *meta;
174  BloomOptions *opts;
175 
176  opts = MemoryContextAlloc(index->rd_indexcxt, sizeof(BloomOptions));
177 
178  buffer = ReadBuffer(index, BLOOM_METAPAGE_BLKNO);
179  LockBuffer(buffer, BUFFER_LOCK_SHARE);
180 
181  page = BufferGetPage(buffer);
182 
183  if (!BloomPageIsMeta(page))
184  elog(ERROR, "Relation is not a bloom index");
185  meta = BloomPageGetMeta(BufferGetPage(buffer));
186 
187  if (meta->magickNumber != BLOOM_MAGICK_NUMBER)
188  elog(ERROR, "Relation is not a bloom index");
189 
190  *opts = meta->opts;
191 
192  UnlockReleaseBuffer(buffer);
193 
194  index->rd_amcache = (void *) opts;
195  }
196 
197  memcpy(&state->opts, index->rd_amcache, sizeof(state->opts));
199  sizeof(BloomSignatureWord) * state->opts.bloomLength;
200 }
201 
202 /*
203  * Random generator copied from FreeBSD. Using own random generator here for
204  * two reasons:
205  *
206  * 1) In this case random numbers are used for on-disk storage. Usage of
207  * PostgreSQL number generator would obstruct it from all possible changes.
208  * 2) Changing seed of PostgreSQL random generator would be undesirable side
209  * effect.
210  */
211 static int32 next;
212 
213 static int32
214 myRand(void)
215 {
216  /*----------
217  * Compute x = (7^5 * x) mod (2^31 - 1)
218  * without overflowing 31 bits:
219  * (2^31 - 1) = 127773 * (7^5) + 2836
220  * From "Random number generators: good ones are hard to find",
221  * Park and Miller, Communications of the ACM, vol. 31, no. 10,
222  * October 1988, p. 1195.
223  *----------
224  */
225  int32 hi,
226  lo,
227  x;
228 
229  /* Must be in [1, 0x7ffffffe] range at this point. */
230  hi = next / 127773;
231  lo = next % 127773;
232  x = 16807 * lo - 2836 * hi;
233  if (x < 0)
234  x += 0x7fffffff;
235  next = x;
236  /* Transform to [0, 0x7ffffffd] range. */
237  return (x - 1);
238 }
239 
240 static void
242 {
243  next = seed;
244  /* Transform to [1, 0x7ffffffe] range. */
245  next = (next % 0x7ffffffe) + 1;
246 }
247 
248 /*
249  * Add bits of given value to the signature.
250  */
251 void
253 {
254  uint32 hashVal;
255  int nBit,
256  j;
257 
258  /*
259  * init generator with "column's" number to get "hashed" seed for new
260  * value. We don't want to map the same numbers from different columns
261  * into the same bits!
262  */
263  mySrand(attno);
264 
265  /*
266  * Init hash sequence to map our value into bits. the same values in
267  * different columns will be mapped into different bits because of step
268  * above
269  */
270  hashVal = DatumGetInt32(FunctionCall1(&state->hashFn[attno], value));
271  mySrand(hashVal ^ myRand());
272 
273  for (j = 0; j < state->opts.bitSize[attno]; j++)
274  {
275  /* prevent multiple evaluation in SETBIT macro */
276  nBit = myRand() % (state->opts.bloomLength * SIGNWORDBITS);
277  SETBIT(sign, nBit);
278  }
279 }
280 
281 /*
282  * Make bloom tuple from values.
283  */
284 BloomTuple *
286 {
287  int i;
288  BloomTuple *res = (BloomTuple *) palloc0(state->sizeOfBloomTuple);
289 
290  res->heapPtr = *iptr;
291 
292  /* Blooming each column */
293  for (i = 0; i < state->nColumns; i++)
294  {
295  /* skip nulls */
296  if (isnull[i])
297  continue;
298 
299  signValue(state, res->sign, values[i], i);
300  }
301 
302  return res;
303 }
304 
305 /*
306  * Add new bloom tuple to the page. Returns true if new tuple was successfully
307  * added to the page. Returns false if it doesn't fit on the page.
308  */
309 bool
311 {
312  BloomTuple *itup;
313  BloomPageOpaque opaque;
314  Pointer ptr;
315 
316  /* We shouldn't be pointed to an invalid page */
317  Assert(!PageIsNew(page) && !BloomPageIsDeleted(page));
318 
319  /* Does new tuple fit on the page? */
320  if (BloomPageGetFreeSpace(state, page) < state->sizeOfBloomTuple)
321  return false;
322 
323  /* Copy new tuple to the end of page */
324  opaque = BloomPageGetOpaque(page);
325  itup = BloomPageGetTuple(state, page, opaque->maxoff + 1);
326  memcpy((Pointer) itup, (Pointer) tuple, state->sizeOfBloomTuple);
327 
328  /* Adjust maxoff and pd_lower */
329  opaque->maxoff++;
330  ptr = (Pointer) BloomPageGetTuple(state, page, opaque->maxoff + 1);
331  ((PageHeader) page)->pd_lower = ptr - page;
332 
333  /* Assert we didn't overrun available space */
334  Assert(((PageHeader) page)->pd_lower <= ((PageHeader) page)->pd_upper);
335 
336  return true;
337 }
338 
339 /*
340  * Allocate a new page (either by recycling, or by extending the index file)
341  * The returned buffer is already pinned and exclusive-locked
342  * Caller is responsible for initializing the page by calling BloomInitBuffer
343  */
344 Buffer
346 {
347  Buffer buffer;
348  bool needLock;
349 
350  /* First, try to get a page from FSM */
351  for (;;)
352  {
353  BlockNumber blkno = GetFreeIndexPage(index);
354 
355  if (blkno == InvalidBlockNumber)
356  break;
357 
358  buffer = ReadBuffer(index, blkno);
359 
360  /*
361  * We have to guard against the possibility that someone else already
362  * recycled this page; the buffer may be locked if so.
363  */
364  if (ConditionalLockBuffer(buffer))
365  {
366  Page page = BufferGetPage(buffer);
367 
368  if (PageIsNew(page))
369  return buffer; /* OK to use, if never initialized */
370 
371  if (BloomPageIsDeleted(page))
372  return buffer; /* OK to use */
373 
375  }
376 
377  /* Can't use it, so release buffer and try again */
378  ReleaseBuffer(buffer);
379  }
380 
381  /* Must extend the file */
382  needLock = !RELATION_IS_LOCAL(index);
383  if (needLock)
385 
386  buffer = ReadBuffer(index, P_NEW);
388 
389  if (needLock)
391 
392  return buffer;
393 }
394 
395 /*
396  * Initialize any page of a bloom index.
397  */
398 void
400 {
401  BloomPageOpaque opaque;
402 
403  PageInit(page, BLCKSZ, sizeof(BloomPageOpaqueData));
404 
405  opaque = BloomPageGetOpaque(page);
406  memset(opaque, 0, sizeof(BloomPageOpaqueData));
407  opaque->flags = flags;
408  opaque->bloom_page_id = BLOOM_PAGE_ID;
409 }
410 
411 /*
412  * Fill in metapage for bloom index.
413  */
414 void
416 {
417  BloomOptions *opts;
418  BloomMetaPageData *metadata;
419 
420  /*
421  * Choose the index's options. If reloptions have been assigned, use
422  * those, otherwise create default options.
423  */
424  opts = (BloomOptions *) index->rd_options;
425  if (!opts)
426  opts = makeDefaultBloomOptions();
427 
428  /*
429  * Initialize contents of meta page, including a copy of the options,
430  * which are now frozen for the life of the index.
431  */
432  BloomInitPage(metaPage, BLOOM_META);
433  metadata = BloomPageGetMeta(metaPage);
434  memset(metadata, 0, sizeof(BloomMetaPageData));
435  metadata->magickNumber = BLOOM_MAGICK_NUMBER;
436  metadata->opts = *opts;
437  ((PageHeader) metaPage)->pd_lower += sizeof(BloomMetaPageData);
438 
439  /* If this fails, probably FreeBlockNumberArray size calc is wrong: */
440  Assert(((PageHeader) metaPage)->pd_lower <= ((PageHeader) metaPage)->pd_upper);
441 }
442 
443 /*
444  * Initialize metapage for bloom index.
445  */
446 void
448 {
449  Buffer metaBuffer;
450  Page metaPage;
452 
453  /*
454  * Make a new page; since it is first page it should be associated with
455  * block number 0 (BLOOM_METAPAGE_BLKNO).
456  */
457  metaBuffer = BloomNewBuffer(index);
459 
460  /* Initialize contents of meta page */
461  state = GenericXLogStart(index);
462  metaPage = GenericXLogRegisterBuffer(state, metaBuffer,
464  BloomFillMetapage(index, metaPage);
465  GenericXLogFinish(state);
466 
467  UnlockReleaseBuffer(metaBuffer);
468 }
469 
470 /*
471  * Parse reloptions for bloom index, producing a BloomOptions struct.
472  */
473 bytea *
474 bloptions(Datum reloptions, bool validate)
475 {
477  int numoptions;
478  BloomOptions *rdopts;
479 
480  /* Parse the user-given reloptions */
481  options = parseRelOptions(reloptions, validate, bl_relopt_kind, &numoptions);
482  rdopts = allocateReloptStruct(sizeof(BloomOptions), options, numoptions);
483  fillRelOptions((void *) rdopts, sizeof(BloomOptions), options, numoptions,
484  validate, bl_relopt_tab, lengthof(bl_relopt_tab));
485 
486  /* Convert signature length from # of bits to # to words, rounding up */
487  rdopts->bloomLength = (rdopts->bloomLength + SIGNWORDBITS - 1) / SIGNWORDBITS;
488 
489  return (bytea *) rdopts;
490 }
ambeginscan_function ambeginscan
Definition: amapi.h:217
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:326
#define BLOOM_METAPAGE_BLKNO
Definition: bloom.h:77
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:87
#define SETBIT(x, i)
Definition: blutils.c:33
#define BloomPageIsDeleted(page)
Definition: bloom.h:63
ambulkdelete_function ambulkdelete
Definition: amapi.h:210
relopt_type opttype
Definition: reloptions.h:127
bool amcanmulticol
Definition: amapi.h:180
#define MAX_BLOOM_LENGTH
Definition: bloom.h:91
uint16 amsupport
Definition: amapi.h:170
IndexBuildResult * blbuild(Relation heap, Relation index, IndexInfo *indexInfo)
Definition: blinsert.c:122
BloomOptions opts
Definition: bloom.h:140
#define BLOOM_PAGE_ID
Definition: bloom.h:56
static int32 next
Definition: blutils.c:211
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition: indexam.c:855
amgettuple_function amgettuple
Definition: amapi.h:219
#define DatumGetInt32(X)
Definition: postgres.h:457
bool amcanorderbyop
Definition: amapi.h:174
amproperty_function amproperty
Definition: amapi.h:215
#define ExclusiveLock
Definition: lockdefs.h:44
static BloomOptions * makeDefaultBloomOptions(void)
Definition: blutils.c:86
#define RELATION_IS_LOCAL(relation)
Definition: rel.h:528
#define BloomPageIsMeta(page)
Definition: bloom.h:61
FmgrInfo hashFn[INDEX_MAX_KEYS]
Definition: bloom.h:139
amparallelrescan_function amparallelrescan
Definition: amapi.h:228
#define BLOOM_NPROC
Definition: bloom.h:25
bool amstorage
Definition: amapi.h:188
#define DEFAULT_BLOOM_BITS
Definition: bloom.h:96
bool ampredlocks
Definition: amapi.h:192
int snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3
uint32 BlockNumber
Definition: block.h:31
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3309
#define P_NEW
Definition: bufmgr.h:82
OffsetNumber maxoff
Definition: bloom.h:34
aminsert_function aminsert
Definition: amapi.h:209
#define lengthof(array)
Definition: c.h:629
#define BUFFER_LOCK_EXCLUSIVE
Definition: bufmgr.h:89
PG_FUNCTION_INFO_V1(blhandler)
Oid amkeytype
Definition: amapi.h:198
int bitSize[INDEX_MAX_KEYS]
Definition: bloom.h:104
void blcostestimate(PlannerInfo *root, IndexPath *path, double loop_count, Cost *indexStartupCost, Cost *indexTotalCost, Selectivity *indexSelectivity, double *indexCorrelation, double *indexPages)
Definition: blcost.c:25
bool amoptionalkey
Definition: amapi.h:182
Page GenericXLogRegisterBuffer(GenericXLogState *state, Buffer buffer, int flags)
Definition: generic_xlog.c:298
amvalidate_function amvalidate
Definition: amapi.h:216
int natts
Definition: tupdesc.h:82
uint16 bloom_page_id
Definition: bloom.h:39
void _PG_init(void)
Definition: blutils.c:53
signed int int32
Definition: c.h:313
IndexBulkDeleteResult * blvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
Definition: blvacuum.c:169
uint16 flags
Definition: bloom.h:35
#define DEFAULT_BLOOM_LENGTH
Definition: bloom.h:90
Buffer BloomNewBuffer(Relation index)
Definition: blutils.c:345
bool blvalidate(Oid opclassoid)
Definition: blvalidate.c:33
Definition: type.h:89
void blendscan(IndexScanDesc scan)
Definition: blscan.c:69
void add_int_reloption(bits32 kinds, const char *name, const char *desc, int default_val, int min_val, int max_val)
Definition: reloptions.c:677
uint16 BloomSignatureWord
Definition: bloom.h:83
unsigned short uint16
Definition: c.h:324
char * Pointer
Definition: c.h:302
amgetbitmap_function amgetbitmap
Definition: amapi.h:220
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:3332
#define BloomPageGetOpaque(page)
Definition: bloom.h:59
#define ERROR
Definition: elog.h:43
ambuild_function ambuild
Definition: amapi.h:207
static relopt_kind bl_relopt_kind
Definition: blutils.c:39
amoptions_function amoptions
Definition: amapi.h:214
void initBloomState(BloomState *state, Relation index)
Definition: blutils.c:154
static relopt_parse_elt bl_relopt_tab[INDEX_MAX_KEYS+1]
Definition: blutils.c:42
#define SIGNWORDBITS
Definition: bloom.h:85
bool amcaninclude
Definition: amapi.h:196
void fmgr_info_copy(FmgrInfo *dstinfo, FmgrInfo *srcinfo, MemoryContext destcxt)
Definition: fmgr.c:610
char sign
Definition: informix.c:693
amcostestimate_function amcostestimate
Definition: amapi.h:213
bool amcanunique
Definition: amapi.h:178
void * allocateReloptStruct(Size base, relopt_value *options, int numoptions)
Definition: reloptions.c:1242
#define BloomPageGetFreeSpace(state, page)
Definition: bloom.h:150
IndexBulkDeleteResult * blbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
Definition: blvacuum.c:34
static char * buf
Definition: pg_test_fsync.c:67
amvacuumcleanup_function amvacuumcleanup
Definition: amapi.h:211
amendscan_function amendscan
Definition: amapi.h:221
bool amcanbackward
Definition: amapi.h:176
void BloomFillMetapage(Relation index, Page metaPage)
Definition: blutils.c:415
unsigned int uint32
Definition: c.h:325
MemoryContext CurrentMemoryContext
Definition: mcxt.c:38
#define BloomPageGetTuple(state, page, offset)
Definition: bloom.h:70
int64 blgetbitmap(IndexScanDesc scan, TIDBitmap *tbm)
Definition: blscan.c:82
#define BufferGetPage(buffer)
Definition: bufmgr.h:160
#define BloomPageGetMeta(page)
Definition: bloom.h:135
amrescan_function amrescan
Definition: amapi.h:218
bool amcanparallel
Definition: amapi.h:194
bool ConditionalLockBuffer(Buffer buffer)
Definition: bufmgr.c:3572
MemoryContext TopMemoryContext
Definition: mcxt.c:44
#define BLOOM_NSTRATEGIES
Definition: bloom.h:29
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:1266
void LockRelationForExtension(Relation relation, LOCKMODE lockmode)
Definition: lmgr.c:332
bool amsearchnulls
Definition: amapi.h:186
#define BLOOMTUPLEHDRSZ
Definition: bloom.h:164
void * palloc0(Size size)
Definition: mcxt.c:955
BloomOptions opts
Definition: bloom.h:125
void UnlockRelationForExtension(Relation relation, LOCKMODE lockmode)
Definition: lmgr.c:382
uintptr_t Datum
Definition: postgres.h:367
void blrescan(IndexScanDesc scan, ScanKey scankey, int nscankeys, ScanKey orderbys, int norderbys)
Definition: blscan.c:49
void signValue(BloomState *state, BloomSignatureWord *sign, Datum value, int attno)
Definition: blutils.c:252
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:3546
bool amclusterable
Definition: amapi.h:190
const char * optname
Definition: reloptions.h:126
int32 nColumns
Definition: bloom.h:141
static struct @131 value
TupleDesc rd_att
Definition: rel.h:85
void BloomInitMetapage(Relation index)
Definition: blutils.c:447
bool amsearcharray
Definition: amapi.h:184
#define InvalidOid
Definition: postgres_ext.h:36
BlockNumber GetFreeIndexPage(Relation rel)
Definition: indexfsm.c:38
#define makeNode(_type_)
Definition: nodes.h:564
PageHeaderData * PageHeader
Definition: bufpage.h:162
#define Assert(condition)
Definition: c.h:699
BloomTuple * BloomFormTuple(BloomState *state, ItemPointer iptr, Datum *values, bool *isnull)
Definition: blutils.c:285
static int32 myRand(void)
Definition: blutils.c:214
Definition: regguts.h:298
XLogRecPtr GenericXLogFinish(GenericXLogState *state)
Definition: generic_xlog.c:336
WalTimeSample buffer[LAG_TRACKER_BUFFER_SIZE]
Definition: walsender.c:215
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
Definition: bufmgr.c:594
static void mySrand(uint32 seed)
Definition: blutils.c:241
bool blinsert(Relation index, Datum *values, bool *isnull, ItemPointer ht_ctid, Relation heapRel, IndexUniqueCheck checkUnique, IndexInfo *indexInfo)
Definition: blinsert.c:198
#define INDEX_MAX_KEYS
#define InvalidBlockNumber
Definition: block.h:33
ammarkpos_function ammarkpos
Definition: amapi.h:222
bool amcanorder
Definition: amapi.h:172
amestimateparallelscan_function amestimateparallelscan
Definition: amapi.h:226
BloomSignatureWord sign[FLEXIBLE_ARRAY_MEMBER]
Definition: bloom.h:161
void blbuildempty(Relation index)
Definition: blinsert.c:165
int bloomLength
Definition: bloom.h:103
relopt_kind add_reloption_kind(void)
Definition: reloptions.c:562
uint32 magickNumber
Definition: bloom.h:122
static Datum values[MAXATTR]
Definition: bootstrap.c:164
uint16 amstrategies
Definition: amapi.h:168
void BloomInitPage(Page page, uint16 flags)
Definition: blutils.c:399
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:2605
IndexScanDesc blbeginscan(Relation r, int nkeys, int norderbys)
Definition: blscan.c:29
ItemPointerData heapPtr
Definition: bloom.h:160
#define MAX_BLOOM_BITS
Definition: bloom.h:97
#define PageIsNew(page)
Definition: bufpage.h:225
char * MemoryContextStrdup(MemoryContext context, const char *string)
Definition: mcxt.c:1148
#define BLOOM_META
Definition: bloom.h:45
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:771
relopt_kind
Definition: reloptions.h:38
ambuildempty_function ambuildempty
Definition: amapi.h:208
MemoryContext rd_indexcxt
Definition: rel.h:151
bytea * bloptions(Datum reloptions, bool validate)
Definition: blutils.c:474
int i
#define FunctionCall1(flinfo, arg1)
Definition: fmgr.h:608
#define BUFFER_LOCK_SHARE
Definition: bufmgr.h:88
bool BloomPageAddItem(BloomState *state, Page page, BloomTuple *tuple)
Definition: blutils.c:310
Definition: c.h:516
#define PG_FUNCTION_ARGS
Definition: fmgr.h:163
relopt_value * parseRelOptions(Datum options, bool validate, relopt_kind kind, int *numrelopts)
Definition: reloptions.c:1048
Datum blhandler(PG_FUNCTION_ARGS)
Definition: blutils.c:105
#define SET_VARSIZE(PTR, len)
Definition: postgres.h:329
#define elog
Definition: elog.h:219
struct BloomMetaPageData BloomMetaPageData
void * rd_amcache
Definition: rel.h:164
#define BLOOM_MAGICK_NUMBER
Definition: bloom.h:130
Size sizeOfBloomTuple
Definition: bloom.h:147
int Buffer
Definition: buf.h:23
amcanreturn_function amcanreturn
Definition: amapi.h:212
#define BLOOM_HASH_PROC
Definition: bloom.h:24
#define GENERIC_XLOG_FULL_IMAGE
Definition: generic_xlog.h:26
bytea * rd_options
Definition: rel.h:128
#define offsetof(type, field)
Definition: c.h:622
GenericXLogState * GenericXLogStart(Relation relation)
Definition: generic_xlog.c:270
Pointer Page
Definition: bufpage.h:74
aminitparallelscan_function aminitparallelscan
Definition: amapi.h:227
amrestrpos_function amrestrpos
Definition: amapi.h:223
void PageInit(Page page, Size pageSize, Size specialSize)
Definition: bufpage.c:41