PostgreSQL Source Code: src/include/access/gin_private.h Source File

PostgreSQL Source Code git master
gin_private.h
Go to the documentation of this file.
1/*--------------------------------------------------------------------------
2 * gin_private.h
3 * header file for postgres inverted index access method implementation.
4 *
5 * Copyright (c) 2006-2025, PostgreSQL Global Development Group
6 *
7 * src/include/access/gin_private.h
8 *--------------------------------------------------------------------------
9 */
10#ifndef GIN_PRIVATE_H
11#define GIN_PRIVATE_H
12
13#include "access/amapi.h"
14#include "access/gin.h"
15#include "access/ginblock.h"
16#include "access/htup_details.h"
17#include "access/itup.h"
18#include "common/int.h"
19#include "catalog/pg_am_d.h"
20#include "fmgr.h"
21#include "lib/rbtree.h"
22#include "storage/bufmgr.h"
23
24/*
25 * Storage type for GIN's reloptions
26 */
27 typedef struct GinOptions
28{
29 int32 vl_len_; /* varlena header (do not touch directly!) */
30 bool useFastUpdate; /* use fast updates? */
31 int pendingListCleanupSize; /* maximum size of pending list */
32 } GinOptions;
33
34 #define GIN_DEFAULT_USE_FASTUPDATE true
35 #define GinGetUseFastUpdate(relation) \
36 (AssertMacro(relation->rd_rel->relkind == RELKIND_INDEX && \
37 relation->rd_rel->relam == GIN_AM_OID), \
38 (relation)->rd_options ? \
39 ((GinOptions *) (relation)->rd_options)->useFastUpdate : GIN_DEFAULT_USE_FASTUPDATE)
40 #define GinGetPendingListCleanupSize(relation) \
41 (AssertMacro(relation->rd_rel->relkind == RELKIND_INDEX && \
42 relation->rd_rel->relam == GIN_AM_OID), \
43 (relation)->rd_options && \
44 ((GinOptions *) (relation)->rd_options)->pendingListCleanupSize != -1 ? \
45 ((GinOptions *) (relation)->rd_options)->pendingListCleanupSize : \
46 gin_pending_list_limit)
47
48
49/* Macros for buffer lock/unlock operations */
50 #define GIN_UNLOCK BUFFER_LOCK_UNLOCK
51 #define GIN_SHARE BUFFER_LOCK_SHARE
52 #define GIN_EXCLUSIVE BUFFER_LOCK_EXCLUSIVE
53
54
55/*
56 * GinState: working data structure describing the index being worked on
57 */
58 typedef struct GinState
59{
60 Relation index;
61 bool oneCol; /* true if single-column index */
62
63 /*
64 * origTupdesc is the nominal tuple descriptor of the index, ie, the i'th
65 * attribute shows the key type (not the input data type!) of the i'th
66 * index column. In a single-column index this describes the actual leaf
67 * index tuples. In a multi-column index, the actual leaf tuples contain
68 * a smallint column number followed by a key datum of the appropriate
69 * type for that column. We set up tupdesc[i] to describe the actual
70 * rowtype of the index tuples for the i'th column, ie, (int2, keytype).
71 * Note that in any case, leaf tuples contain more data than is known to
72 * the TupleDesc; see access/gin/README for details.
73 */
74 TupleDesc origTupdesc;
75 TupleDesc tupdesc[INDEX_MAX_KEYS];
76
77 /*
78 * Per-index-column opclass support functions
79 */
80 FmgrInfo compareFn[INDEX_MAX_KEYS];
81 FmgrInfo extractValueFn[INDEX_MAX_KEYS];
82 FmgrInfo extractQueryFn[INDEX_MAX_KEYS];
83 FmgrInfo consistentFn[INDEX_MAX_KEYS];
84 FmgrInfo triConsistentFn[INDEX_MAX_KEYS];
85 FmgrInfo comparePartialFn[INDEX_MAX_KEYS]; /* optional method */
86 /* canPartialMatch[i] is true if comparePartialFn[i] is valid */
87 bool canPartialMatch[INDEX_MAX_KEYS];
88 /* Collations to pass to the support functions */
89 Oid supportCollation[INDEX_MAX_KEYS];
90 } GinState;
91
92
93/* ginutil.c */
94extern bytea *ginoptions(Datum reloptions, bool validate);
95extern void initGinState(GinState *state, Relation index);
96extern Buffer GinNewBuffer(Relation index);
97extern void GinInitBuffer(Buffer b, uint32 f);
98extern void GinInitPage(Page page, uint32 f, Size pageSize);
99extern void GinInitMetabuffer(Buffer b);
100extern int ginCompareEntries(GinState *ginstate, OffsetNumber attnum,
101 Datum a, GinNullCategory categorya,
102 Datum b, GinNullCategory categoryb);
103extern int ginCompareAttEntries(GinState *ginstate,
104 OffsetNumber attnuma, Datum a, GinNullCategory categorya,
105 OffsetNumber attnumb, Datum b, GinNullCategory categoryb);
106extern Datum *ginExtractEntries(GinState *ginstate, OffsetNumber attnum,
107 Datum value, bool isNull,
108 int32 *nentries, GinNullCategory **categories);
109
110extern OffsetNumber gintuple_get_attrnum(GinState *ginstate, IndexTuple tuple);
111extern Datum gintuple_get_key(GinState *ginstate, IndexTuple tuple,
112 GinNullCategory *category);
113extern char *ginbuildphasename(int64 phasenum);
114
115/* gininsert.c */
116extern IndexBuildResult *ginbuild(Relation heap, Relation index,
117 struct IndexInfo *indexInfo);
118extern void ginbuildempty(Relation index);
119extern bool gininsert(Relation index, Datum *values, bool *isnull,
120 ItemPointer ht_ctid, Relation heapRel,
121 IndexUniqueCheck checkUnique,
122 bool indexUnchanged,
123 struct IndexInfo *indexInfo);
124extern void ginEntryInsert(GinState *ginstate,
125 OffsetNumber attnum, Datum key, GinNullCategory category,
126 ItemPointerData *items, uint32 nitem,
127 GinStatsData *buildStats);
128
129/* ginbtree.c */
130
131 typedef struct GinBtreeStack
132{
133 BlockNumber blkno;
134 Buffer buffer;
135 OffsetNumber off;
136 ItemPointerData iptr;
137 /* predictNumber contains predicted number of pages on current level */
138 uint32 predictNumber;
139 struct GinBtreeStack *parent;
140 } GinBtreeStack;
141
142 typedef struct GinBtreeData *GinBtree;
143
144/* Return codes for GinBtreeData.beginPlaceToPage method */
145 typedef enum
146{
147 GPTP_NO_WORK,
148 GPTP_INSERT,
149 GPTP_SPLIT,
150} GinPlaceToPageRC;
151
152 typedef struct GinBtreeData
153{
154 /* search methods */
155 BlockNumber (*findChildPage) (GinBtree, GinBtreeStack *);
156 BlockNumber (*getLeftMostChild) (GinBtree, Page);
157 bool (*isMoveRight) (GinBtree, Page);
158 bool (*findItem) (GinBtree, GinBtreeStack *);
159
160 /* insert methods */
161 OffsetNumber (*findChildPtr) (GinBtree, Page, BlockNumber, OffsetNumber);
162 GinPlaceToPageRC (*beginPlaceToPage) (GinBtree, Buffer, GinBtreeStack *, void *, BlockNumber, void **, Page *, Page *);
163 void (*execPlaceToPage) (GinBtree, Buffer, GinBtreeStack *, void *, BlockNumber, void *);
164 void *(*prepareDownlink) (GinBtree, Buffer);
165 void (*fillRoot) (GinBtree, Page, BlockNumber, Page, BlockNumber, Page);
166
167 bool isData;
168
169 Relation index;
170 BlockNumber rootBlkno;
171 GinState *ginstate; /* not valid in a data scan */
172 bool fullScan;
173 bool isBuild;
174
175 /* Search key for Entry tree */
176 OffsetNumber entryAttnum;
177 Datum entryKey;
178 GinNullCategory entryCategory;
179
180 /* Search key for data tree (posting tree) */
181 ItemPointerData itemptr;
182 } GinBtreeData;
183
184/* This represents a tuple to be inserted to entry tree. */
185 typedef struct
186{
187 IndexTuple entry; /* tuple to insert */
188 bool isDelete; /* delete old tuple at same offset? */
189} GinBtreeEntryInsertData;
190
191/*
192 * This represents an itempointer, or many itempointers, to be inserted to
193 * a data (posting tree) leaf page
194 */
195 typedef struct
196{
197 ItemPointerData *items;
198 uint32 nitem;
199 uint32 curitem;
200} GinBtreeDataLeafInsertData;
201
202/*
203 * For internal data (posting tree) pages, the insertion payload is a
204 * PostingItem
205 */
206
207extern GinBtreeStack *ginFindLeafPage(GinBtree btree, bool searchMode,
208 bool rootConflictCheck);
209extern Buffer ginStepRight(Buffer buffer, Relation index, int lockmode);
210extern void freeGinBtreeStack(GinBtreeStack *stack);
211extern void ginInsertValue(GinBtree btree, GinBtreeStack *stack,
212 void *insertdata, GinStatsData *buildStats);
213
214/* ginentrypage.c */
215extern IndexTuple GinFormTuple(GinState *ginstate,
216 OffsetNumber attnum, Datum key, GinNullCategory category,
217 Pointer data, Size dataSize, int nipd, bool errorTooBig);
218extern void ginPrepareEntryScan(GinBtree btree, OffsetNumber attnum,
219 Datum key, GinNullCategory category,
220 GinState *ginstate);
221extern void ginEntryFillRoot(GinBtree btree, Page root, BlockNumber lblkno, Page lpage, BlockNumber rblkno, Page rpage);
222extern ItemPointer ginReadTuple(GinState *ginstate, OffsetNumber attnum,
223 IndexTuple itup, int *nitems);
224
225/* gindatapage.c */
226extern ItemPointer GinDataLeafPageGetItems(Page page, int *nitems, ItemPointerData advancePast);
227extern int GinDataLeafPageGetItemsToTbm(Page page, TIDBitmap *tbm);
228extern BlockNumber createPostingTree(Relation index,
229 ItemPointerData *items, uint32 nitems,
230 GinStatsData *buildStats, Buffer entrybuffer);
231extern void GinDataPageAddPostingItem(Page page, PostingItem *data, OffsetNumber offset);
232extern void GinPageDeletePostingItem(Page page, OffsetNumber offset);
233extern void ginInsertItemPointers(Relation index, BlockNumber rootBlkno,
234 ItemPointerData *items, uint32 nitem,
235 GinStatsData *buildStats);
236extern GinBtreeStack *ginScanBeginPostingTree(GinBtree btree, Relation index, BlockNumber rootBlkno);
237extern void ginDataFillRoot(GinBtree btree, Page root, BlockNumber lblkno, Page lpage, BlockNumber rblkno, Page rpage);
238
239/*
240 * This is declared in ginvacuum.c, but is passed between ginVacuumItemPointers
241 * and ginVacuumPostingTreeLeaf and as an opaque struct, so we need a forward
242 * declaration for it.
243 */
244 typedef struct GinVacuumState GinVacuumState;
245
246extern void ginVacuumPostingTreeLeaf(Relation indexrel, Buffer buffer,
247 GinVacuumState *gvs);
248
249/* ginscan.c */
250
251/*
252 * GinScanKeyData describes a single GIN index qualifier expression.
253 *
254 * From each qual expression, we extract one or more specific index search
255 * conditions, which are represented by GinScanEntryData. It's quite
256 * possible for identical search conditions to be requested by more than
257 * one qual expression, in which case we merge such conditions to have just
258 * one unique GinScanEntry --- this is particularly important for efficiency
259 * when dealing with full-index-scan entries. So there can be multiple
260 * GinScanKeyData.scanEntry pointers to the same GinScanEntryData.
261 *
262 * In each GinScanKeyData, nentries is the true number of entries, while
263 * nuserentries is the number that extractQueryFn returned (which is what
264 * we report to consistentFn). The "user" entries must come first.
265 */
266 typedef struct GinScanKeyData *GinScanKey;
267
268 typedef struct GinScanEntryData *GinScanEntry;
269
270 typedef struct GinScanKeyData
271{
272 /* Real number of entries in scanEntry[] (always > 0) */
273 uint32 nentries;
274 /* Number of entries that extractQueryFn and consistentFn know about */
275 uint32 nuserentries;
276
277 /* array of GinScanEntry pointers, one per extracted search condition */
278 GinScanEntry *scanEntry;
279
280 /*
281 * At least one of the entries in requiredEntries must be present for a
282 * tuple to match the overall qual.
283 *
284 * additionalEntries contains entries that are needed by the consistent
285 * function to decide if an item matches, but are not sufficient to
286 * satisfy the qual without entries from requiredEntries.
287 */
288 GinScanEntry *requiredEntries;
289 int nrequired;
290 GinScanEntry *additionalEntries;
291 int nadditional;
292
293 /* array of check flags, reported to consistentFn */
294 GinTernaryValue *entryRes;
295 bool (*boolConsistentFn) (GinScanKey key);
296 GinTernaryValue (*triConsistentFn) (GinScanKey key);
297 FmgrInfo *consistentFmgrInfo;
298 FmgrInfo *triConsistentFmgrInfo;
299 Oid collation;
300
301 /* other data needed for calling consistentFn */
302 Datum query;
303 /* NB: these three arrays have only nuserentries elements! */
304 Datum *queryValues;
305 GinNullCategory *queryCategories;
306 Pointer *extra_data;
307 StrategyNumber strategy;
308 int32 searchMode;
309 OffsetNumber attnum;
310
311 /*
312 * An excludeOnly scan key is not able to enumerate all matching tuples.
313 * That is, to be semantically correct on its own, it would need to have a
314 * GIN_CAT_EMPTY_QUERY scanEntry, but it doesn't. Such a key can still be
315 * used to filter tuples returned by other scan keys, so we will get the
316 * right answers as long as there's at least one non-excludeOnly scan key
317 * for each index attribute considered by the search. For efficiency
318 * reasons we don't want to have unnecessary GIN_CAT_EMPTY_QUERY entries,
319 * so we will convert an excludeOnly scan key to non-excludeOnly (by
320 * adding a GIN_CAT_EMPTY_QUERY scanEntry) only if there are no other
321 * non-excludeOnly scan keys.
322 */
323 bool excludeOnly;
324
325 /*
326 * Match status data. curItem is the TID most recently tested (could be a
327 * lossy-page pointer). curItemMatches is true if it passes the
328 * consistentFn test; if so, recheckCurItem is the recheck flag.
329 * isFinished means that all the input entry streams are finished, so this
330 * key cannot succeed for any later TIDs.
331 */
332 ItemPointerData curItem;
333 bool curItemMatches;
334 bool recheckCurItem;
335 bool isFinished;
336 } GinScanKeyData;
337
338 typedef struct GinScanEntryData
339{
340 /* query key and other information from extractQueryFn */
341 Datum queryKey;
342 GinNullCategory queryCategory;
343 bool isPartialMatch;
344 Pointer extra_data;
345 StrategyNumber strategy;
346 int32 searchMode;
347 OffsetNumber attnum;
348
349 /* Current page in posting tree */
350 Buffer buffer;
351
352 /* current ItemPointer to heap */
353 ItemPointerData curItem;
354
355 /* for a partial-match or full-scan query, we accumulate all TIDs here */
356 TIDBitmap *matchBitmap;
357 TBMPrivateIterator *matchIterator;
358
359 /*
360 * If blockno is InvalidBlockNumber, all of the other fields in the
361 * matchResult are meaningless.
362 */
363 TBMIterateResult matchResult;
364 OffsetNumber matchOffsets[TBM_MAX_TUPLES_PER_PAGE];
365 int matchNtuples;
366
367 /* used for Posting list and one page in Posting tree */
368 ItemPointerData *list;
369 int nlist;
370 OffsetNumber offset;
371
372 bool isFinished;
373 bool reduceResult;
374 uint32 predictNumberResult;
375 GinBtreeData btree;
376 } GinScanEntryData;
377
378 typedef struct GinScanOpaqueData
379{
380 MemoryContext tempCtx;
381 GinState ginstate;
382
383 GinScanKey keys; /* one per scan qualifier expr */
384 uint32 nkeys;
385
386 GinScanEntry *entries; /* one per index search condition */
387 uint32 totalentries;
388 uint32 allocentries; /* allocated length of entries[] */
389
390 MemoryContext keyCtx; /* used to hold key and entry data */
391
392 bool isVoidRes; /* true if query is unsatisfiable */
393 } GinScanOpaqueData;
394
395 typedef GinScanOpaqueData *GinScanOpaque;
396
397extern IndexScanDesc ginbeginscan(Relation rel, int nkeys, int norderbys);
398extern void ginendscan(IndexScanDesc scan);
399extern void ginrescan(IndexScanDesc scan, ScanKey scankey, int nscankeys,
400 ScanKey orderbys, int norderbys);
401extern void ginNewScanKey(IndexScanDesc scan);
402extern void ginFreeScanKeys(GinScanOpaque so);
403
404/* ginget.c */
405extern int64 gingetbitmap(IndexScanDesc scan, TIDBitmap *tbm);
406
407/* ginlogic.c */
408extern void ginInitConsistentFunction(GinState *ginstate, GinScanKey key);
409
410/* ginvacuum.c */
411extern IndexBulkDeleteResult *ginbulkdelete(IndexVacuumInfo *info,
412 IndexBulkDeleteResult *stats,
413 IndexBulkDeleteCallback callback,
414 void *callback_state);
415extern IndexBulkDeleteResult *ginvacuumcleanup(IndexVacuumInfo *info,
416 IndexBulkDeleteResult *stats);
417extern ItemPointer ginVacuumItemPointers(GinVacuumState *gvs,
418 ItemPointerData *items, int nitem, int *nremaining);
419
420/* ginvalidate.c */
421extern bool ginvalidate(Oid opclassoid);
422extern void ginadjustmembers(Oid opfamilyoid,
423 Oid opclassoid,
424 List *operators,
425 List *functions);
426
427/* ginbulk.c */
428 typedef struct GinEntryAccumulator
429{
430 RBTNode rbtnode;
431 Datum key;
432 GinNullCategory category;
433 OffsetNumber attnum;
434 bool shouldSort;
435 ItemPointerData *list;
436 uint32 maxcount; /* allocated size of list[] */
437 uint32 count; /* current number of list[] entries */
438 } GinEntryAccumulator;
439
440 typedef struct
441{
442 GinState *ginstate;
443 Size allocatedMemory;
444 GinEntryAccumulator *entryallocator;
445 uint32 eas_used;
446 RBTree *tree;
447 RBTreeIterator tree_walk;
448} BuildAccumulator;
449
450extern void ginInitBA(BuildAccumulator *accum);
451extern void ginInsertBAEntries(BuildAccumulator *accum,
452 ItemPointer heapptr, OffsetNumber attnum,
453 Datum *entries, GinNullCategory *categories,
454 int32 nentries);
455extern void ginBeginBAScan(BuildAccumulator *accum);
456extern ItemPointerData *ginGetBAEntry(BuildAccumulator *accum,
457 OffsetNumber *attnum, Datum *key, GinNullCategory *category,
458 uint32 *n);
459
460/* ginfast.c */
461
462 typedef struct GinTupleCollector
463{
464 IndexTuple *tuples;
465 uint32 ntuples;
466 uint32 lentuples;
467 uint32 sumsize;
468 } GinTupleCollector;
469
470extern void ginHeapTupleFastInsert(GinState *ginstate,
471 GinTupleCollector *collector);
472extern void ginHeapTupleFastCollect(GinState *ginstate,
473 GinTupleCollector *collector,
474 OffsetNumber attnum, Datum value, bool isNull,
475 ItemPointer ht_ctid);
476extern void ginInsertCleanup(GinState *ginstate, bool full_clean,
477 bool fill_fsm, bool forceCleanup, IndexBulkDeleteResult *stats);
478
479/* ginpostinglist.c */
480
481extern GinPostingList *ginCompressPostingList(const ItemPointer ipd, int nipd,
482 int maxsize, int *nwritten);
483extern int ginPostingListDecodeAllSegmentsToTbm(GinPostingList *ptr, int len, TIDBitmap *tbm);
484
485extern ItemPointer ginPostingListDecodeAllSegments(GinPostingList *segment, int len,
486 int *ndecoded_out);
487extern ItemPointer ginPostingListDecode(GinPostingList *plist, int *ndecoded_out);
488extern ItemPointer ginMergeItemPointers(ItemPointerData *a, uint32 na,
489 ItemPointerData *b, uint32 nb,
490 int *nmerged);
491
492/*
493 * Merging the results of several gin scans compares item pointers a lot,
494 * so we want this to be inlined.
495 */
496static inline int
497 ginCompareItemPointers(ItemPointer a, ItemPointer b)
498{
499 uint64 ia = (uint64) GinItemPointerGetBlockNumber(a) << 32 | GinItemPointerGetOffsetNumber(a);
500 uint64 ib = (uint64) GinItemPointerGetBlockNumber(b) << 32 | GinItemPointerGetOffsetNumber(b);
501
502 return pg_cmp_u64(ia, ib);
503}
504
505extern int ginTraverseLock(Buffer buffer, bool searchMode);
506
507#endif /* GIN_PRIVATE_H */
static bool validate(Port *port, const char *auth)
Definition: auth-oauth.c:638
uint32 BlockNumber
Definition: block.h:31
static Datum values[MAXATTR]
Definition: bootstrap.c:153
int Buffer
Definition: buf.h:23
PageData * Page
Definition: bufpage.h:82
char * Pointer
Definition: c.h:529
int64_t int64
Definition: c.h:535
int32_t int32
Definition: c.h:534
uint64_t uint64
Definition: c.h:539
uint32_t uint32
Definition: c.h:538
size_t Size
Definition: c.h:610
bool(* IndexBulkDeleteCallback)(ItemPointer itemptr, void *state)
Definition: genam.h:114
IndexUniqueCheck
Definition: genam.h:143
char GinTernaryValue
Definition: gin.h:71
int ginTraverseLock(Buffer buffer, bool searchMode)
Definition: ginbtree.c:39
IndexScanDesc ginbeginscan(Relation rel, int nkeys, int norderbys)
Definition: ginscan.c:25
struct GinScanKeyData GinScanKeyData
void freeGinBtreeStack(GinBtreeStack *stack)
Definition: ginbtree.c:198
ItemPointer ginPostingListDecodeAllSegments(GinPostingList *segment, int len, int *ndecoded_out)
void ginBeginBAScan(BuildAccumulator *accum)
Definition: ginbulk.c:257
void ginInsertValue(GinBtree btree, GinBtreeStack *stack, void *insertdata, GinStatsData *buildStats)
Definition: ginbtree.c:816
GinScanOpaqueData * GinScanOpaque
Definition: gin_private.h:395
void GinInitPage(Page page, uint32 f, Size pageSize)
Definition: ginutil.c:343
struct GinOptions GinOptions
bytea * ginoptions(Datum reloptions, bool validate)
Definition: ginutil.c:607
int64 gingetbitmap(IndexScanDesc scan, TIDBitmap *tbm)
Definition: ginget.c:1931
void ginInsertCleanup(GinState *ginstate, bool full_clean, bool fill_fsm, bool forceCleanup, IndexBulkDeleteResult *stats)
Definition: ginfast.c:780
void ginHeapTupleFastCollect(GinState *ginstate, GinTupleCollector *collector, OffsetNumber attnum, Datum value, bool isNull, ItemPointer ht_ctid)
Definition: ginfast.c:483
void ginFreeScanKeys(GinScanOpaque so)
Definition: ginscan.c:239
ItemPointerData * ginGetBAEntry(BuildAccumulator *accum, OffsetNumber *attnum, Datum *key, GinNullCategory *category, uint32 *n)
Definition: ginbulk.c:268
void ginEntryFillRoot(GinBtree btree, Page root, BlockNumber lblkno, Page lpage, BlockNumber rblkno, Page rpage)
Definition: ginentrypage.c:723
static int ginCompareItemPointers(ItemPointer a, ItemPointer b)
Definition: gin_private.h:497
OffsetNumber gintuple_get_attrnum(GinState *ginstate, IndexTuple tuple)
Definition: ginutil.c:231
Buffer GinNewBuffer(Relation index)
Definition: ginutil.c:305
BlockNumber createPostingTree(Relation index, ItemPointerData *items, uint32 nitems, GinStatsData *buildStats, Buffer entrybuffer)
Definition: gindatapage.c:1775
bool ginvalidate(Oid opclassoid)
Definition: ginvalidate.c:31
int ginPostingListDecodeAllSegmentsToTbm(GinPostingList *ptr, int len, TIDBitmap *tbm)
struct GinState GinState
void GinInitBuffer(Buffer b, uint32 f)
Definition: ginutil.c:355
void ginEntryInsert(GinState *ginstate, OffsetNumber attnum, Datum key, GinNullCategory category, ItemPointerData *items, uint32 nitem, GinStatsData *buildStats)
Definition: gininsert.c:339
void ginendscan(IndexScanDesc scan)
Definition: ginscan.c:506
void ginNewScanKey(IndexScanDesc scan)
Definition: ginscan.c:269
void ginInsertBAEntries(BuildAccumulator *accum, ItemPointer heapptr, OffsetNumber attnum, Datum *entries, GinNullCategory *categories, int32 nentries)
Definition: ginbulk.c:210
struct GinScanOpaqueData GinScanOpaqueData
Datum * ginExtractEntries(GinState *ginstate, OffsetNumber attnum, Datum value, bool isNull, int32 *nentries, GinNullCategory **categories)
Definition: ginutil.c:488
GinBtreeStack * ginScanBeginPostingTree(GinBtree btree, Relation index, BlockNumber rootBlkno)
Definition: gindatapage.c:1936
void ginrescan(IndexScanDesc scan, ScanKey scankey, int nscankeys, ScanKey orderbys, int norderbys)
Definition: ginscan.c:493
void GinPageDeletePostingItem(Page page, OffsetNumber offset)
Definition: gindatapage.c:417
ItemPointer ginVacuumItemPointers(GinVacuumState *gvs, ItemPointerData *items, int nitem, int *nremaining)
Definition: ginvacuum.c:47
void ginInitConsistentFunction(GinState *ginstate, GinScanKey key)
Definition: ginlogic.c:227
GinPlaceToPageRC
Definition: gin_private.h:146
@ GPTP_INSERT
Definition: gin_private.h:148
@ GPTP_SPLIT
Definition: gin_private.h:149
@ GPTP_NO_WORK
Definition: gin_private.h:147
struct GinScanEntryData * GinScanEntry
Definition: gin_private.h:268
bool gininsert(Relation index, Datum *values, bool *isnull, ItemPointer ht_ctid, Relation heapRel, IndexUniqueCheck checkUnique, bool indexUnchanged, struct IndexInfo *indexInfo)
Definition: gininsert.c:824
struct GinBtreeStack GinBtreeStack
ItemPointer ginPostingListDecode(GinPostingList *plist, int *ndecoded_out)
int ginCompareAttEntries(GinState *ginstate, OffsetNumber attnuma, Datum a, GinNullCategory categorya, OffsetNumber attnumb, Datum b, GinNullCategory categoryb)
Definition: ginutil.c:415
GinPostingList * ginCompressPostingList(const ItemPointer ipd, int nipd, int maxsize, int *nwritten)
int GinDataLeafPageGetItemsToTbm(Page page, TIDBitmap *tbm)
Definition: gindatapage.c:182
struct GinBtreeData GinBtreeData
Datum gintuple_get_key(GinState *ginstate, IndexTuple tuple, GinNullCategory *category)
Definition: ginutil.c:264
struct GinBtreeData * GinBtree
Definition: gin_private.h:142
void GinDataPageAddPostingItem(Page page, PostingItem *data, OffsetNumber offset)
Definition: gindatapage.c:380
void ginInsertItemPointers(Relation index, BlockNumber rootBlkno, ItemPointerData *items, uint32 nitem, GinStatsData *buildStats)
Definition: gindatapage.c:1908
void GinInitMetabuffer(Buffer b)
Definition: ginutil.c:361
void ginInitBA(BuildAccumulator *accum)
Definition: ginbulk.c:109
void ginbuildempty(Relation index)
Definition: gininsert.c:775
void ginHeapTupleFastInsert(GinState *ginstate, GinTupleCollector *collector)
Definition: ginfast.c:219
char * ginbuildphasename(int64 phasenum)
Definition: ginutil.c:712
IndexBuildResult * ginbuild(Relation heap, Relation index, struct IndexInfo *indexInfo)
Definition: gininsert.c:581
void initGinState(GinState *state, Relation index)
Definition: ginutil.c:102
struct GinScanKeyData * GinScanKey
Definition: gin_private.h:266
GinBtreeStack * ginFindLeafPage(GinBtree btree, bool searchMode, bool rootConflictCheck)
Definition: ginbtree.c:83
IndexBulkDeleteResult * ginbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
Definition: ginvacuum.c:564
IndexBulkDeleteResult * ginvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
Definition: ginvacuum.c:687
ItemPointer ginReadTuple(GinState *ginstate, OffsetNumber attnum, IndexTuple itup, int *nitems)
Definition: ginentrypage.c:162
struct GinEntryAccumulator GinEntryAccumulator
int ginCompareEntries(GinState *ginstate, OffsetNumber attnum, Datum a, GinNullCategory categorya, Datum b, GinNullCategory categoryb)
Definition: ginutil.c:393
void ginadjustmembers(Oid opfamilyoid, Oid opclassoid, List *operators, List *functions)
Definition: ginvalidate.c:269
void ginVacuumPostingTreeLeaf(Relation indexrel, Buffer buffer, GinVacuumState *gvs)
Definition: gindatapage.c:738
IndexTuple GinFormTuple(GinState *ginstate, OffsetNumber attnum, Datum key, GinNullCategory category, Pointer data, Size dataSize, int nipd, bool errorTooBig)
Definition: ginentrypage.c:44
void ginPrepareEntryScan(GinBtree btree, OffsetNumber attnum, Datum key, GinNullCategory category, GinState *ginstate)
Definition: ginentrypage.c:747
struct GinTupleCollector GinTupleCollector
ItemPointer ginMergeItemPointers(ItemPointerData *a, uint32 na, ItemPointerData *b, uint32 nb, int *nmerged)
void ginDataFillRoot(GinBtree btree, Page root, BlockNumber lblkno, Page lpage, BlockNumber rblkno, Page rpage)
Definition: gindatapage.c:1349
Buffer ginStepRight(Buffer buffer, Relation index, int lockmode)
Definition: ginbtree.c:177
ItemPointer GinDataLeafPageGetItems(Page page, int *nitems, ItemPointerData advancePast)
Definition: gindatapage.c:135
struct GinScanEntryData GinScanEntryData
#define GinItemPointerGetOffsetNumber(pointer)
Definition: ginblock.h:146
signed char GinNullCategory
Definition: ginblock.h:206
#define GinItemPointerGetBlockNumber(pointer)
Definition: ginblock.h:143
#define nitems(x)
Definition: indent.h:31
static struct @169 value
static int pg_cmp_u64(uint64 a, uint64 b)
Definition: int.h:664
b
int b
Definition: isn.c:74
a
int a
Definition: isn.c:73
uint16 OffsetNumber
Definition: off.h:24
int16 attnum
Definition: pg_attribute.h:74
#define INDEX_MAX_KEYS
const void size_t len
const void * data
uint64_t Datum
Definition: postgres.h:70
unsigned int Oid
Definition: postgres_ext.h:32
tree ctl root
Definition: radixtree.h:1857
static const struct fns functions
Definition: regcomp.c:358
uint16 StrategyNumber
Definition: stratnum.h:22
Size allocatedMemory
Definition: gin_private.h:443
RBTree * tree
Definition: gin_private.h:446
uint32 eas_used
Definition: gin_private.h:445
GinState * ginstate
Definition: gin_private.h:442
RBTreeIterator tree_walk
Definition: gin_private.h:447
GinEntryAccumulator * entryallocator
Definition: gin_private.h:444
Definition: fmgr.h:57
ItemPointerData * items
Definition: gin_private.h:197
bool isBuild
Definition: gin_private.h:173
Datum entryKey
Definition: gin_private.h:177
BlockNumber(* findChildPage)(GinBtree, GinBtreeStack *)
Definition: gin_private.h:155
GinState * ginstate
Definition: gin_private.h:171
void(* execPlaceToPage)(GinBtree, Buffer, GinBtreeStack *, void *, BlockNumber, void *)
Definition: gin_private.h:163
BlockNumber(* getLeftMostChild)(GinBtree, Page)
Definition: gin_private.h:156
bool(* findItem)(GinBtree, GinBtreeStack *)
Definition: gin_private.h:158
bool(* isMoveRight)(GinBtree, Page)
Definition: gin_private.h:157
ItemPointerData itemptr
Definition: gin_private.h:181
bool fullScan
Definition: gin_private.h:172
GinPlaceToPageRC(* beginPlaceToPage)(GinBtree, Buffer, GinBtreeStack *, void *, BlockNumber, void **, Page *, Page *)
Definition: gin_private.h:162
GinNullCategory entryCategory
Definition: gin_private.h:178
OffsetNumber entryAttnum
Definition: gin_private.h:176
OffsetNumber(* findChildPtr)(GinBtree, Page, BlockNumber, OffsetNumber)
Definition: gin_private.h:161
Relation index
Definition: gin_private.h:169
void(* fillRoot)(GinBtree, Page, BlockNumber, Page, BlockNumber, Page)
Definition: gin_private.h:165
bool isData
Definition: gin_private.h:167
BlockNumber rootBlkno
Definition: gin_private.h:170
OffsetNumber off
Definition: gin_private.h:135
uint32 predictNumber
Definition: gin_private.h:138
ItemPointerData iptr
Definition: gin_private.h:136
struct GinBtreeStack * parent
Definition: gin_private.h:139
BlockNumber blkno
Definition: gin_private.h:133
Buffer buffer
Definition: gin_private.h:134
OffsetNumber attnum
Definition: gin_private.h:433
ItemPointerData * list
Definition: gin_private.h:435
GinNullCategory category
Definition: gin_private.h:432
int32 vl_len_
Definition: gin_private.h:29
bool useFastUpdate
Definition: gin_private.h:30
int pendingListCleanupSize
Definition: gin_private.h:31
ItemPointerData curItem
Definition: gin_private.h:353
bool isPartialMatch
Definition: gin_private.h:343
GinBtreeData btree
Definition: gin_private.h:375
TBMIterateResult matchResult
Definition: gin_private.h:363
OffsetNumber matchOffsets[TBM_MAX_TUPLES_PER_PAGE]
Definition: gin_private.h:364
TIDBitmap * matchBitmap
Definition: gin_private.h:356
ItemPointerData * list
Definition: gin_private.h:368
TBMPrivateIterator * matchIterator
Definition: gin_private.h:357
GinNullCategory queryCategory
Definition: gin_private.h:342
int32 searchMode
Definition: gin_private.h:346
StrategyNumber strategy
Definition: gin_private.h:345
Pointer extra_data
Definition: gin_private.h:344
OffsetNumber offset
Definition: gin_private.h:370
uint32 predictNumberResult
Definition: gin_private.h:374
OffsetNumber attnum
Definition: gin_private.h:347
int32 searchMode
Definition: gin_private.h:308
GinScanEntry * scanEntry
Definition: gin_private.h:278
bool excludeOnly
Definition: gin_private.h:323
uint32 nuserentries
Definition: gin_private.h:275
StrategyNumber strategy
Definition: gin_private.h:307
GinScanEntry * additionalEntries
Definition: gin_private.h:290
bool recheckCurItem
Definition: gin_private.h:334
Datum * queryValues
Definition: gin_private.h:304
GinScanEntry * requiredEntries
Definition: gin_private.h:288
FmgrInfo * triConsistentFmgrInfo
Definition: gin_private.h:298
ItemPointerData curItem
Definition: gin_private.h:332
GinNullCategory * queryCategories
Definition: gin_private.h:305
FmgrInfo * consistentFmgrInfo
Definition: gin_private.h:297
GinTernaryValue * entryRes
Definition: gin_private.h:294
bool isFinished
Definition: gin_private.h:335
Pointer * extra_data
Definition: gin_private.h:306
GinTernaryValue(* triConsistentFn)(GinScanKey key)
Definition: gin_private.h:296
bool curItemMatches
Definition: gin_private.h:333
bool(* boolConsistentFn)(GinScanKey key)
Definition: gin_private.h:295
OffsetNumber attnum
Definition: gin_private.h:309
uint32 nentries
Definition: gin_private.h:273
GinScanKey keys
Definition: gin_private.h:383
MemoryContext keyCtx
Definition: gin_private.h:390
uint32 totalentries
Definition: gin_private.h:387
GinScanEntry * entries
Definition: gin_private.h:386
GinState ginstate
Definition: gin_private.h:381
uint32 allocentries
Definition: gin_private.h:388
MemoryContext tempCtx
Definition: gin_private.h:380
FmgrInfo comparePartialFn[INDEX_MAX_KEYS]
Definition: gin_private.h:85
bool oneCol
Definition: gin_private.h:61
FmgrInfo extractQueryFn[INDEX_MAX_KEYS]
Definition: gin_private.h:82
TupleDesc tupdesc[INDEX_MAX_KEYS]
Definition: gin_private.h:75
FmgrInfo triConsistentFn[INDEX_MAX_KEYS]
Definition: gin_private.h:84
TupleDesc origTupdesc
Definition: gin_private.h:74
FmgrInfo extractValueFn[INDEX_MAX_KEYS]
Definition: gin_private.h:81
Relation index
Definition: gin_private.h:60
FmgrInfo consistentFn[INDEX_MAX_KEYS]
Definition: gin_private.h:83
Oid supportCollation[INDEX_MAX_KEYS]
Definition: gin_private.h:89
bool canPartialMatch[INDEX_MAX_KEYS]
Definition: gin_private.h:87
FmgrInfo compareFn[INDEX_MAX_KEYS]
Definition: gin_private.h:80
Definition: gin.h:56
IndexTuple * tuples
Definition: gin_private.h:464
uint32 lentuples
Definition: gin_private.h:466
Definition: pg_list.h:54
Definition: rbtree.h:24
Definition: rbtree.c:42
Definition: rel.h:56
Definition: skey.h:65
Definition: type.h:96
Definition: regguts.h:323
Definition: c.h:692
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition: test_ifaddrs.c:46
static ItemArray items
Definition: test_tidstore.c:48
#define TBM_MAX_TUPLES_PER_PAGE
Definition: tidbitmap.h:34

AltStyle によって変換されたページ (->オリジナル) /