PostgreSQL Source Code git master
ginget.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * ginget.c
4 * fetch tuples from a GIN scan.
5 *
6 *
7 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 * IDENTIFICATION
11 * src/backend/access/gin/ginget.c
12 *-------------------------------------------------------------------------
13 */
14
15#include "postgres.h"
16
17#include "access/gin_private.h"
18#include "access/relscan.h"
19#include "common/pg_prng.h"
20#include "miscadmin.h"
21#include "storage/predicate.h"
22#include "utils/datum.h"
23#include "utils/memutils.h"
24#include "utils/rel.h"
25
26/* GUC parameter */
28
29typedef struct pendingPosition
30{
37
38
39/*
40 * Goes to the next page if current offset is outside of bounds
41 */
42static bool
44{
45 Page page = BufferGetPage(stack->buffer);
46
47 if (stack->off > PageGetMaxOffsetNumber(page))
48 {
49 /*
50 * We scanned the whole page, so we should take right page
51 */
52 if (GinPageRightMost(page))
53 return false; /* no more pages */
54
55 stack->buffer = ginStepRight(stack->buffer, btree->index, GIN_SHARE);
56 stack->blkno = BufferGetBlockNumber(stack->buffer);
57 stack->off = FirstOffsetNumber;
58 PredicateLockPage(btree->index, stack->blkno, snapshot);
59 }
60
61 return true;
62}
63
64/*
65 * Scan all pages of a posting tree and save all its heap ItemPointers
66 * in scanEntry->matchBitmap
67 */
68static void
70 BlockNumber rootPostingTree)
71{
72 GinBtreeData btree;
73 GinBtreeStack *stack;
74 Buffer buffer;
75 Page page;
76
77 /* Descend to the leftmost leaf page */
78 stack = ginScanBeginPostingTree(&btree, index, rootPostingTree);
79 buffer = stack->buffer;
80
81 IncrBufferRefCount(buffer); /* prevent unpin in freeGinBtreeStack */
82
83 freeGinBtreeStack(stack);
84
85 /*
86 * Loop iterates through all leaf pages of posting tree
87 */
88 for (;;)
89 {
90 page = BufferGetPage(buffer);
91 if ((GinPageGetOpaque(page)->flags & GIN_DELETED) == 0)
92 {
93 int n = GinDataLeafPageGetItemsToTbm(page, scanEntry->matchBitmap);
94
95 scanEntry->predictNumberResult += n;
96 }
97
98 if (GinPageRightMost(page))
99 break; /* no more pages */
100
101 buffer = ginStepRight(buffer, index, GIN_SHARE);
102 }
103
104 UnlockReleaseBuffer(buffer);
105}
106
107/*
108 * Collects TIDs into scanEntry->matchBitmap for all heap tuples that
109 * match the search entry. This supports three different match modes:
110 *
111 * 1. Partial-match support: scan from current point until the
112 * comparePartialFn says we're done.
113 * 2. SEARCH_MODE_ALL: scan from current point (which should be first
114 * key for the current attnum) until we hit null items or end of attnum
115 * 3. SEARCH_MODE_EVERYTHING: scan from current point (which should be first
116 * key for the current attnum) until we hit end of attnum
117 *
118 * Returns true if done, false if it's necessary to restart scan from scratch
119 */
120static bool
122 GinScanEntry scanEntry, Snapshot snapshot)
123{
125 CompactAttribute *attr;
126
127 /* Initialize empty bitmap result */
128 scanEntry->matchBitmap = tbm_create(work_mem * (Size) 1024, NULL);
129
130 /* Null query cannot partial-match anything */
131 if (scanEntry->isPartialMatch &&
132 scanEntry->queryCategory != GIN_CAT_NORM_KEY)
133 return true;
134
135 /* Locate tupdesc entry for key column (for attbyval/attlen data) */
136 attnum = scanEntry->attnum;
137 attr = TupleDescCompactAttr(btree->ginstate->origTupdesc, attnum - 1);
138
139 /*
140 * Predicate lock entry leaf page, following pages will be locked by
141 * moveRightIfItNeeded()
142 */
145 snapshot);
146
147 for (;;)
148 {
149 Page page;
150 IndexTuple itup;
151 Datum idatum;
152 GinNullCategory icategory;
153
154 /*
155 * stack->off points to the interested entry, buffer is already locked
156 */
157 if (moveRightIfItNeeded(btree, stack, snapshot) == false)
158 return true;
159
160 page = BufferGetPage(stack->buffer);
161 itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, stack->off));
162
163 /*
164 * If tuple stores another attribute then stop scan
165 */
166 if (gintuple_get_attrnum(btree->ginstate, itup) != attnum)
167 return true;
168
169 /* Safe to fetch attribute value */
170 idatum = gintuple_get_key(btree->ginstate, itup, &icategory);
171
172 /*
173 * Check for appropriate scan stop conditions
174 */
175 if (scanEntry->isPartialMatch)
176 {
177 int32 cmp;
178
179 /*
180 * In partial match, stop scan at any null (including
181 * placeholders); partial matches never match nulls
182 */
183 if (icategory != GIN_CAT_NORM_KEY)
184 return true;
185
186 /*----------
187 * Check of partial match.
188 * case cmp == 0 => match
189 * case cmp > 0 => not match and finish scan
190 * case cmp < 0 => not match and continue scan
191 *----------
192 */
194 btree->ginstate->supportCollation[attnum - 1],
195 scanEntry->queryKey,
196 idatum,
197 UInt16GetDatum(scanEntry->strategy),
198 PointerGetDatum(scanEntry->extra_data)));
199
200 if (cmp > 0)
201 return true;
202 else if (cmp < 0)
203 {
204 stack->off++;
205 continue;
206 }
207 }
208 else if (scanEntry->searchMode == GIN_SEARCH_MODE_ALL)
209 {
210 /*
211 * In ALL mode, we are not interested in null items, so we can
212 * stop if we get to a null-item placeholder (which will be the
213 * last entry for a given attnum). We do want to include NULL_KEY
214 * and EMPTY_ITEM entries, though.
215 */
216 if (icategory == GIN_CAT_NULL_ITEM)
217 return true;
218 }
219
220 /*
221 * OK, we want to return the TIDs listed in this entry.
222 */
223 if (GinIsPostingTree(itup))
224 {
225 BlockNumber rootPostingTree = GinGetPostingTree(itup);
226
227 /*
228 * We should unlock current page (but not unpin) during tree scan
229 * to prevent deadlock with vacuum processes.
230 *
231 * We save current entry value (idatum) to be able to re-find our
232 * tuple after re-locking
233 */
234 if (icategory == GIN_CAT_NORM_KEY)
235 idatum = datumCopy(idatum, attr->attbyval, attr->attlen);
236
238
239 /*
240 * Acquire predicate lock on the posting tree. We already hold a
241 * lock on the entry page, but insertions to the posting tree
242 * don't check for conflicts on that level.
243 */
244 PredicateLockPage(btree->index, rootPostingTree, snapshot);
245
246 /* Collect all the TIDs in this entry's posting tree */
247 scanPostingTree(btree->index, scanEntry, rootPostingTree);
248
249 /*
250 * We lock again the entry page and while it was unlocked insert
251 * might have occurred, so we need to re-find our position.
252 */
253 LockBuffer(stack->buffer, GIN_SHARE);
254 page = BufferGetPage(stack->buffer);
255 if (!GinPageIsLeaf(page))
256 {
257 /*
258 * Root page becomes non-leaf while we unlock it. We will
259 * start again, this situation doesn't occur often - root can
260 * became a non-leaf only once per life of index.
261 */
262 return false;
263 }
264
265 /* Search forward to re-find idatum */
266 for (;;)
267 {
268 if (moveRightIfItNeeded(btree, stack, snapshot) == false)
270 (errcode(ERRCODE_INTERNAL_ERROR),
271 errmsg("failed to re-find tuple within index \"%s\"",
273
274 page = BufferGetPage(stack->buffer);
275 itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, stack->off));
276
277 if (gintuple_get_attrnum(btree->ginstate, itup) == attnum)
278 {
279 Datum newDatum;
280 GinNullCategory newCategory;
281
282 newDatum = gintuple_get_key(btree->ginstate, itup,
283 &newCategory);
284
286 newDatum, newCategory,
287 idatum, icategory) == 0)
288 break; /* Found! */
289 }
290
291 stack->off++;
292 }
293
294 if (icategory == GIN_CAT_NORM_KEY && !attr->attbyval)
295 pfree(DatumGetPointer(idatum));
296 }
297 else
298 {
299 ItemPointer ipd;
300 int nipd;
301
302 ipd = ginReadTuple(btree->ginstate, scanEntry->attnum, itup, &nipd);
303 tbm_add_tuples(scanEntry->matchBitmap, ipd, nipd, false);
304 scanEntry->predictNumberResult += GinGetNPosting(itup);
305 pfree(ipd);
306 }
307
308 /*
309 * Done with this entry, go to the next
310 */
311 stack->off++;
312 }
313}
314
315/*
316 * Start* functions setup beginning state of searches: finds correct buffer and pins it.
317 */
318static void
319startScanEntry(GinState *ginstate, GinScanEntry entry, Snapshot snapshot)
320{
321 GinBtreeData btreeEntry;
322 GinBtreeStack *stackEntry;
323 Page page;
324 bool needUnlock;
325
326restartScanEntry:
327 entry->buffer = InvalidBuffer;
328 ItemPointerSetMin(&entry->curItem);
330 if (entry->list)
331 pfree(entry->list);
332 entry->list = NULL;
333 entry->nlist = 0;
334 entry->matchBitmap = NULL;
335 entry->matchNtuples = -1;
337 entry->reduceResult = false;
338 entry->predictNumberResult = 0;
339
340 /*
341 * we should find entry, and begin scan of posting tree or just store
342 * posting list in memory
343 */
344 ginPrepareEntryScan(&btreeEntry, entry->attnum,
345 entry->queryKey, entry->queryCategory,
346 ginstate);
347 stackEntry = ginFindLeafPage(&btreeEntry, true, false);
348 page = BufferGetPage(stackEntry->buffer);
349
350 /* ginFindLeafPage() will have already checked snapshot age. */
351 needUnlock = true;
352
353 entry->isFinished = true;
354
355 if (entry->isPartialMatch ||
357 {
358 /*
359 * btreeEntry.findItem locates the first item >= given search key.
360 * (For GIN_CAT_EMPTY_QUERY, it will find the leftmost index item
361 * because of the way the GIN_CAT_EMPTY_QUERY category code is
362 * assigned.) We scan forward from there and collect all TIDs needed
363 * for the entry type.
364 */
365 btreeEntry.findItem(&btreeEntry, stackEntry);
366 if (collectMatchBitmap(&btreeEntry, stackEntry, entry, snapshot)
367 == false)
368 {
369 /*
370 * GIN tree was seriously restructured, so we will cleanup all
371 * found data and rescan. See comments near 'return false' in
372 * collectMatchBitmap()
373 */
374 if (entry->matchBitmap)
375 {
376 if (entry->matchIterator)
378 entry->matchIterator = NULL;
379 tbm_free(entry->matchBitmap);
380 entry->matchBitmap = NULL;
381 }
382 LockBuffer(stackEntry->buffer, GIN_UNLOCK);
383 freeGinBtreeStack(stackEntry);
384 goto restartScanEntry;
385 }
386
387 if (entry->matchBitmap && !tbm_is_empty(entry->matchBitmap))
388 {
389 entry->matchIterator =
391 entry->isFinished = false;
392 }
393 }
394 else if (btreeEntry.findItem(&btreeEntry, stackEntry))
395 {
396 IndexTuple itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, stackEntry->off));
397
398 if (GinIsPostingTree(itup))
399 {
400 BlockNumber rootPostingTree = GinGetPostingTree(itup);
401 GinBtreeStack *stack;
402 Page entrypage;
403 ItemPointerData minItem;
404
405 /*
406 * This is an equality scan, so lock the root of the posting tree.
407 * It represents a lock on the exact key value, and covers all the
408 * items in the posting tree.
409 */
410 PredicateLockPage(ginstate->index, rootPostingTree, snapshot);
411
412 /*
413 * We should unlock entry page before touching posting tree to
414 * prevent deadlocks with vacuum processes. Because entry is never
415 * deleted from page and posting tree is never reduced to the
416 * posting list, we can unlock page after getting BlockNumber of
417 * root of posting tree.
418 */
419 LockBuffer(stackEntry->buffer, GIN_UNLOCK);
420 needUnlock = false;
421
422 stack = ginScanBeginPostingTree(&entry->btree, ginstate->index,
423 rootPostingTree);
424 entry->buffer = stack->buffer;
425
426 /*
427 * We keep buffer pinned because we need to prevent deletion of
428 * page during scan. See GIN's vacuum implementation. RefCount is
429 * increased to keep buffer pinned after freeGinBtreeStack() call.
430 */
432
433 entrypage = BufferGetPage(entry->buffer);
434
435 /*
436 * Load the first page into memory.
437 */
438 ItemPointerSetMin(&minItem);
439 entry->list = GinDataLeafPageGetItems(entrypage, &entry->nlist, minItem);
440
441 entry->predictNumberResult = stack->predictNumber * entry->nlist;
442
444 freeGinBtreeStack(stack);
445 entry->isFinished = false;
446 }
447 else
448 {
449 /*
450 * Lock the entry leaf page. This is more coarse-grained than
451 * necessary, because it will conflict with any insertions that
452 * land on the same leaf page, not only the exact key we searched
453 * for. But locking an individual tuple would require updating
454 * that lock whenever it moves because of insertions or vacuums,
455 * which seems too complicated.
456 */
457 PredicateLockPage(ginstate->index,
458 BufferGetBlockNumber(stackEntry->buffer),
459 snapshot);
460 if (GinGetNPosting(itup) > 0)
461 {
462 entry->list = ginReadTuple(ginstate, entry->attnum, itup,
463 &entry->nlist);
464 entry->predictNumberResult = entry->nlist;
465
466 entry->isFinished = false;
467 }
468 }
469 }
470 else
471 {
472 /*
473 * No entry found. Predicate lock the leaf page, to lock the place
474 * where the entry would've been, had there been one.
475 */
476 PredicateLockPage(ginstate->index,
477 BufferGetBlockNumber(stackEntry->buffer), snapshot);
478 }
479
480 if (needUnlock)
481 LockBuffer(stackEntry->buffer, GIN_UNLOCK);
482 freeGinBtreeStack(stackEntry);
483}
484
485/*
486 * Comparison function for scan entry indexes. Sorts by predictNumberResult,
487 * least frequent items first.
488 */
489static int
490entryIndexByFrequencyCmp(const void *a1, const void *a2, void *arg)
491{
492 const GinScanKey key = (const GinScanKey) arg;
493 int i1 = *(const int *) a1;
494 int i2 = *(const int *) a2;
495 uint32 n1 = key->scanEntry[i1]->predictNumberResult;
496 uint32 n2 = key->scanEntry[i2]->predictNumberResult;
497
498 if (n1 < n2)
499 return -1;
500 else if (n1 == n2)
501 return 0;
502 else
503 return 1;
504}
505
506static void
508{
510 int i;
511 int j;
512 int *entryIndexes;
513
514 ItemPointerSetMin(&key->curItem);
515 key->curItemMatches = false;
516 key->recheckCurItem = false;
517 key->isFinished = false;
518
519 /*
520 * Divide the entries into two distinct sets: required and additional.
521 * Additional entries are not enough for a match alone, without any items
522 * from the required set, but are needed by the consistent function to
523 * decide if an item matches. When scanning, we can skip over items from
524 * additional entries that have no corresponding matches in any of the
525 * required entries. That speeds up queries like "frequent & rare"
526 * considerably, if the frequent term can be put in the additional set.
527 *
528 * There can be many legal ways to divide them entries into these two
529 * sets. A conservative division is to just put everything in the required
530 * set, but the more you can put in the additional set, the more you can
531 * skip during the scan. To maximize skipping, we try to put as many
532 * frequent items as possible into additional, and less frequent ones into
533 * required. To do that, sort the entries by frequency
534 * (predictNumberResult), and put entries into the required set in that
535 * order, until the consistent function says that none of the remaining
536 * entries can form a match, without any items from the required set. The
537 * rest go to the additional set.
538 *
539 * Exclude-only scan keys are known to have no required entries.
540 */
541 if (key->excludeOnly)
542 {
544
545 key->nrequired = 0;
546 key->nadditional = key->nentries;
547 key->additionalEntries = palloc(key->nadditional * sizeof(GinScanEntry));
548 for (i = 0; i < key->nadditional; i++)
549 key->additionalEntries[i] = key->scanEntry[i];
550 }
551 else if (key->nentries > 1)
552 {
554
555 entryIndexes = (int *) palloc(sizeof(int) * key->nentries);
556 for (i = 0; i < key->nentries; i++)
557 entryIndexes[i] = i;
558 qsort_arg(entryIndexes, key->nentries, sizeof(int),
560
561 for (i = 1; i < key->nentries; i++)
562 key->entryRes[entryIndexes[i]] = GIN_MAYBE;
563 for (i = 0; i < key->nentries - 1; i++)
564 {
565 /* Pass all entries <= i as FALSE, and the rest as MAYBE */
566 key->entryRes[entryIndexes[i]] = GIN_FALSE;
567
568 if (key->triConsistentFn(key) == GIN_FALSE)
569 break;
570
571 /* Make this loop interruptible in case there are many keys */
573 }
574 /* i is now the last required entry. */
575
577
578 key->nrequired = i + 1;
579 key->nadditional = key->nentries - key->nrequired;
580 key->requiredEntries = palloc(key->nrequired * sizeof(GinScanEntry));
581 key->additionalEntries = palloc(key->nadditional * sizeof(GinScanEntry));
582
583 j = 0;
584 for (i = 0; i < key->nrequired; i++)
585 key->requiredEntries[i] = key->scanEntry[entryIndexes[j++]];
586 for (i = 0; i < key->nadditional; i++)
587 key->additionalEntries[i] = key->scanEntry[entryIndexes[j++]];
588
589 /* clean up after consistentFn calls (also frees entryIndexes) */
591 }
592 else
593 {
595
596 key->nrequired = 1;
597 key->nadditional = 0;
598 key->requiredEntries = palloc(1 * sizeof(GinScanEntry));
599 key->requiredEntries[0] = key->scanEntry[0];
600 }
601 MemoryContextSwitchTo(oldCtx);
602}
603
604static void
606{
608 GinState *ginstate = &so->ginstate;
609 uint32 i;
610
611 for (i = 0; i < so->totalentries; i++)
612 startScanEntry(ginstate, so->entries[i], scan->xs_snapshot);
613
614 if (GinFuzzySearchLimit > 0)
615 {
616 /*
617 * If all of keys more than threshold we will try to reduce result, we
618 * hope (and only hope, for intersection operation of array our
619 * supposition isn't true), that total result will not more than
620 * minimal predictNumberResult.
621 */
622 bool reduce = true;
623
624 for (i = 0; i < so->totalentries; i++)
625 {
627 {
628 reduce = false;
629 break;
630 }
631 }
632 if (reduce)
633 {
634 for (i = 0; i < so->totalentries; i++)
635 {
637 so->entries[i]->reduceResult = true;
638 }
639 }
640 }
641
642 /*
643 * Now that we have the estimates for the entry frequencies, finish
644 * initializing the scan keys.
645 */
646 for (i = 0; i < so->nkeys; i++)
647 startScanKey(ginstate, so, so->keys + i);
648}
649
650/*
651 * Load the next batch of item pointers from a posting tree.
652 *
653 * Note that we copy the page into GinScanEntry->list array and unlock it, but
654 * keep it pinned to prevent interference with vacuum.
655 */
656static void
658 ItemPointerData advancePast)
659{
660 Page page;
661 int i;
662 bool stepright;
663
664 if (!BufferIsValid(entry->buffer))
665 {
666 entry->isFinished = true;
667 return;
668 }
669
670 /*
671 * We have two strategies for finding the correct page: step right from
672 * the current page, or descend the tree again from the root. If
673 * advancePast equals the current item, the next matching item should be
674 * on the next page, so we step right. Otherwise, descend from root.
675 */
676 if (ginCompareItemPointers(&entry->curItem, &advancePast) == 0)
677 {
678 stepright = true;
679 LockBuffer(entry->buffer, GIN_SHARE);
680 }
681 else
682 {
683 GinBtreeStack *stack;
684
685 ReleaseBuffer(entry->buffer);
686
687 /*
688 * Set the search key, and find the correct leaf page.
689 */
690 if (ItemPointerIsLossyPage(&advancePast))
691 {
693 GinItemPointerGetBlockNumber(&advancePast) + 1,
695 }
696 else
697 {
699 GinItemPointerGetBlockNumber(&advancePast),
701 }
702 entry->btree.fullScan = false;
703 stack = ginFindLeafPage(&entry->btree, true, false);
704
705 /* we don't need the stack, just the buffer. */
706 entry->buffer = stack->buffer;
708 freeGinBtreeStack(stack);
709 stepright = false;
710 }
711
712 elog(DEBUG2, "entryLoadMoreItems, %u/%u, skip: %d",
713 GinItemPointerGetBlockNumber(&advancePast),
714 GinItemPointerGetOffsetNumber(&advancePast),
715 !stepright);
716
717 page = BufferGetPage(entry->buffer);
718 for (;;)
719 {
721 if (entry->list)
722 {
723 pfree(entry->list);
724 entry->list = NULL;
725 entry->nlist = 0;
726 }
727
728 if (stepright)
729 {
730 /*
731 * We've processed all the entries on this page. If it was the
732 * last page in the tree, we're done.
733 */
734 if (GinPageRightMost(page))
735 {
737 entry->buffer = InvalidBuffer;
738 entry->isFinished = true;
739 return;
740 }
741
742 /*
743 * Step to next page, following the right link. then find the
744 * first ItemPointer greater than advancePast.
745 */
746 entry->buffer = ginStepRight(entry->buffer,
747 ginstate->index,
748 GIN_SHARE);
749 page = BufferGetPage(entry->buffer);
750 }
751 stepright = true;
752
753 if (GinPageGetOpaque(page)->flags & GIN_DELETED)
754 continue; /* page was deleted by concurrent vacuum */
755
756 /*
757 * The first item > advancePast might not be on this page, but
758 * somewhere to the right, if the page was split, or a non-match from
759 * another key in the query allowed us to skip some items from this
760 * entry. Keep following the right-links until we re-find the correct
761 * page.
762 */
763 if (!GinPageRightMost(page) &&
764 ginCompareItemPointers(&advancePast, GinDataPageGetRightBound(page)) >= 0)
765 {
766 /*
767 * the item we're looking is > the right bound of the page, so it
768 * can't be on this page.
769 */
770 continue;
771 }
772
773 entry->list = GinDataLeafPageGetItems(page, &entry->nlist, advancePast);
774
775 for (i = 0; i < entry->nlist; i++)
776 {
777 if (ginCompareItemPointers(&advancePast, &entry->list[i]) < 0)
778 {
779 entry->offset = i;
780
781 if (GinPageRightMost(page))
782 {
783 /* after processing the copied items, we're done. */
785 entry->buffer = InvalidBuffer;
786 }
787 else
789 return;
790 }
791 }
792 }
793}
794
795#define gin_rand() pg_prng_double(&pg_global_prng_state)
796#define dropItem(e) ( gin_rand() > ((double)GinFuzzySearchLimit)/((double)((e)->predictNumberResult)) )
797
798/*
799 * Sets entry->curItem to next heap item pointer > advancePast, for one entry
800 * of one scan key, or sets entry->isFinished to true if there are no more.
801 *
802 * Item pointers are returned in ascending order.
803 *
804 * Note: this can return a "lossy page" item pointer, indicating that the
805 * entry potentially matches all items on that heap page. However, it is
806 * not allowed to return both a lossy page pointer and exact (regular)
807 * item pointers for the same page. (Doing so would break the key-combination
808 * logic in keyGetItem and scanGetItem; see comment in scanGetItem.) In the
809 * current implementation this is guaranteed by the behavior of tidbitmaps.
810 */
811static void
813 ItemPointerData advancePast)
814{
815 Assert(!entry->isFinished);
816
818 ginCompareItemPointers(&entry->curItem, &advancePast) <= 0);
819
820 if (entry->matchBitmap)
821 {
822 /* A bitmap result */
823 BlockNumber advancePastBlk = GinItemPointerGetBlockNumber(&advancePast);
824 OffsetNumber advancePastOff = GinItemPointerGetOffsetNumber(&advancePast);
825
826 for (;;)
827 {
828 /*
829 * If we've exhausted all items on this block, move to next block
830 * in the bitmap. tbm_private_iterate() sets matchResult.blockno
831 * to InvalidBlockNumber when the bitmap is exhausted.
832 */
833 while ((!BlockNumberIsValid(entry->matchResult.blockno)) ||
834 (!entry->matchResult.lossy &&
835 entry->offset >= entry->matchNtuples) ||
836 entry->matchResult.blockno < advancePastBlk ||
837 (ItemPointerIsLossyPage(&advancePast) &&
838 entry->matchResult.blockno == advancePastBlk))
839 {
840 if (!tbm_private_iterate(entry->matchIterator, &entry->matchResult))
841 {
845 entry->matchIterator = NULL;
846 entry->isFinished = true;
847 break;
848 }
849
850 /* Exact pages need their tuple offsets extracted. */
851 if (!entry->matchResult.lossy)
853 entry->matchOffsets,
855
856 /*
857 * Reset counter to the beginning of entry->matchResult. Note:
858 * entry->offset is still greater than matchResult.ntuples if
859 * matchResult is lossy. So, on next call we will get next
860 * result from TIDBitmap.
861 */
862 entry->offset = 0;
863 }
864 if (entry->isFinished)
865 break;
866
867 /*
868 * We're now on the first page after advancePast which has any
869 * items on it. If it's a lossy result, return that.
870 */
871 if (entry->matchResult.lossy)
872 {
874 entry->matchResult.blockno);
875
876 /*
877 * We might as well fall out of the loop; we could not
878 * estimate number of results on this page to support correct
879 * reducing of result even if it's enabled.
880 */
881 break;
882 }
883
884 /*
885 * Not a lossy page. If tuple offsets were extracted,
886 * entry->matchNtuples must be > -1
887 */
888 Assert(entry->matchNtuples > -1);
889
890 /* Skip over any offsets <= advancePast, and return that. */
891 if (entry->matchResult.blockno == advancePastBlk)
892 {
893 Assert(entry->matchNtuples > 0);
894
895 /*
896 * First, do a quick check against the last offset on the
897 * page. If that's > advancePast, so are all the other
898 * offsets, so just go back to the top to get the next page.
899 */
900 if (entry->matchOffsets[entry->matchNtuples - 1] <= advancePastOff)
901 {
902 entry->offset = entry->matchNtuples;
903 continue;
904 }
905
906 /* Otherwise scan to find the first item > advancePast */
907 while (entry->matchOffsets[entry->offset] <= advancePastOff)
908 entry->offset++;
909 }
910
911 ItemPointerSet(&entry->curItem,
912 entry->matchResult.blockno,
913 entry->matchOffsets[entry->offset]);
914 entry->offset++;
915
916 /* Done unless we need to reduce the result */
917 if (!entry->reduceResult || !dropItem(entry))
918 break;
919 }
920 }
921 else if (!BufferIsValid(entry->buffer))
922 {
923 /*
924 * A posting list from an entry tuple, or the last page of a posting
925 * tree.
926 */
927 for (;;)
928 {
929 if (entry->offset >= entry->nlist)
930 {
932 entry->isFinished = true;
933 break;
934 }
935
936 entry->curItem = entry->list[entry->offset++];
937
938 /* If we're not past advancePast, keep scanning */
939 if (ginCompareItemPointers(&entry->curItem, &advancePast) <= 0)
940 continue;
941
942 /* Done unless we need to reduce the result */
943 if (!entry->reduceResult || !dropItem(entry))
944 break;
945 }
946 }
947 else
948 {
949 /* A posting tree */
950 for (;;)
951 {
952 /* If we've processed the current batch, load more items */
953 while (entry->offset >= entry->nlist)
954 {
955 entryLoadMoreItems(ginstate, entry, advancePast);
956
957 if (entry->isFinished)
958 {
960 return;
961 }
962 }
963
964 entry->curItem = entry->list[entry->offset++];
965
966 /* If we're not past advancePast, keep scanning */
967 if (ginCompareItemPointers(&entry->curItem, &advancePast) <= 0)
968 continue;
969
970 /* Done unless we need to reduce the result */
971 if (!entry->reduceResult || !dropItem(entry))
972 break;
973
974 /*
975 * Advance advancePast (so that entryLoadMoreItems will load the
976 * right data), and keep scanning
977 */
978 advancePast = entry->curItem;
979 }
980 }
981}
982
983/*
984 * Identify the "current" item among the input entry streams for this scan key
985 * that is greater than advancePast, and test whether it passes the scan key
986 * qual condition.
987 *
988 * The current item is the smallest curItem among the inputs. key->curItem
989 * is set to that value. key->curItemMatches is set to indicate whether that
990 * TID passes the consistentFn test. If so, key->recheckCurItem is set true
991 * iff recheck is needed for this item pointer (including the case where the
992 * item pointer is a lossy page pointer).
993 *
994 * If all entry streams are exhausted, sets key->isFinished to true.
995 *
996 * Item pointers must be returned in ascending order.
997 *
998 * Note: this can return a "lossy page" item pointer, indicating that the
999 * key potentially matches all items on that heap page. However, it is
1000 * not allowed to return both a lossy page pointer and exact (regular)
1001 * item pointers for the same page. (Doing so would break the key-combination
1002 * logic in scanGetItem.)
1003 */
1004static void
1006 ItemPointerData advancePast)
1007{
1008 ItemPointerData minItem;
1009 ItemPointerData curPageLossy;
1010 uint32 i;
1011 bool haveLossyEntry;
1012 GinScanEntry entry;
1013 GinTernaryValue res;
1014 MemoryContext oldCtx;
1015 bool allFinished;
1016
1017 Assert(!key->isFinished);
1018
1019 /*
1020 * We might have already tested this item; if so, no need to repeat work.
1021 * (Note: the ">" case can happen, if advancePast is exact but we
1022 * previously had to set curItem to a lossy-page pointer.)
1023 */
1024 if (ginCompareItemPointers(&key->curItem, &advancePast) > 0)
1025 return;
1026
1027 /*
1028 * Find the minimum item > advancePast among the active entry streams.
1029 *
1030 * Note: a lossy-page entry is encoded by a ItemPointer with max value for
1031 * offset (0xffff), so that it will sort after any exact entries for the
1032 * same page. So we'll prefer to return exact pointers not lossy
1033 * pointers, which is good.
1034 */
1035 ItemPointerSetMax(&minItem);
1036 allFinished = true;
1037 for (i = 0; i < key->nrequired; i++)
1038 {
1039 entry = key->requiredEntries[i];
1040
1041 if (entry->isFinished)
1042 continue;
1043
1044 /*
1045 * Advance this stream if necessary.
1046 *
1047 * In particular, since entry->curItem was initialized with
1048 * ItemPointerSetMin, this ensures we fetch the first item for each
1049 * entry on the first call.
1050 */
1051 if (ginCompareItemPointers(&entry->curItem, &advancePast) <= 0)
1052 {
1053 entryGetItem(ginstate, entry, advancePast);
1054 if (entry->isFinished)
1055 continue;
1056 }
1057
1058 allFinished = false;
1059 if (ginCompareItemPointers(&entry->curItem, &minItem) < 0)
1060 minItem = entry->curItem;
1061 }
1062
1063 if (allFinished && !key->excludeOnly)
1064 {
1065 /* all entries are finished */
1066 key->isFinished = true;
1067 return;
1068 }
1069
1070 if (!key->excludeOnly)
1071 {
1072 /*
1073 * For a normal scan key, we now know there are no matches < minItem.
1074 *
1075 * If minItem is lossy, it means that there were no exact items on the
1076 * page among requiredEntries, because lossy pointers sort after exact
1077 * items. However, there might be exact items for the same page among
1078 * additionalEntries, so we mustn't advance past them.
1079 */
1080 if (ItemPointerIsLossyPage(&minItem))
1081 {
1082 if (GinItemPointerGetBlockNumber(&advancePast) <
1084 {
1085 ItemPointerSet(&advancePast,
1088 }
1089 }
1090 else
1091 {
1093 ItemPointerSet(&advancePast,
1096 }
1097 }
1098 else
1099 {
1100 /*
1101 * excludeOnly scan keys don't have any entries that are necessarily
1102 * present in matching items. So, we consider the item just after
1103 * advancePast.
1104 */
1105 Assert(key->nrequired == 0);
1106 ItemPointerSet(&minItem,
1107 GinItemPointerGetBlockNumber(&advancePast),
1109 }
1110
1111 /*
1112 * We might not have loaded all the entry streams for this TID yet. We
1113 * could call the consistent function, passing MAYBE for those entries, to
1114 * see if it can decide if this TID matches based on the information we
1115 * have. But if the consistent-function is expensive, and cannot in fact
1116 * decide with partial information, that could be a big loss. So, load all
1117 * the additional entries, before calling the consistent function.
1118 */
1119 for (i = 0; i < key->nadditional; i++)
1120 {
1121 entry = key->additionalEntries[i];
1122
1123 if (entry->isFinished)
1124 continue;
1125
1126 if (ginCompareItemPointers(&entry->curItem, &advancePast) <= 0)
1127 {
1128 entryGetItem(ginstate, entry, advancePast);
1129 if (entry->isFinished)
1130 continue;
1131 }
1132
1133 /*
1134 * Normally, none of the items in additionalEntries can have a curItem
1135 * larger than minItem. But if minItem is a lossy page, then there
1136 * might be exact items on the same page among additionalEntries.
1137 */
1138 if (ginCompareItemPointers(&entry->curItem, &minItem) < 0)
1139 {
1140 Assert(ItemPointerIsLossyPage(&minItem));
1141 minItem = entry->curItem;
1142 }
1143 }
1144
1145 /*
1146 * Ok, we've advanced all the entries up to minItem now. Set key->curItem,
1147 * and perform consistentFn test.
1148 *
1149 * Lossy-page entries pose a problem, since we don't know the correct
1150 * entryRes state to pass to the consistentFn, and we also don't know what
1151 * its combining logic will be (could be AND, OR, or even NOT). If the
1152 * logic is OR then the consistentFn might succeed for all items in the
1153 * lossy page even when none of the other entries match.
1154 *
1155 * Our strategy is to call the tri-state consistent function, with the
1156 * lossy-page entries set to MAYBE, and all the other entries FALSE. If it
1157 * returns FALSE, none of the lossy items alone are enough for a match, so
1158 * we don't need to return a lossy-page pointer. Otherwise, return a
1159 * lossy-page pointer to indicate that the whole heap page must be
1160 * checked. (On subsequent calls, we'll do nothing until minItem is past
1161 * the page altogether, thus ensuring that we never return both regular
1162 * and lossy pointers for the same page.)
1163 *
1164 * An exception is that it doesn't matter what we pass for lossy pointers
1165 * in "hidden" entries, because the consistentFn's result can't depend on
1166 * them. We could pass them as MAYBE as well, but if we're using the
1167 * "shim" implementation of a tri-state consistent function (see
1168 * ginlogic.c), it's better to pass as few MAYBEs as possible. So pass
1169 * them as true.
1170 *
1171 * Note that only lossy-page entries pointing to the current item's page
1172 * should trigger this processing; we might have future lossy pages in the
1173 * entry array, but they aren't relevant yet.
1174 */
1175 key->curItem = minItem;
1176 ItemPointerSetLossyPage(&curPageLossy,
1178 haveLossyEntry = false;
1179 for (i = 0; i < key->nentries; i++)
1180 {
1181 entry = key->scanEntry[i];
1182 if (entry->isFinished == false &&
1183 ginCompareItemPointers(&entry->curItem, &curPageLossy) == 0)
1184 {
1185 if (i < key->nuserentries)
1186 key->entryRes[i] = GIN_MAYBE;
1187 else
1188 key->entryRes[i] = GIN_TRUE;
1189 haveLossyEntry = true;
1190 }
1191 else
1192 key->entryRes[i] = GIN_FALSE;
1193 }
1194
1195 /* prepare for calling consistentFn in temp context */
1196 oldCtx = MemoryContextSwitchTo(tempCtx);
1197
1198 if (haveLossyEntry)
1199 {
1200 /* Have lossy-page entries, so see if whole page matches */
1201 res = key->triConsistentFn(key);
1202
1203 if (res == GIN_TRUE || res == GIN_MAYBE)
1204 {
1205 /* Yes, so clean up ... */
1206 MemoryContextSwitchTo(oldCtx);
1207 MemoryContextReset(tempCtx);
1208
1209 /* and return lossy pointer for whole page */
1210 key->curItem = curPageLossy;
1211 key->curItemMatches = true;
1212 key->recheckCurItem = true;
1213 return;
1214 }
1215 }
1216
1217 /*
1218 * At this point we know that we don't need to return a lossy whole-page
1219 * pointer, but we might have matches for individual exact item pointers,
1220 * possibly in combination with a lossy pointer. Pass lossy pointers as
1221 * MAYBE to the ternary consistent function, to let it decide if this
1222 * tuple satisfies the overall key, even though we don't know if the lossy
1223 * entries match.
1224 *
1225 * Prepare entryRes array to be passed to consistentFn.
1226 */
1227 for (i = 0; i < key->nentries; i++)
1228 {
1229 entry = key->scanEntry[i];
1230 if (entry->isFinished)
1231 key->entryRes[i] = GIN_FALSE;
1232#if 0
1233
1234 /*
1235 * This case can't currently happen, because we loaded all the entries
1236 * for this item earlier.
1237 */
1238 else if (ginCompareItemPointers(&entry->curItem, &advancePast) <= 0)
1239 key->entryRes[i] = GIN_MAYBE;
1240#endif
1241 else if (ginCompareItemPointers(&entry->curItem, &curPageLossy) == 0)
1242 key->entryRes[i] = GIN_MAYBE;
1243 else if (ginCompareItemPointers(&entry->curItem, &minItem) == 0)
1244 key->entryRes[i] = GIN_TRUE;
1245 else
1246 key->entryRes[i] = GIN_FALSE;
1247 }
1248
1249 res = key->triConsistentFn(key);
1250
1251 switch (res)
1252 {
1253 case GIN_TRUE:
1254 key->curItemMatches = true;
1255 /* triConsistentFn set recheckCurItem */
1256 break;
1257
1258 case GIN_FALSE:
1259 key->curItemMatches = false;
1260 break;
1261
1262 case GIN_MAYBE:
1263 key->curItemMatches = true;
1264 key->recheckCurItem = true;
1265 break;
1266
1267 default:
1268
1269 /*
1270 * the 'default' case shouldn't happen, but if the consistent
1271 * function returns something bogus, this is the safe result
1272 */
1273 key->curItemMatches = true;
1274 key->recheckCurItem = true;
1275 break;
1276 }
1277
1278 /*
1279 * We have a tuple, and we know if it matches or not. If it's a non-match,
1280 * we could continue to find the next matching tuple, but let's break out
1281 * and give scanGetItem a chance to advance the other keys. They might be
1282 * able to skip past to a much higher TID, allowing us to save work.
1283 */
1284
1285 /* clean up after consistentFn calls */
1286 MemoryContextSwitchTo(oldCtx);
1287 MemoryContextReset(tempCtx);
1288}
1289
1290/*
1291 * Get next heap item pointer (after advancePast) from scan.
1292 * Returns true if anything found.
1293 * On success, *item and *recheck are set.
1294 *
1295 * Note: this is very nearly the same logic as in keyGetItem(), except
1296 * that we know the keys are to be combined with AND logic, whereas in
1297 * keyGetItem() the combination logic is known only to the consistentFn.
1298 */
1299static bool
1301 ItemPointerData *item, bool *recheck)
1302{
1303 GinScanOpaque so = (GinScanOpaque) scan->opaque;
1304 uint32 i;
1305 bool match;
1306
1307 /*----------
1308 * Advance the scan keys in lock-step, until we find an item that matches
1309 * all the keys. If any key reports isFinished, meaning its subset of the
1310 * entries is exhausted, we can stop. Otherwise, set *item to the next
1311 * matching item.
1312 *
1313 * This logic works only if a keyGetItem stream can never contain both
1314 * exact and lossy pointers for the same page. Else we could have a
1315 * case like
1316 *
1317 * stream 1 stream 2
1318 * ... ...
1319 * 42/6 42/7
1320 * 50/1 42/0xffff
1321 * ... ...
1322 *
1323 * We would conclude that 42/6 is not a match and advance stream 1,
1324 * thus never detecting the match to the lossy pointer in stream 2.
1325 * (keyGetItem has a similar problem versus entryGetItem.)
1326 *----------
1327 */
1328 do
1329 {
1330 ItemPointerSetMin(item);
1331 match = true;
1332 for (i = 0; i < so->nkeys && match; i++)
1333 {
1334 GinScanKey key = so->keys + i;
1335
1336 /*
1337 * If we're considering a lossy page, skip excludeOnly keys. They
1338 * can't exclude the whole page anyway.
1339 */
1340 if (ItemPointerIsLossyPage(item) && key->excludeOnly)
1341 {
1342 /*
1343 * ginNewScanKey() should never mark the first key as
1344 * excludeOnly.
1345 */
1346 Assert(i > 0);
1347 continue;
1348 }
1349
1350 /* Fetch the next item for this key that is > advancePast. */
1351 keyGetItem(&so->ginstate, so->tempCtx, key, advancePast);
1352
1353 if (key->isFinished)
1354 return false;
1355
1356 /*
1357 * If it's not a match, we can immediately conclude that nothing
1358 * <= this item matches, without checking the rest of the keys.
1359 */
1360 if (!key->curItemMatches)
1361 {
1362 advancePast = key->curItem;
1363 match = false;
1364 break;
1365 }
1366
1367 /*
1368 * It's a match. We can conclude that nothing < matches, so the
1369 * other key streams can skip to this item.
1370 *
1371 * Beware of lossy pointers, though; from a lossy pointer, we can
1372 * only conclude that nothing smaller than this *block* matches.
1373 */
1374 if (ItemPointerIsLossyPage(&key->curItem))
1375 {
1376 if (GinItemPointerGetBlockNumber(&advancePast) <
1378 {
1379 ItemPointerSet(&advancePast,
1382 }
1383 }
1384 else
1385 {
1387 ItemPointerSet(&advancePast,
1390 }
1391
1392 /*
1393 * If this is the first key, remember this location as a potential
1394 * match, and proceed to check the rest of the keys.
1395 *
1396 * Otherwise, check if this is the same item that we checked the
1397 * previous keys for (or a lossy pointer for the same page). If
1398 * not, loop back to check the previous keys for this item (we
1399 * will check this key again too, but keyGetItem returns quickly
1400 * for that)
1401 */
1402 if (i == 0)
1403 {
1404 *item = key->curItem;
1405 }
1406 else
1407 {
1408 if (ItemPointerIsLossyPage(&key->curItem) ||
1410 {
1412 match = (GinItemPointerGetBlockNumber(&key->curItem) ==
1414 }
1415 else
1416 {
1417 Assert(ginCompareItemPointers(&key->curItem, item) >= 0);
1418 match = (ginCompareItemPointers(&key->curItem, item) == 0);
1419 }
1420 }
1421 }
1422 } while (!match);
1423
1424 Assert(!ItemPointerIsMin(item));
1425
1426 /*
1427 * Now *item contains the first ItemPointer after previous result that
1428 * satisfied all the keys for that exact TID, or a lossy reference to the
1429 * same page.
1430 *
1431 * We must return recheck = true if any of the keys are marked recheck.
1432 */
1433 *recheck = false;
1434 for (i = 0; i < so->nkeys; i++)
1435 {
1436 GinScanKey key = so->keys + i;
1437
1438 if (key->recheckCurItem)
1439 {
1440 *recheck = true;
1441 break;
1442 }
1443 }
1444
1445 return true;
1446}
1447
1448
1449/*
1450 * Functions for scanning the pending list
1451 */
1452
1453
1454/*
1455 * Get ItemPointer of next heap row to be checked from pending list.
1456 * Returns false if there are no more. On pages with several heap rows
1457 * it returns each row separately, on page with part of heap row returns
1458 * per page data. pos->firstOffset and pos->lastOffset are set to identify
1459 * the range of pending-list tuples belonging to this heap row.
1460 *
1461 * The pendingBuffer is presumed pinned and share-locked on entry, and is
1462 * pinned and share-locked on success exit. On failure exit it's released.
1463 */
1464static bool
1466{
1467 OffsetNumber maxoff;
1468 Page page;
1469 IndexTuple itup;
1470
1472 for (;;)
1473 {
1474 page = BufferGetPage(pos->pendingBuffer);
1475
1476 maxoff = PageGetMaxOffsetNumber(page);
1477 if (pos->firstOffset > maxoff)
1478 {
1479 BlockNumber blkno = GinPageGetOpaque(page)->rightlink;
1480
1481 if (blkno == InvalidBlockNumber)
1482 {
1485
1486 return false;
1487 }
1488 else
1489 {
1490 /*
1491 * Here we must prevent deletion of next page by insertcleanup
1492 * process, which may be trying to obtain exclusive lock on
1493 * current page. So, we lock next page before releasing the
1494 * current one
1495 */
1496 Buffer tmpbuf = ReadBuffer(scan->indexRelation, blkno);
1497
1500
1501 pos->pendingBuffer = tmpbuf;
1503 }
1504 }
1505 else
1506 {
1507 itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, pos->firstOffset));
1508 pos->item = itup->t_tid;
1509 if (GinPageHasFullRow(page))
1510 {
1511 /*
1512 * find itempointer to the next row
1513 */
1514 for (pos->lastOffset = pos->firstOffset + 1; pos->lastOffset <= maxoff; pos->lastOffset++)
1515 {
1516 itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, pos->lastOffset));
1517 if (!ItemPointerEquals(&pos->item, &itup->t_tid))
1518 break;
1519 }
1520 }
1521 else
1522 {
1523 /*
1524 * All itempointers are the same on this page
1525 */
1526 pos->lastOffset = maxoff + 1;
1527 }
1528
1529 /*
1530 * Now pos->firstOffset points to the first tuple of current heap
1531 * row, pos->lastOffset points to the first tuple of next heap row
1532 * (or to the end of page)
1533 */
1534 break;
1535 }
1536 }
1537
1538 return true;
1539}
1540
1541/*
1542 * Scan pending-list page from current tuple (off) up till the first of:
1543 * - match is found (then returns true)
1544 * - no later match is possible
1545 * - tuple's attribute number is not equal to entry's attrnum
1546 * - reach end of page
1547 *
1548 * datum[]/category[]/datumExtracted[] arrays are used to cache the results
1549 * of gintuple_get_key() on the current page.
1550 */
1551static bool
1553 OffsetNumber off, OffsetNumber maxoff,
1554 GinScanEntry entry,
1555 Datum *datum, GinNullCategory *category,
1556 bool *datumExtracted)
1557{
1558 IndexTuple itup;
1559 int32 cmp;
1560
1561 /* Partial match to a null is not possible */
1562 if (entry->queryCategory != GIN_CAT_NORM_KEY)
1563 return false;
1564
1565 while (off < maxoff)
1566 {
1567 itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, off));
1568
1569 if (gintuple_get_attrnum(ginstate, itup) != entry->attnum)
1570 return false;
1571
1572 if (datumExtracted[off - 1] == false)
1573 {
1574 datum[off - 1] = gintuple_get_key(ginstate, itup,
1575 &category[off - 1]);
1576 datumExtracted[off - 1] = true;
1577 }
1578
1579 /* Once we hit nulls, no further match is possible */
1580 if (category[off - 1] != GIN_CAT_NORM_KEY)
1581 return false;
1582
1583 /*----------
1584 * Check partial match.
1585 * case cmp == 0 => match
1586 * case cmp > 0 => not match and end scan (no later match possible)
1587 * case cmp < 0 => not match and continue scan
1588 *----------
1589 */
1591 ginstate->supportCollation[entry->attnum - 1],
1592 entry->queryKey,
1593 datum[off - 1],
1594 UInt16GetDatum(entry->strategy),
1595 PointerGetDatum(entry->extra_data)));
1596 if (cmp == 0)
1597 return true;
1598 else if (cmp > 0)
1599 return false;
1600
1601 off++;
1602 }
1603
1604 return false;
1605}
1606
1607/*
1608 * Set up the entryRes array for each key by looking at
1609 * every entry for current heap row in pending list.
1610 *
1611 * Returns true if each scan key has at least one entryRes match.
1612 * This corresponds to the situations where the normal index search will
1613 * try to apply the key's consistentFn. (A tuple not meeting that requirement
1614 * cannot be returned by the normal search since no entry stream will
1615 * source its TID.)
1616 *
1617 * The pendingBuffer is presumed pinned and share-locked on entry.
1618 */
1619static bool
1621{
1622 GinScanOpaque so = (GinScanOpaque) scan->opaque;
1623 OffsetNumber attrnum;
1624 Page page;
1625 IndexTuple itup;
1626 int i,
1627 j;
1628
1629 /*
1630 * Reset all entryRes and hasMatchKey flags
1631 */
1632 for (i = 0; i < so->nkeys; i++)
1633 {
1634 GinScanKey key = so->keys + i;
1635
1636 memset(key->entryRes, GIN_FALSE, key->nentries);
1637 }
1638 memset(pos->hasMatchKey, false, so->nkeys);
1639
1640 /*
1641 * Outer loop iterates over multiple pending-list pages when a single heap
1642 * row has entries spanning those pages.
1643 */
1644 for (;;)
1645 {
1646 Datum datum[BLCKSZ / sizeof(IndexTupleData)];
1647 GinNullCategory category[BLCKSZ / sizeof(IndexTupleData)];
1648 bool datumExtracted[BLCKSZ / sizeof(IndexTupleData)];
1649
1650 Assert(pos->lastOffset > pos->firstOffset);
1651 memset(datumExtracted + pos->firstOffset - 1, 0,
1652 sizeof(bool) * (pos->lastOffset - pos->firstOffset));
1653
1654 page = BufferGetPage(pos->pendingBuffer);
1655
1656 for (i = 0; i < so->nkeys; i++)
1657 {
1658 GinScanKey key = so->keys + i;
1659
1660 for (j = 0; j < key->nentries; j++)
1661 {
1662 GinScanEntry entry = key->scanEntry[j];
1663 OffsetNumber StopLow = pos->firstOffset,
1664 StopHigh = pos->lastOffset,
1665 StopMiddle;
1666
1667 /* If already matched on earlier page, do no extra work */
1668 if (key->entryRes[j])
1669 continue;
1670
1671 /*
1672 * Interesting tuples are from pos->firstOffset to
1673 * pos->lastOffset and they are ordered by (attnum, Datum) as
1674 * it's done in entry tree. So we can use binary search to
1675 * avoid linear scanning.
1676 */
1677 while (StopLow < StopHigh)
1678 {
1679 int res;
1680
1681 StopMiddle = StopLow + ((StopHigh - StopLow) >> 1);
1682
1683 itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, StopMiddle));
1684
1685 attrnum = gintuple_get_attrnum(&so->ginstate, itup);
1686
1687 if (key->attnum < attrnum)
1688 {
1689 StopHigh = StopMiddle;
1690 continue;
1691 }
1692 if (key->attnum > attrnum)
1693 {
1694 StopLow = StopMiddle + 1;
1695 continue;
1696 }
1697
1698 if (datumExtracted[StopMiddle - 1] == false)
1699 {
1700 datum[StopMiddle - 1] =
1701 gintuple_get_key(&so->ginstate, itup,
1702 &category[StopMiddle - 1]);
1703 datumExtracted[StopMiddle - 1] = true;
1704 }
1705
1706 if (entry->queryCategory == GIN_CAT_EMPTY_QUERY)
1707 {
1708 /* special behavior depending on searchMode */
1709 if (entry->searchMode == GIN_SEARCH_MODE_ALL)
1710 {
1711 /* match anything except NULL_ITEM */
1712 if (category[StopMiddle - 1] == GIN_CAT_NULL_ITEM)
1713 res = -1;
1714 else
1715 res = 0;
1716 }
1717 else
1718 {
1719 /* match everything */
1720 res = 0;
1721 }
1722 }
1723 else
1724 {
1725 res = ginCompareEntries(&so->ginstate,
1726 entry->attnum,
1727 entry->queryKey,
1728 entry->queryCategory,
1729 datum[StopMiddle - 1],
1730 category[StopMiddle - 1]);
1731 }
1732
1733 if (res == 0)
1734 {
1735 /*
1736 * Found exact match (there can be only one, except in
1737 * EMPTY_QUERY mode).
1738 *
1739 * If doing partial match, scan forward from here to
1740 * end of page to check for matches.
1741 *
1742 * See comment above about tuple's ordering.
1743 */
1744 if (entry->isPartialMatch)
1745 key->entryRes[j] =
1747 page,
1748 StopMiddle,
1749 pos->lastOffset,
1750 entry,
1751 datum,
1752 category,
1753 datumExtracted);
1754 else
1755 key->entryRes[j] = true;
1756
1757 /* done with binary search */
1758 break;
1759 }
1760 else if (res < 0)
1761 StopHigh = StopMiddle;
1762 else
1763 StopLow = StopMiddle + 1;
1764 }
1765
1766 if (StopLow >= StopHigh && entry->isPartialMatch)
1767 {
1768 /*
1769 * No exact match on this page. If doing partial match,
1770 * scan from the first tuple greater than target value to
1771 * end of page. Note that since we don't remember whether
1772 * the comparePartialFn told us to stop early on a
1773 * previous page, we will uselessly apply comparePartialFn
1774 * to the first tuple on each subsequent page.
1775 */
1776 key->entryRes[j] =
1778 page,
1779 StopHigh,
1780 pos->lastOffset,
1781 entry,
1782 datum,
1783 category,
1784 datumExtracted);
1785 }
1786
1787 pos->hasMatchKey[i] |= key->entryRes[j];
1788 }
1789 }
1790
1791 /* Advance firstOffset over the scanned tuples */
1792 pos->firstOffset = pos->lastOffset;
1793
1794 if (GinPageHasFullRow(page))
1795 {
1796 /*
1797 * We have examined all pending entries for the current heap row.
1798 * Break out of loop over pages.
1799 */
1800 break;
1801 }
1802 else
1803 {
1804 /*
1805 * Advance to next page of pending entries for the current heap
1806 * row. Complain if there isn't one.
1807 */
1808 ItemPointerData item = pos->item;
1809
1810 if (scanGetCandidate(scan, pos) == false ||
1811 !ItemPointerEquals(&pos->item, &item))
1812 elog(ERROR, "could not find additional pending pages for same heap tuple");
1813 }
1814 }
1815
1816 /*
1817 * All scan keys except excludeOnly require at least one entry to match.
1818 * excludeOnly keys are an exception, because their implied
1819 * GIN_CAT_EMPTY_QUERY scanEntry always matches. So return "true" if all
1820 * non-excludeOnly scan keys have at least one match.
1821 */
1822 for (i = 0; i < so->nkeys; i++)
1823 {
1824 if (pos->hasMatchKey[i] == false && !so->keys[i].excludeOnly)
1825 return false;
1826 }
1827
1828 return true;
1829}
1830
1831/*
1832 * Collect all matched rows from pending list into bitmap.
1833 */
1834static void
1836{
1837 GinScanOpaque so = (GinScanOpaque) scan->opaque;
1838 MemoryContext oldCtx;
1839 bool recheck,
1840 match;
1841 int i;
1842 pendingPosition pos;
1844 Page page;
1845 BlockNumber blkno;
1846
1847 *ntids = 0;
1848
1849 /*
1850 * Acquire predicate lock on the metapage, to conflict with any fastupdate
1851 * insertions.
1852 */
1854
1855 LockBuffer(metabuffer, GIN_SHARE);
1856 page = BufferGetPage(metabuffer);
1857 blkno = GinPageGetMeta(page)->head;
1858
1859 /*
1860 * fetch head of list before unlocking metapage. head page must be pinned
1861 * to prevent deletion by vacuum process
1862 */
1863 if (blkno == InvalidBlockNumber)
1864 {
1865 /* No pending list, so proceed with normal scan */
1866 UnlockReleaseBuffer(metabuffer);
1867 return;
1868 }
1869
1870 pos.pendingBuffer = ReadBuffer(scan->indexRelation, blkno);
1871 LockBuffer(pos.pendingBuffer, GIN_SHARE);
1872 pos.firstOffset = FirstOffsetNumber;
1873 UnlockReleaseBuffer(metabuffer);
1874 pos.hasMatchKey = palloc(sizeof(bool) * so->nkeys);
1875
1876 /*
1877 * loop for each heap row. scanGetCandidate returns full row or row's
1878 * tuples from first page.
1879 */
1880 while (scanGetCandidate(scan, &pos))
1881 {
1882 /*
1883 * Check entries in tuple and set up entryRes array.
1884 *
1885 * If pending tuples belonging to the current heap row are spread
1886 * across several pages, collectMatchesForHeapRow will read all of
1887 * those pages.
1888 */
1889 if (!collectMatchesForHeapRow(scan, &pos))
1890 continue;
1891
1892 /*
1893 * Matching of entries of one row is finished, so check row using
1894 * consistent functions.
1895 */
1896 oldCtx = MemoryContextSwitchTo(so->tempCtx);
1897 recheck = false;
1898 match = true;
1899
1900 for (i = 0; i < so->nkeys; i++)
1901 {
1902 GinScanKey key = so->keys + i;
1903
1904 if (!key->boolConsistentFn(key))
1905 {
1906 match = false;
1907 break;
1908 }
1909 recheck |= key->recheckCurItem;
1910 }
1911
1912 MemoryContextSwitchTo(oldCtx);
1914
1915 if (match)
1916 {
1917 tbm_add_tuples(tbm, &pos.item, 1, recheck);
1918 (*ntids)++;
1919 }
1920 }
1921
1922 pfree(pos.hasMatchKey);
1923}
1924
1925
1926#define GinIsVoidRes(s) ( ((GinScanOpaque) scan->opaque)->isVoidRes )
1927
1928int64
1930{
1931 GinScanOpaque so = (GinScanOpaque) scan->opaque;
1932 int64 ntids;
1933 ItemPointerData iptr;
1934 bool recheck;
1935
1936 /*
1937 * Set up the scan keys, and check for unsatisfiable query.
1938 */
1939 ginFreeScanKeys(so); /* there should be no keys yet, but just to be
1940 * sure */
1941 ginNewScanKey(scan);
1942
1943 if (GinIsVoidRes(scan))
1944 return 0;
1945
1946 ntids = 0;
1947
1948 /*
1949 * First, scan the pending list and collect any matching entries into the
1950 * bitmap. After we scan a pending item, some other backend could post it
1951 * into the main index, and so we might visit it a second time during the
1952 * main scan. This is okay because we'll just re-set the same bit in the
1953 * bitmap. (The possibility of duplicate visits is a major reason why GIN
1954 * can't support the amgettuple API, however.) Note that it would not do
1955 * to scan the main index before the pending list, since concurrent
1956 * cleanup could then make us miss entries entirely.
1957 */
1958 scanPendingInsert(scan, tbm, &ntids);
1959
1960 /*
1961 * Now scan the main index.
1962 */
1963 startScan(scan);
1964
1965 ItemPointerSetMin(&iptr);
1966
1967 for (;;)
1968 {
1970
1971 if (!scanGetItem(scan, iptr, &iptr, &recheck))
1972 break;
1973
1974 if (ItemPointerIsLossyPage(&iptr))
1976 else
1977 tbm_add_tuples(tbm, &iptr, 1, recheck);
1978 ntids++;
1979 }
1980
1981 return ntids;
1982}
uint32 BlockNumber
Definition: block.h:31
#define InvalidBlockNumber
Definition: block.h:33
static bool BlockNumberIsValid(BlockNumber blockNumber)
Definition: block.h:71
int Buffer
Definition: buf.h:23
#define InvalidBuffer
Definition: buf.h:25
void IncrBufferRefCount(Buffer buffer)
Definition: bufmgr.c:4884
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:3730
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:4852
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:4869
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:5086
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
Definition: bufmgr.c:748
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:400
static bool BufferIsValid(Buffer bufnum)
Definition: bufmgr.h:351
static Item PageGetItem(const PageData *page, const ItemIdData *itemId)
Definition: bufpage.h:354
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition: bufpage.h:244
PageData * Page
Definition: bufpage.h:82
static OffsetNumber PageGetMaxOffsetNumber(const PageData *page)
Definition: bufpage.h:372
int64_t int64
Definition: c.h:499
int32_t int32
Definition: c.h:498
uint32_t uint32
Definition: c.h:502
size_t Size
Definition: c.h:576
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:132
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define DEBUG2
Definition: elog.h:29
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define ereport(elevel,...)
Definition: elog.h:149
Datum FunctionCall4Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4)
Definition: fmgr.c:1196
#define GIN_SEARCH_MODE_ALL
Definition: gin.h:38
#define GIN_FALSE
Definition: gin.h:76
char GinTernaryValue
Definition: gin.h:71
#define GIN_MAYBE
Definition: gin.h:78
#define GIN_TRUE
Definition: gin.h:77
GinScanOpaqueData * GinScanOpaque
Definition: gin_private.h:394
static int ginCompareItemPointers(ItemPointer a, ItemPointer b)
Definition: gin_private.h:496
#define GIN_UNLOCK
Definition: gin_private.h:49
struct GinScanKeyData * GinScanKey
Definition: gin_private.h:265
#define GIN_SHARE
Definition: gin_private.h:50
#define ItemPointerSetLossyPage(p, b)
Definition: ginblock.h:173
#define GinIsPostingTree(itup)
Definition: ginblock.h:231
#define GinItemPointerGetOffsetNumber(pointer)
Definition: ginblock.h:146
#define GIN_METAPAGE_BLKNO
Definition: ginblock.h:51
#define GinPageHasFullRow(page)
Definition: ginblock.h:119
#define GinPageGetOpaque(page)
Definition: ginblock.h:110
#define ItemPointerIsMin(p)
Definition: ginblock.h:168
#define GIN_CAT_NORM_KEY
Definition: ginblock.h:208
#define GIN_DELETED
Definition: ginblock.h:43
#define GinGetNPosting(itup)
Definition: ginblock.h:228
#define ItemPointerSetMax(p)
Definition: ginblock.h:171
#define GinDataPageGetRightBound(page)
Definition: ginblock.h:288
#define GinGetPostingTree(itup)
Definition: ginblock.h:233
#define ItemPointerIsLossyPage(p)
Definition: ginblock.h:175
signed char GinNullCategory
Definition: ginblock.h:206
#define GinPageRightMost(page)
Definition: ginblock.h:129
#define GIN_CAT_NULL_ITEM
Definition: ginblock.h:211
#define ItemPointerSetMin(p)
Definition: ginblock.h:166
#define GinPageGetMeta(p)
Definition: ginblock.h:104
#define GIN_CAT_EMPTY_QUERY
Definition: ginblock.h:212
#define GinItemPointerGetBlockNumber(pointer)
Definition: ginblock.h:143
#define GinPageIsLeaf(page)
Definition: ginblock.h:112
void freeGinBtreeStack(GinBtreeStack *stack)
Definition: ginbtree.c:198
GinBtreeStack * ginFindLeafPage(GinBtree btree, bool searchMode, bool rootConflictCheck)
Definition: ginbtree.c:83
Buffer ginStepRight(Buffer buffer, Relation index, int lockmode)
Definition: ginbtree.c:177
GinBtreeStack * ginScanBeginPostingTree(GinBtree btree, Relation index, BlockNumber rootBlkno)
Definition: gindatapage.c:1936
int GinDataLeafPageGetItemsToTbm(Page page, TIDBitmap *tbm)
Definition: gindatapage.c:182
ItemPointer GinDataLeafPageGetItems(Page page, int *nitems, ItemPointerData advancePast)
Definition: gindatapage.c:135
ItemPointer ginReadTuple(GinState *ginstate, OffsetNumber attnum, IndexTuple itup, int *nitems)
Definition: ginentrypage.c:162
void ginPrepareEntryScan(GinBtree btree, OffsetNumber attnum, Datum key, GinNullCategory category, GinState *ginstate)
Definition: ginentrypage.c:747
int64 gingetbitmap(IndexScanDesc scan, TIDBitmap *tbm)
Definition: ginget.c:1929
static void scanPendingInsert(IndexScanDesc scan, TIDBitmap *tbm, int64 *ntids)
Definition: ginget.c:1835
static void startScan(IndexScanDesc scan)
Definition: ginget.c:605
struct pendingPosition pendingPosition
static void startScanEntry(GinState *ginstate, GinScanEntry entry, Snapshot snapshot)
Definition: ginget.c:319
static void startScanKey(GinState *ginstate, GinScanOpaque so, GinScanKey key)
Definition: ginget.c:507
#define GinIsVoidRes(s)
Definition: ginget.c:1926
static bool scanGetItem(IndexScanDesc scan, ItemPointerData advancePast, ItemPointerData *item, bool *recheck)
Definition: ginget.c:1300
int GinFuzzySearchLimit
Definition: ginget.c:27
static bool matchPartialInPendingList(GinState *ginstate, Page page, OffsetNumber off, OffsetNumber maxoff, GinScanEntry entry, Datum *datum, GinNullCategory *category, bool *datumExtracted)
Definition: ginget.c:1552
static bool scanGetCandidate(IndexScanDesc scan, pendingPosition *pos)
Definition: ginget.c:1465
static void scanPostingTree(Relation index, GinScanEntry scanEntry, BlockNumber rootPostingTree)
Definition: ginget.c:69
static bool moveRightIfItNeeded(GinBtreeData *btree, GinBtreeStack *stack, Snapshot snapshot)
Definition: ginget.c:43
static int entryIndexByFrequencyCmp(const void *a1, const void *a2, void *arg)
Definition: ginget.c:490
#define dropItem(e)
Definition: ginget.c:796
static bool collectMatchBitmap(GinBtreeData *btree, GinBtreeStack *stack, GinScanEntry scanEntry, Snapshot snapshot)
Definition: ginget.c:121
static bool collectMatchesForHeapRow(IndexScanDesc scan, pendingPosition *pos)
Definition: ginget.c:1620
static void keyGetItem(GinState *ginstate, MemoryContext tempCtx, GinScanKey key, ItemPointerData advancePast)
Definition: ginget.c:1005
static void entryGetItem(GinState *ginstate, GinScanEntry entry, ItemPointerData advancePast)
Definition: ginget.c:812
static void entryLoadMoreItems(GinState *ginstate, GinScanEntry entry, ItemPointerData advancePast)
Definition: ginget.c:657
void ginFreeScanKeys(GinScanOpaque so)
Definition: ginscan.c:239
void ginNewScanKey(IndexScanDesc scan)
Definition: ginscan.c:269
OffsetNumber gintuple_get_attrnum(GinState *ginstate, IndexTuple tuple)
Definition: ginutil.c:231
Datum gintuple_get_key(GinState *ginstate, IndexTuple tuple, GinNullCategory *category)
Definition: ginutil.c:264
int ginCompareEntries(GinState *ginstate, OffsetNumber attnum, Datum a, GinNullCategory categorya, Datum b, GinNullCategory categoryb)
Definition: ginutil.c:393
int work_mem
Definition: globals.c:130
Assert(PointerIsAligned(start, uint64))
for(;;)
static const FormData_pg_attribute a1
Definition: heap.c:144
static const FormData_pg_attribute a2
Definition: heap.c:157
int j
Definition: isn.c:75
int i
Definition: isn.c:74
bool ItemPointerEquals(ItemPointer pointer1, ItemPointer pointer2)
Definition: itemptr.c:35
static void ItemPointerSet(ItemPointerData *pointer, BlockNumber blockNumber, OffsetNumber offNum)
Definition: itemptr.h:135
static void ItemPointerSetInvalid(ItemPointerData *pointer)
Definition: itemptr.h:184
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition: itemptr.h:103
static bool ItemPointerIsValid(const ItemPointerData *pointer)
Definition: itemptr.h:83
IndexTupleData * IndexTuple
Definition: itup.h:53
struct IndexTupleData IndexTupleData
void MemoryContextReset(MemoryContext context)
Definition: mcxt.c:383
void pfree(void *pointer)
Definition: mcxt.c:1524
void * palloc(Size size)
Definition: mcxt.c:1317
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:122
#define InvalidOffsetNumber
Definition: off.h:26
#define OffsetNumberNext(offsetNumber)
Definition: off.h:52
uint16 OffsetNumber
Definition: off.h:24
#define FirstOffsetNumber
Definition: off.h:27
#define OffsetNumberPrev(offsetNumber)
Definition: off.h:54
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
static void reduce(void)
Definition: parse.c:260
int16 attnum
Definition: pg_attribute.h:74
void * arg
void qsort_arg(void *base, size_t nel, size_t elsize, qsort_arg_comparator cmp, void *arg)
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:327
uintptr_t Datum
Definition: postgres.h:69
static Datum UInt16GetDatum(uint16 X)
Definition: postgres.h:197
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:317
static int32 DatumGetInt32(Datum X)
Definition: postgres.h:207
void PredicateLockPage(Relation relation, BlockNumber blkno, Snapshot snapshot)
Definition: predicate.c:2589
static int cmp(const chr *x, const chr *y, size_t len)
Definition: regc_locale.c:743
#define RelationGetRelationName(relation)
Definition: rel.h:546
int16 attlen
Definition: tupdesc.h:71
GinState * ginstate
Definition: gin_private.h:170
bool(* findItem)(GinBtree, GinBtreeStack *)
Definition: gin_private.h:157
ItemPointerData itemptr
Definition: gin_private.h:180
Relation index
Definition: gin_private.h:168
OffsetNumber off
Definition: gin_private.h:134
uint32 predictNumber
Definition: gin_private.h:137
BlockNumber blkno
Definition: gin_private.h:132
ItemPointerData curItem
Definition: gin_private.h:352
GinBtreeData btree
Definition: gin_private.h:374
TBMIterateResult matchResult
Definition: gin_private.h:362
OffsetNumber matchOffsets[TBM_MAX_TUPLES_PER_PAGE]
Definition: gin_private.h:363
TIDBitmap * matchBitmap
Definition: gin_private.h:355
ItemPointerData * list
Definition: gin_private.h:367
TBMPrivateIterator * matchIterator
Definition: gin_private.h:356
GinNullCategory queryCategory
Definition: gin_private.h:341
StrategyNumber strategy
Definition: gin_private.h:344
Pointer extra_data
Definition: gin_private.h:343
OffsetNumber offset
Definition: gin_private.h:369
uint32 predictNumberResult
Definition: gin_private.h:373
OffsetNumber attnum
Definition: gin_private.h:346
GinScanKey keys
Definition: gin_private.h:382
MemoryContext keyCtx
Definition: gin_private.h:389
GinScanEntry * entries
Definition: gin_private.h:385
MemoryContext tempCtx
Definition: gin_private.h:379
FmgrInfo comparePartialFn[INDEX_MAX_KEYS]
Definition: gin_private.h:84
TupleDesc origTupdesc
Definition: gin_private.h:73
Relation index
Definition: gin_private.h:59
Oid supportCollation[INDEX_MAX_KEYS]
Definition: gin_private.h:88
Relation indexRelation
Definition: relscan.h:137
struct SnapshotData * xs_snapshot
Definition: relscan.h:138
ItemPointerData t_tid
Definition: itup.h:37
BlockNumber blockno
Definition: tidbitmap.h:64
Definition: type.h:96
Buffer pendingBuffer
Definition: ginget.c:31
OffsetNumber lastOffset
Definition: ginget.c:33
OffsetNumber firstOffset
Definition: ginget.c:32
bool * hasMatchKey
Definition: ginget.c:35
ItemPointerData item
Definition: ginget.c:34
void tbm_free(TIDBitmap *tbm)
Definition: tidbitmap.c:311
void tbm_add_tuples(TIDBitmap *tbm, const ItemPointer tids, int ntids, bool recheck)
Definition: tidbitmap.c:366
bool tbm_is_empty(const TIDBitmap *tbm)
Definition: tidbitmap.c:659
bool tbm_private_iterate(TBMPrivateIterator *iterator, TBMIterateResult *tbmres)
Definition: tidbitmap.c:977
void tbm_add_page(TIDBitmap *tbm, BlockNumber pageno)
Definition: tidbitmap.c:432
int tbm_extract_page_tuple(TBMIterateResult *iteritem, OffsetNumber *offsets, uint32 max_offsets)
Definition: tidbitmap.c:901
void tbm_end_private_iterate(TBMPrivateIterator *iterator)
Definition: tidbitmap.c:1150
TIDBitmap * tbm_create(Size maxbytes, dsa_area *dsa)
Definition: tidbitmap.c:255
TBMPrivateIterator * tbm_begin_private_iterate(TIDBitmap *tbm)
Definition: tidbitmap.c:678
#define TBM_MAX_TUPLES_PER_PAGE
Definition: tidbitmap.h:35
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:169
static StringInfoData tmpbuf
Definition: walsender.c:171