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