Loading...
Searching...
No Matches
brin.c File Reference
#include "postgres.h"#include "access/brin.h"#include "access/brin_page.h"#include "access/brin_pageops.h"#include "access/brin_xlog.h"#include "access/relation.h"#include "access/reloptions.h"#include "access/relscan.h"#include "access/table.h"#include "access/tableam.h"#include "access/xloginsert.h"#include "catalog/index.h"#include "catalog/pg_am.h"#include "commands/vacuum.h"#include "miscadmin.h"#include "pgstat.h"#include "postmaster/autovacuum.h"#include "storage/bufmgr.h"#include "storage/freespace.h"#include "tcop/tcopprot.h"#include "utils/acl.h"#include "utils/datum.h"#include "utils/fmgrprotos.h"#include "utils/guc.h"#include "utils/index_selfuncs.h"#include "utils/memutils.h"#include "utils/rel.h"#include "utils/tuplesort.h"
Include dependency graph for brin.c:
Go to the source code of this file.
Data Structures | |
| struct | BrinShared |
| struct | BrinLeader |
| struct | BrinBuildState |
| struct | BrinInsertState |
| struct | BrinOpaque |
Macros | |
| #define | PARALLEL_KEY_BRIN_SHARED UINT64CONST(0xB000000000000001) |
| #define | PARALLEL_KEY_TUPLESORT UINT64CONST(0xB000000000000002) |
| #define | PARALLEL_KEY_QUERY_TEXT UINT64CONST(0xB000000000000003) |
| #define | PARALLEL_KEY_WAL_USAGE UINT64CONST(0xB000000000000004) |
| #define | PARALLEL_KEY_BUFFER_USAGE UINT64CONST(0xB000000000000005) |
| #define | ParallelTableScanFromBrinShared(shared) (ParallelTableScanDesc) ((char *) (shared) + BUFFERALIGN(sizeof(BrinShared))) |
| #define | BRIN_ALL_BLOCKRANGES InvalidBlockNumber |
Macro Definition Documentation
◆ BRIN_ALL_BLOCKRANGES
| #define BRIN_ALL_BLOCKRANGES InvalidBlockNumber |
◆ PARALLEL_KEY_BRIN_SHARED
| #define PARALLEL_KEY_BRIN_SHARED UINT64CONST(0xB000000000000001) |
◆ PARALLEL_KEY_BUFFER_USAGE
| #define PARALLEL_KEY_BUFFER_USAGE UINT64CONST(0xB000000000000005) |
◆ PARALLEL_KEY_QUERY_TEXT
| #define PARALLEL_KEY_QUERY_TEXT UINT64CONST(0xB000000000000003) |
◆ PARALLEL_KEY_TUPLESORT
| #define PARALLEL_KEY_TUPLESORT UINT64CONST(0xB000000000000002) |
◆ PARALLEL_KEY_WAL_USAGE
| #define PARALLEL_KEY_WAL_USAGE UINT64CONST(0xB000000000000004) |
◆ ParallelTableScanFromBrinShared
| #define ParallelTableScanFromBrinShared | ( | shared | ) | (ParallelTableScanDesc) ((char *) (shared) + BUFFERALIGN(sizeof(BrinShared))) |
Definition at line 116 of file brin.c.
122{
123 /* parallel context itself */
124 ParallelContext *pcxt;
125
126 /*
127 * nparticipanttuplesorts is the exact number of worker processes
128 * successfully launched, plus one leader process if it participates as a
129 * worker (only DISABLE_LEADER_PARTICIPATION builds avoid leader
130 * participating as a worker).
131 */
132 int nparticipanttuplesorts;
133
134 /*
135 * Leader process convenience pointers to shared state (leader avoids TOC
136 * lookups).
137 *
138 * brinshared is the shared state for entire build. sharedsort is the
139 * shared, tuplesort-managed state passed to each process tuplesort.
140 * snapshot is the snapshot used by the scan iff an MVCC snapshot is
141 * required.
142 */
143 BrinShared *brinshared;
144 Sharedsort *sharedsort;
145 Snapshot snapshot;
146 WalUsage *walusage;
147 BufferUsage *bufferusage;
148} BrinLeader;
149
150/*
151 * We use a BrinBuildState during initial construction of a BRIN index.
152 * The running state is kept in a BrinMemTuple.
153 */
155{
166
170
171 /*
172 * bs_leader is only present when a parallel index build is performed, and
173 * only in the leader process. (Actually, only the leader process has a
174 * BrinBuildState.)
175 */
178
179 /*
180 * The sortstate is used by workers (including the leader). It has to be
181 * part of the build state, because that's the only thing passed to the
182 * build callback etc.
183 */
185} BrinBuildState;
186
187/*
188 * We use a BrinInsertState to capture running state spanning multiple
189 * brininsert invocations, within the same command.
190 */
192{
196} BrinInsertState;
197
198/*
199 * Struct used as "opaque" during index scans
200 */
202{
206} BrinOpaque;
207
208#define BRIN_ALL_BLOCKRANGES InvalidBlockNumber
209
212 BlockNumber pagesPerRange,
228
229/* parallel index builds */
239 BrinShared *brinshared,
240 Sharedsort *sharedsort,
243
244/*
245 * BRIN handler function: return IndexAmRoutine with access method parameters
246 * and callbacks.
247 */
248Datum
250{
253 .amstrategies = 0,
254 .amsupport = BRIN_LAST_OPTIONAL_PROCNUM,
255 .amoptsprocnum = BRIN_PROCNUM_OPTIONS,
256 .amcanorder = false,
257 .amcanorderbyop = false,
258 .amcanhash = false,
259 .amconsistentequality = false,
260 .amconsistentordering = false,
261 .amcanbackward = false,
262 .amcanunique = false,
263 .amcanmulticol = true,
264 .amoptionalkey = true,
265 .amsearcharray = false,
266 .amsearchnulls = true,
267 .amstorage = true,
268 .amclusterable = false,
269 .ampredlocks = false,
270 .amcanparallel = false,
271 .amcanbuildparallel = true,
272 .amcaninclude = false,
273 .amusemaintenanceworkmem = false,
274 .amsummarizing = true,
275 .amparallelvacuumoptions =
277 .amkeytype = InvalidOid,
278
279 .ambuild = brinbuild,
280 .ambuildempty = brinbuildempty,
281 .aminsert = brininsert,
282 .aminsertcleanup = brininsertcleanup,
283 .ambulkdelete = brinbulkdelete,
284 .amvacuumcleanup = brinvacuumcleanup,
285 .amcanreturn = NULL,
286 .amcostestimate = brincostestimate,
287 .amgettreeheight = NULL,
288 .amoptions = brinoptions,
289 .amproperty = NULL,
290 .ambuildphasename = NULL,
291 .amvalidate = brinvalidate,
292 .amadjustmembers = NULL,
293 .ambeginscan = brinbeginscan,
294 .amrescan = brinrescan,
295 .amgettuple = NULL,
296 .amgetbitmap = bringetbitmap,
297 .amendscan = brinendscan,
298 .ammarkpos = NULL,
299 .amrestrpos = NULL,
300 .amestimateparallelscan = NULL,
301 .aminitparallelscan = NULL,
302 .amparallelrescan = NULL,
303 .amtranslatestrategy = NULL,
304 .amtranslatecmptype = NULL,
305 };
306
308}
309
310/*
311 * Initialize a BrinInsertState to maintain state to be used across multiple
312 * tuple inserts, within the same command.
313 */
316{
317 BrinInsertState *bistate;
319
324 &bistate->bis_pages_per_range);
325 indexInfo->ii_AmCache = bistate;
327
328 return bistate;
329}
330
331/*
332 * A tuple in the heap is being inserted. To keep a brin index up to date,
333 * we need to obtain the relevant index tuple and compare its stored values
334 * with those of the new tuple. If the tuple values are not consistent with
335 * the summary tuple, we need to update the index tuple.
336 *
337 * If autosummarization is enabled, check if we need to summarize the previous
338 * page range.
339 *
340 * If the range is not currently summarized (i.e. the revmap returns NULL for
341 * it), there's nothing to do for this tuple.
342 */
343bool
348 IndexInfo *indexInfo)
349{
350 BlockNumber pagesPerRange;
352 BlockNumber heapBlk;
360
361 /*
362 * If first time through in this statement, initialize the insert state
363 * that we keep for all the inserts in the command.
364 */
365 if (!bistate)
367
368 revmap = bistate->bis_rmAccess;
369 bdesc = bistate->bis_desc;
370 pagesPerRange = bistate->bis_pages_per_range;
371
372 /*
373 * origHeapBlk is the block number where the insertion occurred. heapBlk
374 * is the first block in the corresponding page range.
375 */
377 heapBlk = (origHeapBlk / pagesPerRange) * pagesPerRange;
378
379 for (;;)
380 {
382 OffsetNumber off;
385
386 CHECK_FOR_INTERRUPTS();
387
388 /*
389 * If auto-summarization is enabled and we just inserted the first
390 * tuple into the first block of a new non-first page range, request a
391 * summarization run of the previous range.
392 */
393 if (autosummarize &&
394 heapBlk > 0 &&
395 heapBlk == origHeapBlk &&
397 {
400
401 lastPageTuple =
405 {
407
410 lastPageRange);
416 lastPageRange)));
417 }
418 else
420 }
421
424
425 /* if range is unsummarized, there's nothing to do */
427 break;
428
429 /* First time through in this brininsert call? */
431 {
433 "brininsert cxt",
434 ALLOCSET_DEFAULT_SIZES);
436 }
437
439
441
443 {
444 /*
445 * The tuple is consistent with the new values, so there's nothing
446 * to do.
447 */
449 }
450 else
451 {
459
460 /*
461 * Make a copy of the old tuple, so that we can compare it after
462 * re-acquiring the lock.
463 */
466
467 /*
468 * Before releasing the lock, check if we can attempt a same-page
469 * update. Another process could insert a tuple concurrently in
470 * the same page though, so downstream we must be prepared to cope
471 * if this turns out to not be possible after all.
472 */
476
477 /*
478 * Try to update the tuple. If this doesn't work for whatever
479 * reason, we need to restart from the top; the revmap might be
480 * pointing at a different tuple for this block now, so we need to
481 * recompute to ensure both our new heap tuple and the other
482 * inserter's are covered by the combined tuple. It might be that
483 * we don't need to update at all.
484 */
487 samepage))
488 {
489 /* no luck; start over */
491 continue;
492 }
493 }
494
495 /* success! */
496 break;
497 }
498
504
505 return false;
506}
507
508/*
509 * Callback to clean up the BrinInsertState once all tuple inserts are done.
510 */
511void
513{
515
516 /* bail out if cache not initialized */
518 return;
519
520 /* do this first to avoid dangling pointer if we fail partway through */
521 indexInfo->ii_AmCache = NULL;
522
523 /*
524 * Clean up the revmap. Note that the brinDesc has already been cleaned up
525 * as part of its own memory context.
526 */
527 brinRevmapTerminate(bistate->bis_rmAccess);
528 pfree(bistate);
529}
530
531/*
532 * Initialize state for a BRIN index scan.
533 *
534 * We read the metapage here to determine the pages-per-range number that this
535 * index was built with. Note that since this cannot be changed while we're
536 * holding lock on index, it's not necessary to recompute it during brinrescan.
537 */
540{
541 IndexScanDesc scan;
542 BrinOpaque *opaque;
543
544 scan = RelationGetIndexScan(r, nkeys, norderbys);
545
549 scan->opaque = opaque;
550
551 return scan;
552}
553
554/*
555 * Execute the index scan.
556 *
557 * This works by reading index TIDs from the revmap, and obtaining the index
558 * tuples pointed to by them; the summary values in the index tuples are
559 * compared to the scan keys. We return into the TID bitmap all the pages in
560 * ranges corresponding to index tuples that match the scan keys.
561 *
562 * If a TID from the revmap is read as InvalidTID, we know that range is
563 * unsummarized. Pages in those ranges need to be returned regardless of scan
564 * keys.
565 */
566int64
568{
572 Oid heapOid;
573 Relation heapRel;
574 BrinOpaque *opaque;
575 BlockNumber nblocks;
577 FmgrInfo *consistentFn;
583 ScanKey **keys,
584 **nullkeys;
585 int *nkeys,
586 *nnullkeys;
587 char *ptr;
590
592 bdesc = opaque->bo_bdesc;
594 if (scan->instrument)
595 scan->instrument->nsearches++;
596
597 /*
598 * We need to know the size of the table so that we know how long to
599 * iterate on the revmap.
600 */
603 nblocks = RelationGetNumberOfBlocks(heapRel);
605
606 /*
607 * Make room for the consistent support procedures of indexed columns. We
608 * don't look them up here; we do that lazily the first time we see a scan
609 * key reference each of them. We rely on zeroing fn_oid to InvalidOid.
610 */
612
613 /*
614 * Make room for per-attribute lists of scan keys that we'll pass to the
615 * consistent support procedure. We don't know which attributes have scan
616 * keys, so we allocate space for all attributes. That may use more memory
617 * but it's probably cheaper than determining which attributes are used.
618 *
619 * We keep null and regular keys separate, so that we can pass just the
620 * regular keys to the consistent function easily.
621 *
622 * To reduce the allocation overhead, we allocate one big chunk and then
623 * carve it into smaller arrays ourselves. All the pieces have exactly the
624 * same lifetime, so that's OK.
625 *
626 * XXX The widest index can have 32 attributes, so the amount of wasted
627 * memory is negligible. We could invent a more compact approach (with
628 * just space for used attributes) but that would make the matching more
629 * complex so it's not a good trade-off.
630 */
631 len =
638
640 tmp = ptr;
641
642 keys = (ScanKey **) ptr;
644
645 nullkeys = (ScanKey **) ptr;
647
648 nkeys = (int *) ptr;
650
653
655 {
658
661 }
662
664
665 /* zero the number of keys */
668
669 /* Preprocess the scan keys - split them into per-attribute arrays. */
670 for (int keyno = 0; keyno < scan->numberOfKeys; keyno++)
671 {
674
675 /*
676 * The collation of the scan key must match the collation used in the
677 * index column (but only if the search is not IS NULL/ IS NOT NULL).
678 * Otherwise we shouldn't be using this index ...
679 */
681 (key->sk_collation ==
683 keyattno - 1)->attcollation));
684
685 /*
686 * First time we see this index attribute, so init as needed.
687 *
688 * This is a bit of an overkill - we don't know how many scan keys are
689 * there for this attribute, so we simply allocate the largest number
690 * possible (as if all keys were for this attribute). This may waste a
691 * bit of memory, but we only expect small number of scan keys in
692 * general, so this should be negligible, and repeated repalloc calls
693 * are not free either.
694 */
696 {
697 FmgrInfo *tmp;
698
699 /* First time we see this attribute, so no key/null keys. */
702
704 BRIN_PROCNUM_CONSISTENT);
706 CurrentMemoryContext);
707 }
708
709 /* Add key to the proper per-attribute array. */
711 {
714 }
715 else
716 {
718 nkeys[keyattno - 1]++;
719 }
720 }
721
722 /* allocate an initial in-memory tuple, out of the per-range memcxt */
724
725 /*
726 * Setup and use a per-range memory context, which is reset every time we
727 * loop below. This avoids having to free the tuples within the loop.
728 */
730 "bringetbitmap cxt",
731 ALLOCSET_DEFAULT_SIZES);
733
734 /*
735 * Now scan the revmap. We start by querying for heap page 0,
736 * incrementing by the number of pages per range; this gives us a full
737 * view of the table. We make use of uint64 for heapBlk as a BlockNumber
738 * could wrap for tables with close to 2^32 pages.
739 */
741 {
745 OffsetNumber off;
746 Size size;
747
748 CHECK_FOR_INTERRUPTS();
749
751
753 &off, &size, BUFFER_LOCK_SHARE);
755 {
759 }
760
761 /*
762 * For page ranges with no indexed tuple, we must return the whole
763 * range; otherwise, compare it to the scan keys.
764 */
766 {
768 }
769 else
770 {
773 {
774 /*
775 * Placeholder tuples are always returned, regardless of the
776 * values stored in them.
777 */
779 }
780 else
781 {
782 int attno;
783
784 /*
785 * Compare scan keys with summary values stored for the range.
786 * If scan keys are matched, the page range must be added to
787 * the bitmap. We initially assume the range needs to be
788 * added; in particular this serves the case where there are
789 * no keys.
790 */
793 {
794 BrinValues *bval;
796 Oid collation;
797
798 /*
799 * skip attributes without any scan keys (both regular and
800 * IS [NOT] NULL)
801 */
803 continue;
804
805 bval = &dtup->bt_columns[attno - 1];
806
807 /*
808 * If the BRIN tuple indicates that this range is empty,
809 * we can skip it: there's nothing to match. We don't
810 * need to examine the next columns.
811 */
813 {
815 break;
816 }
817
818 /*
819 * First check if there are any IS [NOT] NULL scan keys,
820 * and if we're violating them. In that case we can
821 * terminate early, without invoking the support function.
822 *
823 * As there may be more keys, we can only determine
824 * mismatch within this loop.
825 */
827 !check_null_keys(bval, nullkeys[attno - 1],
828 nnullkeys[attno - 1]))
829 {
830 /*
831 * If any of the IS [NOT] NULL keys failed, the page
832 * range as a whole can't pass. So terminate the loop.
833 */
835 break;
836 }
837
838 /*
839 * So either there are no IS [NOT] NULL keys, or all
840 * passed. If there are no regular scan keys, we're done -
841 * the page range matches. If there are regular keys, but
842 * the page range is marked as 'all nulls' it can't
843 * possibly pass (we're assuming the operators are
844 * strict).
845 */
846
847 /* No regular scan keys - page range as a whole passes. */
848 if (!nkeys[attno - 1])
849 continue;
850
851 Assert((nkeys[attno - 1] > 0) &&
852 (nkeys[attno - 1] <= scan->numberOfKeys));
853
854 /* If it is all nulls, it cannot possibly be consistent. */
856 {
858 break;
859 }
860
861 /*
862 * Collation from the first key (has to be the same for
863 * all keys for the same attribute).
864 */
865 collation = keys[attno - 1][0]->sk_collation;
866
867 /*
868 * Check whether the scan key is consistent with the page
869 * range values; if so, have the pages in the range added
870 * to the output bitmap.
871 *
872 * The opclass may or may not support processing of
873 * multiple scan keys. We can determine that based on the
874 * number of arguments - functions with extra parameter
875 * (number of scan keys) do support this, otherwise we
876 * have to simply pass the scan keys one by one.
877 */
878 if (consistentFn[attno - 1].fn_nargs >= 4)
879 {
880 /* Check all keys at once */
882 collation,
884 PointerGetDatum(bval),
885 PointerGetDatum(keys[attno - 1]),
886 Int32GetDatum(nkeys[attno - 1]));
888 }
889 else
890 {
891 /*
892 * Check keys one by one
893 *
894 * When there are multiple scan keys, failure to meet
895 * the criteria for a single one of them is enough to
896 * discard the range as a whole, so break out of the
897 * loop as soon as a false return value is obtained.
898 */
899 int keyno;
900
901 for (keyno = 0; keyno < nkeys[attno - 1]; keyno++)
902 {
904 keys[attno - 1][keyno]->sk_collation,
906 PointerGetDatum(bval),
907 PointerGetDatum(keys[attno - 1][keyno]));
910 break;
911 }
912 }
913
914 /*
915 * If we found a scan key eliminating the range, no need
916 * to check additional ones.
917 */
919 break;
920 }
921 }
922 }
923
924 /* add the pages in the range to the output bitmap, if needed */
926 {
927 uint64 pageno;
928
929 for (pageno = heapBlk;
930 pageno <= Min(nblocks, heapBlk + opaque->bo_pagesPerRange) - 1;
931 pageno++)
932 {
934 tbm_add_page(tbm, pageno);
935 totalpages++;
937 }
938 }
939 }
940
943
946
947 /*
948 * XXX We have an approximation of the number of *pages* that our scan
949 * returns, but we don't have a precise idea of the number of heap tuples
950 * involved.
951 */
953}
954
955/*
956 * Re-initialize state for a BRIN index scan
957 */
958void
961{
962 /*
963 * Other index AMs preprocess the scan keys at this point, or sometime
964 * early during the scan; this lets them optimize by removing redundant
965 * keys, or doing early returns when they are impossible to satisfy; see
966 * _bt_preprocess_keys for an example. Something like that could be added
967 * here someday, too.
968 */
969
972}
973
974/*
975 * Close down a BRIN index scan
976 */
977void
979{
981
982 brinRevmapTerminate(opaque->bo_rmAccess);
983 brin_free_desc(opaque->bo_bdesc);
984 pfree(opaque);
985}
986
987/*
988 * Per-heap-tuple callback for table_index_build_scan.
989 *
990 * Note we don't worry about the page range at the end of the table here; it is
991 * present in the build state struct after we're called the last time, but not
992 * inserted into the index. Caller must ensure to do so, if appropriate.
993 */
994static void
996 ItemPointer tid,
998 bool *isnull,
1001{
1004
1006
1007 /*
1008 * If we're in a block that belongs to a future range, summarize what
1009 * we've got and start afresh. Note the scan might have skipped many
1010 * pages, if they were devoid of live tuples; make sure to insert index
1011 * tuples for those too.
1012 */
1014 {
1015
1017 "brinbuildCallback: completed a range: %u--%u",
1018 state->bs_currRangeStart,
1020
1021 /* create the index tuple and insert it */
1023
1024 /* set state to correspond to the next range */
1026
1027 /* re-initialize state for it */
1029 }
1030
1031 /* Accumulate the current tuple into the running state */
1033 values, isnull);
1034}
1035
1036/*
1037 * Per-heap-tuple callback for table_index_build_scan with parallelism.
1038 *
1039 * A version of the callback used by parallel index builds. The main difference
1040 * is that instead of writing the BRIN tuples into the index, we write them
1041 * into a shared tuplesort, and leave the insertion up to the leader (which may
1042 * reorder them a bit etc.). The callback also does not generate empty ranges,
1043 * those will be added by the leader when merging results from workers.
1044 */
1045static void
1047 ItemPointer tid,
1049 bool *isnull,
1052{
1055
1057
1058 /*
1059 * If we're in a block that belongs to a different range, summarize what
1060 * we've got and start afresh. Note the scan might have skipped many
1061 * pages, if they were devoid of live tuples; we do not create empty BRIN
1062 * ranges here - the leader is responsible for filling them in.
1063 *
1064 * Unlike serial builds, parallel index builds allow synchronized seqscans
1065 * (because that's what parallel scans do). This means the block may wrap
1066 * around to the beginning of the relation, so the condition needs to
1067 * check for both future and past ranges.
1068 */
1071 {
1072
1074 "brinbuildCallbackParallel: completed a range: %u--%u",
1075 state->bs_currRangeStart,
1077
1078 /* create the index tuple and write it into the tuplesort */
1080
1081 /*
1082 * Set state to correspond to the next range (for this block).
1083 *
1084 * This skips ranges that are either empty (and so we don't get any
1085 * tuples to summarize), or processed by other workers. We can't
1086 * differentiate those cases here easily, so we leave it up to the
1087 * leader to fill empty ranges where needed.
1088 */
1089 state->bs_currRangeStart
1091
1092 /* re-initialize state for it */
1094 }
1095
1096 /* Accumulate the current tuple into the running state */
1098 values, isnull);
1099}
1100
1101/*
1102 * brinbuild() -- build a new BRIN index.
1103 */
1104IndexBuildResult *
1106{
1107 IndexBuildResult *result;
1108 double reltuples;
1112 Buffer meta;
1113 BlockNumber pagesPerRange;
1114
1115 /*
1116 * We expect to be called exactly once for any index relation.
1117 */
1121
1122 /*
1123 * Critical section not required, because on error the creation of the
1124 * whole relation will be rolled back.
1125 */
1126
1130
1132 BRIN_CURRENT_VERSION);
1133 MarkBufferDirty(meta);
1134
1136 {
1139 Page page;
1140
1143
1144 XLogBeginInsert();
1147
1149
1150 page = BufferGetPage(meta);
1152 }
1153
1154 UnlockReleaseBuffer(meta);
1155
1156 /*
1157 * Initialize our state, including the deformed tuple state.
1158 */
1161 RelationGetNumberOfBlocks(heap));
1162
1163 /*
1164 * Attempt to launch parallel worker scan when required
1165 *
1166 * XXX plan_create_index_workers makes the number of workers dependent on
1167 * maintenance_work_mem, requiring 32MB for each worker. That makes sense
1168 * for btree, but not for BRIN, which can do with much less memory. So
1169 * maybe make that somehow less strict, optionally?
1170 */
1173 indexInfo->ii_ParallelWorkers);
1174
1175 /*
1176 * If parallel build requested and at least one worker process was
1177 * successfully launched, set up coordination state, wait for workers to
1178 * complete. Then read all tuples from the shared tuplesort and insert
1179 * them into the index.
1180 *
1181 * In serial mode, simply scan the table and build the index one index
1182 * tuple at a time.
1183 */
1185 {
1187
1190 coordinate->nParticipants =
1191 state->bs_leader->nparticipanttuplesorts;
1193
1194 /*
1195 * Begin leader tuplesort.
1196 *
1197 * In cases where parallelism is involved, the leader receives the
1198 * same share of maintenance_work_mem as a serial sort (it is
1199 * generally treated in the same way as a serial sort once we return).
1200 * Parallel worker Tuplesortstates will have received only a fraction
1201 * of maintenance_work_mem, though.
1202 *
1203 * We rely on the lifetime of the Leader Tuplesortstate almost not
1204 * overlapping with any worker Tuplesortstate's lifetime. There may
1205 * be some small overlap, but that's okay because we rely on leader
1206 * Tuplesortstate only allocating a small, fixed amount of memory
1207 * here. When its tuplesort_performsort() is called (by our caller),
1208 * and significant amounts of memory are likely to be used, all
1209 * workers must have already freed almost all memory held by their
1210 * Tuplesortstates (they are about to go away completely, too). The
1211 * overall effect is that maintenance_work_mem always represents an
1212 * absolute high watermark on the amount of memory used by a CREATE
1213 * INDEX operation, regardless of the use of parallelism or any other
1214 * factor.
1215 */
1216 state->bs_sortstate =
1218 TUPLESORT_NONE);
1219
1220 /* scan the relation and merge per-worker results */
1222
1224 }
1225 else /* no parallel index build */
1226 {
1227 /*
1228 * Now scan the relation. No syncscan allowed here because we want
1229 * the heap blocks in physical order (we want to produce the ranges
1230 * starting from block 0, and the callback also relies on this to not
1231 * generate summary for the same range twice).
1232 */
1235
1236 /*
1237 * process the final batch
1238 *
1239 * XXX Note this does not update state->bs_currRangeStart, i.e. it
1240 * stays set to the last range added to the index. This is OK, because
1241 * that's what brin_fill_empty_ranges expects.
1242 */
1244
1245 /*
1246 * Backfill the final ranges with empty data.
1247 *
1248 * This saves us from doing what amounts to full table scans when the
1249 * index with a predicate like WHERE (nonnull_column IS NULL), or
1250 * other very selective predicates.
1251 */
1253 state->bs_currRangeStart,
1254 state->bs_maxRangeStart);
1255 }
1256
1257 /* release resources */
1261
1262 /*
1263 * Return statistics
1264 */
1266
1267 result->heap_tuples = reltuples;
1269
1270 return result;
1271}
1272
1273void
1275{
1277
1278 /* An empty BRIN index has a metapage only. */
1281
1282 /* Initialize and xlog metabuffer. */
1283 START_CRIT_SECTION();
1285 BRIN_CURRENT_VERSION);
1288 END_CRIT_SECTION();
1289
1291}
1292
1293/*
1294 * brinbulkdelete
1295 * Since there are no per-heap-tuple index tuples in BRIN indexes,
1296 * there's not a lot we can do here.
1297 *
1298 * XXX we could mark item tuples as "dirty" (when a minimum or maximum heap
1299 * tuple is deleted), meaning the need to re-run summarization on the affected
1300 * range. Would need to add an extra flag in brintuples for that.
1301 */
1302IndexBulkDeleteResult *
1305{
1306 /* allocate stats if first time through, else re-use existing struct */
1309
1310 return stats;
1311}
1312
1313/*
1314 * This routine is in charge of "vacuuming" a BRIN index: we just summarize
1315 * ranges that are currently unsummarized.
1316 */
1317IndexBulkDeleteResult *
1319{
1320 Relation heapRel;
1321
1322 /* No-op in ANALYZE ONLY mode */
1324 return stats;
1325
1326 if (!stats)
1329 /* rest of stats is initialized by zeroing */
1330
1332 AccessShareLock);
1333
1335
1338
1340
1341 return stats;
1342}
1343
1344/*
1345 * reloptions processor for BRIN indexes
1346 */
1347bytea *
1349{
1353 };
1354
1356 RELOPT_KIND_BRIN,
1358 tab, lengthof(tab));
1359}
1360
1361/*
1362 * SQL-callable function to scan through an index and summarize all ranges
1363 * that are not currently summarized.
1364 */
1365Datum
1367{
1369
1371 relation,
1373}
1374
1375/*
1376 * SQL-callable function to summarize the indicated page range, if not already
1377 * summarized. If the second argument is BRIN_ALL_BLOCKRANGES, all
1378 * unsummarized ranges are summarized.
1379 */
1380Datum
1382{
1385 BlockNumber heapBlk;
1387 Relation indexRel;
1388 Relation heapRel;
1389 Oid save_userid;
1390 int save_sec_context;
1391 int save_nestlevel;
1393
1399
1405
1406 /*
1407 * We must lock table before index to avoid deadlocks. However, if the
1408 * passed indexoid isn't an index then IndexGetRelation() will fail.
1409 * Rather than emitting a not-very-helpful error message, postpone
1410 * complaining, expecting that the is-it-an-index test below will fail.
1411 */
1414 {
1416
1417 /*
1418 * Autovacuum calls us. For its benefit, switch to the table owner's
1419 * userid, so that any index functions are run as that user. Also
1420 * lock down security-restricted operations and arrange to make GUC
1421 * variable changes local to this command. This is harmless, albeit
1422 * unnecessary, when called from SQL, because we fail shortly if the
1423 * user does not own the index.
1424 */
1425 GetUserIdAndSecContext(&save_userid, &save_sec_context);
1427 save_sec_context | SECURITY_RESTRICTED_OPERATION);
1428 save_nestlevel = NewGUCNestLevel();
1429 RestrictSearchPath();
1430 }
1431 else
1432 {
1433 heapRel = NULL;
1434 /* Set these just to suppress "uninitialized variable" warnings */
1435 save_userid = InvalidOid;
1436 save_sec_context = -1;
1437 save_nestlevel = -1;
1438 }
1439
1441
1442 /* Must be a BRIN index */
1448 RelationGetRelationName(indexRel))));
1449
1450 /* User must own the index (comparable to privileges needed for VACUUM) */
1453 RelationGetRelationName(indexRel));
1454
1455 /*
1456 * Since we did the IndexGetRelation call above without any lock, it's
1457 * barely possible that a race against an index drop/recreation could have
1458 * netted us the wrong table. Recheck.
1459 */
1464 RelationGetRelationName(indexRel))));
1465
1466 /* see gin_clean_pending_list() */
1469 else
1473 RelationGetRelationName(indexRel))));
1474
1475 /* Roll back any GUC changes executed by index functions */
1477
1478 /* Restore userid and security context */
1479 SetUserIdAndSecContext(save_userid, save_sec_context);
1480
1483
1485}
1486
1487/*
1488 * SQL-callable interface to mark a range as no longer summarized
1489 */
1490Datum
1492{
1495 BlockNumber heapBlk;
1497 Relation heapRel;
1498 Relation indexRel;
1499 bool done;
1500
1506
1511 heapBlk64)));
1513
1514 /*
1515 * We must lock table before index to avoid deadlocks. However, if the
1516 * passed indexoid isn't an index then IndexGetRelation() will fail.
1517 * Rather than emitting a not-very-helpful error message, postpone
1518 * complaining, expecting that the is-it-an-index test below will fail.
1519 *
1520 * Unlike brin_summarize_range(), autovacuum never calls this. Hence, we
1521 * don't switch userid.
1522 */
1526 else
1527 heapRel = NULL;
1528
1530
1531 /* Must be a BRIN index */
1537 RelationGetRelationName(indexRel))));
1538
1539 /* User must own the index (comparable to privileges needed for VACUUM) */
1542 RelationGetRelationName(indexRel));
1543
1544 /*
1545 * Since we did the IndexGetRelation call above without any lock, it's
1546 * barely possible that a race against an index drop/recreation could have
1547 * netted us the wrong table. Recheck.
1548 */
1553 RelationGetRelationName(indexRel))));
1554
1555 /* see gin_clean_pending_list() */
1557 {
1558 /* the revmap does the hard work */
1559 do
1560 {
1561 done = brinRevmapDesummarizeRange(indexRel, heapBlk);
1562 }
1563 while (!done);
1564 }
1565 else
1569 RelationGetRelationName(indexRel))));
1570
1573
1574 PG_RETURN_VOID();
1575}
1576
1577/*
1578 * Build a BrinDesc used to create or scan a BRIN index
1579 */
1580BrinDesc *
1582{
1585 TupleDesc tupdesc;
1587 int keyno;
1588 long totalsize;
1589 MemoryContext cxt;
1591
1593 "brin desc cxt",
1594 ALLOCSET_SMALL_SIZES);
1596 tupdesc = RelationGetDescr(rel);
1597
1598 /*
1599 * Obtain BrinOpcInfo for each indexed column. While at it, accumulate
1600 * the number of columns stored, since the number is opclass-defined.
1601 */
1604 {
1607
1609
1613 }
1614
1615 /* Allocate our result struct and fill it in */
1618
1620 bdesc->bd_context = cxt;
1621 bdesc->bd_index = rel;
1622 bdesc->bd_tupdesc = tupdesc;
1625
1629
1631
1633}
1634
1635void
1637{
1638 /* make sure the tupdesc is still valid */
1640 /* no need for retail pfree */
1642}
1643
1644/*
1645 * Fetch index's statistical data into *stats
1646 */
1647void
1649{
1652 BrinMetaPageData *metadata;
1653
1658
1661
1663}
1664
1665/*
1666 * Initialize a BrinBuildState appropriate to create tuples on the given index.
1667 */
1671{
1674
1676
1678 state->bs_numtuples = 0;
1679 state->bs_reltuples = 0;
1681 state->bs_pagesPerRange = pagesPerRange;
1682 state->bs_currRangeStart = 0;
1687 state->bs_worker_id = 0;
1691 state->bs_emptyTupleLen = 0;
1692
1693 /* Remember the memory context to use for an empty tuple, if needed. */
1696 state->bs_emptyTupleLen = 0;
1697
1698 /*
1699 * Calculate the start of the last page range. Page numbers are 0-based,
1700 * so to calculate the index we need to subtract one. The integer division
1701 * gives us the index of the page range.
1702 */
1705
1706 /* Now calculate the start of the next range. */
1708
1710}
1711
1712/*
1713 * Release resources associated with a BrinBuildState.
1714 */
1715static void
1717{
1718 /*
1719 * Release the last index buffer used. We might as well ensure that
1720 * whatever free space remains in that page is available in FSM, too.
1721 */
1723 {
1724 Page page;
1725 Size freespace;
1727
1729 freespace = PageGetFreeSpace(page);
1734 }
1735
1739}
1740
1741/*
1742 * On the given BRIN index, summarize the heap page range that corresponds
1743 * to the heap block number given.
1744 *
1745 * This routine can run in parallel with insertions into the heap. To avoid
1746 * missing those values from the summary tuple, we first insert a placeholder
1747 * index tuple into the index, then execute the heap scan; transactions
1748 * concurrent with the scan update the placeholder tuple. After the scan, we
1749 * union the placeholder tuple with the one computed by this routine. The
1750 * update of the index value happens in a loop, so that if somebody updates
1751 * the placeholder tuple after we read it, we detect the case and try again.
1752 * This ensures that the concurrently inserted tuples are not lost.
1753 *
1754 * A further corner case is this routine being asked to summarize the partial
1755 * range at the end of the table. heapNumBlocks is the (possibly outdated)
1756 * table size; if we notice that the requested range lies beyond that size,
1757 * we re-compute the table size after inserting the placeholder tuple, to
1758 * avoid missing pages that were appended recently.
1759 */
1760static void
1763{
1767 OffsetNumber offset;
1769
1770 /*
1771 * Insert the placeholder tuple
1772 */
1778
1779 /*
1780 * Compute range end. We hold ShareUpdateExclusive lock on table, so it
1781 * cannot shrink concurrently (but it can grow).
1782 */
1785 {
1786 /*
1787 * If we're asked to scan what we believe to be the final range on the
1788 * table (i.e. a range that might be partial) we need to recompute our
1789 * idea of what the latest page is after inserting the placeholder
1790 * tuple. Anyone that grows the table later will update the
1791 * placeholder tuple, so it doesn't matter that we won't scan these
1792 * pages ourselves. Careful: the table might have been extended
1793 * beyond the current range, so clamp our result.
1794 *
1795 * Fortunately, this should occur infrequently.
1796 */
1798 state->bs_pagesPerRange);
1799 }
1800 else
1801 {
1802 /* Easy case: range is known to be complete */
1804 }
1805
1806 /*
1807 * Execute the partial heap scan covering the heap blocks in the specified
1808 * page range, summarizing the heap tuples in it. This scan stops just
1809 * short of brinbuildCallback creating the new index entry.
1810 *
1811 * Note that it is critical we use the "any visible" mode of
1812 * table_index_build_range_scan here: otherwise, we would miss tuples
1813 * inserted by transactions that are still in progress, among other corner
1814 * cases.
1815 */
1816 state->bs_currRangeStart = heapBlk;
1818 heapBlk, scanNumBlks,
1820
1821 /*
1822 * Now we update the values obtained by the scan with the placeholder
1823 * tuple. We do this in a loop which only terminates if we're able to
1824 * update the placeholder tuple successfully; if we are not, this means
1825 * somebody else modified the placeholder tuple after we read it.
1826 */
1827 for (;;)
1828 {
1833
1834 CHECK_FOR_INTERRUPTS();
1835
1836 /*
1837 * Update the summary tuple and try to update.
1838 */
1842 didupdate =
1848
1849 /* If the update succeeded, we're done. */
1851 break;
1852
1853 /*
1854 * If the update didn't work, it might be because somebody updated the
1855 * placeholder tuple concurrently. Extract the new version, union it
1856 * with the values we have from the scan, and start over. (There are
1857 * other reasons for the update to fail, but it's simple to treat them
1858 * the same.)
1859 */
1862 /* the placeholder tuple must exist */
1867
1868 /* merge it into the tuple from the heap scan */
1870 }
1871
1873}
1874
1875/*
1876 * Summarize page ranges that are not already summarized. If pageRange is
1877 * BRIN_ALL_BLOCKRANGES then the whole table is scanned; otherwise, only the
1878 * page range containing the given heap page number is scanned.
1879 * If include_partial is true, then the partial range at the end of the table
1880 * is summarized, otherwise not.
1881 *
1882 * For each new index tuple inserted, *numSummarized (if not NULL) is
1883 * incremented; for each existing tuple, *numExisting (if not NULL) is
1884 * incremented.
1885 */
1886static void
1889{
1894 BlockNumber pagesPerRange;
1897
1899
1900 /* determine range of pages to process */
1903 startBlk = 0;
1904 else
1905 {
1908 }
1910 {
1911 /* Nothing to do if start point is beyond end of table */
1913 return;
1914 }
1915
1916 /*
1917 * Scan the revmap to find unsummarized items.
1918 */
1921 {
1923 OffsetNumber off;
1924
1925 /*
1926 * Unless requested to summarize even a partial range, go away now if
1927 * we think the next range is partial. Caller would pass true when it
1928 * is typically run once bulk data loading is done
1929 * (brin_summarize_new_values), and false when it is typically the
1930 * result of arbitrarily-scheduled maintenance command (vacuuming).
1931 */
1934 break;
1935
1936 CHECK_FOR_INTERRUPTS();
1937
1939 BUFFER_LOCK_SHARE);
1941 {
1942 /* no revmap entry for this heap range. Summarize it. */
1944 {
1945 /* first time through */
1946 Assert(!indexInfo);
1948 pagesPerRange,
1949 InvalidBlockNumber);
1951 }
1953
1954 /* and re-initialize state for the next range */
1956
1958 *numSummarized += 1.0;
1959 }
1960 else
1961 {
1963 *numExisting += 1.0;
1965 }
1966 }
1967
1970
1971 /* free resources */
1974 {
1976 pfree(indexInfo);
1977 }
1978}
1979
1980/*
1981 * Given a deformed tuple in the build state, convert it into the on-disk
1982 * format and insert it into the index, making the revmap point to it.
1983 */
1984static void
1986{
1988 Size size;
1989
1991 state->bs_dtuple, &size);
1994 tup, size);
1995 state->bs_numtuples++;
1996
1998}
1999
2000/*
2001 * Given a deformed tuple in the build state, convert it into the on-disk
2002 * format and write it to a (shared) tuplesort (the leader will insert it
2003 * into the index later).
2004 */
2005static void
2007{
2009 Size size;
2010
2011 /* don't insert empty tuples in parallel build */
2013 return;
2014
2016 state->bs_dtuple, &size);
2017
2018 /* write the BRIN tuple to the tuplesort */
2020
2021 state->bs_numtuples++;
2022
2024}
2025
2026/*
2027 * Given two deformed tuples, adjust the first one so that it's consistent
2028 * with the summary values in both.
2029 */
2030static void
2032{
2033 int keyno;
2034 BrinMemTuple *db;
2035 MemoryContext cxt;
2037
2038 /* Use our own memory context to avoid retail pfree */
2040 "brin union",
2041 ALLOCSET_DEFAULT_SIZES);
2045
2046 /*
2047 * Check if the ranges are empty.
2048 *
2049 * If at least one of them is empty, we don't need to call per-key union
2050 * functions at all. If "b" is empty, we just use "a" as the result (it
2051 * might be empty fine, but that's fine). If "a" is empty but "b" is not,
2052 * we use "b" as the result (but we have to copy the data into "a" first).
2053 *
2054 * Only when both ranges are non-empty, we actually do the per-key merge.
2055 */
2056
2057 /* If "b" is empty - ignore it and just use "a" (even if it's empty etc.). */
2059 {
2060 /* skip the per-key merge */
2061 MemoryContextDelete(cxt);
2062 return;
2063 }
2064
2065 /*
2066 * Now we know "b" is not empty. If "a" is empty, then "b" is the result.
2067 * But we need to copy the data from "b" to "a" first, because that's how
2068 * we pass result out.
2069 *
2070 * We have to copy all the global/per-key flags etc. too.
2071 */
2073 {
2075 {
2080
2083
2084 /* If "b" has no data, we're done. */
2086 continue;
2087
2093 }
2094
2095 /* "a" started empty, but "b" was not empty, so remember that */
2097
2098 /* skip the per-key merge */
2099 MemoryContextDelete(cxt);
2100 return;
2101 }
2102
2103 /* Now we know neither range is empty. */
2105 {
2106 FmgrInfo *unionFn;
2110
2112 {
2113 /* Does the "b" summary represent any NULL values? */
2115
2116 /* Adjust "hasnulls". */
2119
2120 /* If there are no values in B, there's nothing left to do. */
2122 continue;
2123
2124 /*
2125 * Adjust "allnulls". If A doesn't have values, just copy the
2126 * values from B into A, and we're done. We cannot run the
2127 * operators in this case, because values in A might contain
2128 * garbage. Note we already established that B contains values.
2129 *
2130 * Also adjust "hasnulls" in order not to forget the summary
2131 * represents NULL values. This is not redundant with the earlier
2132 * update, because that only happens when allnulls=false.
2133 */
2135 {
2137
2140
2146
2147 continue;
2148 }
2149 }
2150
2152 BRIN_PROCNUM_UNION);
2153 FunctionCall3Coll(unionFn,
2154 bdesc->bd_index->rd_indcollation[keyno],
2158 }
2159
2160 MemoryContextDelete(cxt);
2161}
2162
2163/*
2164 * brin_vacuum_scan
2165 * Do a complete scan of the index during VACUUM.
2166 *
2167 * This routine scans the complete index looking for uncataloged index pages,
2168 * i.e. those that might have been lost due to a crash after index extension
2169 * and such.
2170 */
2171static void
2173{
2174 BlockRangeReadStreamPrivate p;
2175 ReadStream *stream;
2177
2178 p.current_blocknum = 0;
2180
2181 /*
2182 * It is safe to use batchmode as block_range_read_stream_cb takes no
2183 * locks.
2184 */
2186 READ_STREAM_FULL |
2187 READ_STREAM_USE_BATCHING,
2188 strategy,
2189 idxrel,
2190 MAIN_FORKNUM,
2192 &p,
2193 0);
2194
2195 /*
2196 * Scan the index in physical order, and clean up any possible mess in
2197 * each page.
2198 */
2200 {
2201 CHECK_FOR_INTERRUPTS();
2202
2204
2206 }
2207
2208 read_stream_end(stream);
2209
2210 /*
2211 * Update all upper pages in the index's FSM, as well. This ensures not
2212 * only that we propagate leaf-page FSM updates made by brin_page_cleanup,
2213 * but also that any pre-existing damage or out-of-dateness is repaired.
2214 */
2216}
2217
2218static bool
2221{
2222 int keyno;
2223
2224 /* If the range starts empty, we're certainly going to modify it. */
2226
2227 /*
2228 * Compare the key values of the new tuple to the stored index values; our
2229 * deformed tuple will get updated if the new tuple doesn't fit the
2230 * original range (note this means we can't break out of the loop early).
2231 * Make a note of whether this happens, so that we know to insert the
2232 * modified tuple later.
2233 */
2235 {
2236 Datum result;
2237 BrinValues *bval;
2239 bool has_nulls;
2240
2241 bval = &dtup->bt_columns[keyno];
2242
2243 /*
2244 * Does the range have actual NULL values? Either of the flags can be
2245 * set, but we ignore the state before adding first row.
2246 *
2247 * We have to remember this, because we'll modify the flags and we
2248 * need to know if the range started as empty.
2249 */
2250 has_nulls = ((!dtup->bt_empty_range) &&
2252
2253 /*
2254 * If the value we're adding is NULL, handle it locally. Otherwise
2255 * call the BRIN_PROCNUM_ADDVALUE procedure.
2256 */
2258 {
2259 /*
2260 * If the new value is null, we record that we saw it if it's the
2261 * first one; otherwise, there's nothing to do.
2262 */
2264 {
2267 }
2268
2269 continue;
2270 }
2271
2273 BRIN_PROCNUM_ADDVALUE);
2275 idxRel->rd_indcollation[keyno],
2277 PointerGetDatum(bval),
2278 values[keyno],
2279 BoolGetDatum(nulls[keyno]));
2280 /* if that returned true, we need to insert the updated tuple */
2282
2283 /*
2284 * If the range was had actual NULL values (i.e. did not start empty),
2285 * make sure we don't forget about the NULL values. Either the
2286 * allnulls flag is still set to true, or (if the opclass cleared it)
2287 * we need to set hasnulls=true.
2288 *
2289 * XXX This can only happen when the opclass modified the tuple, so
2290 * the modified flag should be set.
2291 */
2293 {
2296 }
2297 }
2298
2299 /*
2300 * After updating summaries for all the keys, mark it as not empty.
2301 *
2302 * If we're actually changing the flag value (i.e. tuple started as
2303 * empty), we should have modified the tuple. So we should not see empty
2304 * range that was not modified.
2305 */
2308
2310}
2311
2312static bool
2314{
2315 int keyno;
2316
2317 /*
2318 * First check if there are any IS [NOT] NULL scan keys, and if we're
2319 * violating them.
2320 */
2322 {
2324
2326
2327 /* Handle only IS NULL/IS NOT NULL tests */
2329 continue;
2330
2332 {
2333 /* IS NULL scan key, but range has no NULLs */
2335 return false;
2336 }
2338 {
2339 /*
2340 * For IS NOT NULL, we can only skip ranges that are known to have
2341 * only nulls.
2342 */
2344 return false;
2345 }
2346 else
2347 {
2348 /*
2349 * Neither IS NULL nor IS NOT NULL was used; assume all indexable
2350 * operators are strict and thus return false with NULL value in
2351 * the scan key.
2352 */
2353 return false;
2354 }
2355 }
2356
2357 return true;
2358}
2359
2360/*
2361 * Create parallel context, and launch workers for leader.
2362 *
2363 * buildstate argument should be initialized (with the exception of the
2364 * tuplesort states, which may later be created based on shared
2365 * state initially set up here).
2366 *
2367 * isconcurrent indicates if operation is CREATE INDEX CONCURRENTLY.
2368 *
2369 * request is the target number of parallel worker processes to launch.
2370 *
2371 * Sets buildstate's BrinLeader, which caller must use to shut down parallel
2372 * mode by passing it to _brin_end_parallel() at the very end of its index
2373 * build. If not even a single worker process can be launched, this is
2374 * never set, and caller should proceed with a serial index build.
2375 */
2376static void
2379{
2380 ParallelContext *pcxt;
2381 int scantuplesortstates;
2382 Snapshot snapshot;
2385 BrinShared *brinshared;
2386 Sharedsort *sharedsort;
2388 WalUsage *walusage;
2389 BufferUsage *bufferusage;
2392
2393#ifdef DISABLE_LEADER_PARTICIPATION
2395#endif
2396
2397 /*
2398 * Enter parallel mode, and create context for parallel build of brin
2399 * index
2400 */
2401 EnterParallelMode();
2404 request);
2405
2407
2408 /*
2409 * Prepare for scan of the base relation. In a normal index build, we use
2410 * SnapshotAny because we must retrieve all tuples and do our own time
2411 * qual checks (because we have to index RECENTLY_DEAD tuples). In a
2412 * concurrent build, we take a regular MVCC snapshot and index whatever's
2413 * live according to that.
2414 */
2415 if (!isconcurrent)
2416 snapshot = SnapshotAny;
2417 else
2419
2420 /*
2421 * Estimate size for our own PARALLEL_KEY_BRIN_SHARED workspace.
2422 */
2427
2429
2430 /*
2431 * Estimate space for WalUsage and BufferUsage -- PARALLEL_KEY_WAL_USAGE
2432 * and PARALLEL_KEY_BUFFER_USAGE.
2433 *
2434 * If there are no extensions loaded that care, we could skip this. We
2435 * have no way of knowing whether anyone's looking at pgWalUsage or
2436 * pgBufferUsage, so do it unconditionally.
2437 */
2444
2445 /* Finally, estimate PARALLEL_KEY_QUERY_TEXT space */
2447 {
2451 }
2452 else
2454
2455 /* Everyone's had a chance to ask for space, so now create the DSM */
2456 InitializeParallelDSM(pcxt);
2457
2458 /* If no DSM segment was available, back out (do serial build) */
2460 {
2462 UnregisterSnapshot(snapshot);
2463 DestroyParallelContext(pcxt);
2464 ExitParallelMode();
2465 return;
2466 }
2467
2468 /* Store shared build state, for which we reserved space */
2470 /* Initialize immutable state */
2473 brinshared->isconcurrent = isconcurrent;
2474 brinshared->scantuplesortstates = scantuplesortstates;
2479
2480 /* Initialize mutable state */
2481 brinshared->nparticipantsdone = 0;
2482 brinshared->reltuples = 0.0;
2483 brinshared->indtuples = 0.0;
2484
2485 table_parallelscan_initialize(heap,
2486 ParallelTableScanFromBrinShared(brinshared),
2487 snapshot);
2488
2489 /*
2490 * Store shared tuplesort-private state, for which we reserved space.
2491 * Then, initialize opaque state using tuplesort routine.
2492 */
2494 tuplesort_initialize_shared(sharedsort, scantuplesortstates,
2495 pcxt->seg);
2496
2497 /*
2498 * Store shared tuplesort-private state, for which we reserved space.
2499 * Then, initialize opaque state using tuplesort routine.
2500 */
2503
2504 /* Store query string for workers */
2506 {
2508
2512 }
2513
2514 /*
2515 * Allocate space for each worker's WalUsage and BufferUsage; no need to
2516 * initialize.
2517 */
2524
2525 /* Launch workers, saving status for leader/caller */
2526 LaunchParallelWorkers(pcxt);
2527 brinleader->pcxt = pcxt;
2530 brinleader->nparticipanttuplesorts++;
2531 brinleader->brinshared = brinshared;
2532 brinleader->sharedsort = sharedsort;
2533 brinleader->snapshot = snapshot;
2534 brinleader->walusage = walusage;
2535 brinleader->bufferusage = bufferusage;
2536
2537 /* If no workers were successfully launched, back out (do serial build) */
2539 {
2541 return;
2542 }
2543
2544 /* Save leader state now that it's clear build will be parallel */
2546
2547 /* Join heap scan ourselves */
2550
2551 /*
2552 * Caller needs to wait for all launched workers when we return. Make
2553 * sure that the failure-to-start case will not hang forever.
2554 */
2555 WaitForParallelWorkersToAttach(pcxt);
2556}
2557
2558/*
2559 * Shut down workers, destroy parallel context, and end parallel mode.
2560 */
2561static void
2563{
2565
2566 /* Shutdown worker processes */
2568
2569 /*
2570 * Next, accumulate WAL usage. (This must wait for the workers to finish,
2571 * or we might get incomplete data.)
2572 */
2575
2576 /* Free last reference to MVCC snapshot, if one was used */
2580 ExitParallelMode();
2581}
2582
2583/*
2584 * Within leader, wait for end of heap scan.
2585 *
2586 * When called, parallel heap scan started by _brin_begin_parallel() will
2587 * already be underway within worker processes (when leader participates
2588 * as a worker, we should end up here just as workers are finishing).
2589 *
2590 * Returns the total number of heap tuples scanned.
2591 */
2592static double
2594{
2596 int nparticipanttuplesorts;
2597
2598 nparticipanttuplesorts = state->bs_leader->nparticipanttuplesorts;
2599 for (;;)
2600 {
2603 {
2604 /* copy the data into leader state */
2607
2609 break;
2610 }
2612
2615 }
2616
2617 ConditionVariableCancelSleep();
2618
2620}
2621
2622/*
2623 * Within leader, wait for end of heap scan and merge per-worker results.
2624 *
2625 * After waiting for all workers to finish, merge the per-worker results into
2626 * the complete index. The results from each worker are sorted by block number
2627 * (start of the page range). While combining the per-worker results we merge
2628 * summaries for the same page range, and also fill-in empty summaries for
2629 * ranges without any tuples.
2630 *
2631 * Returns the total number of heap tuples scanned.
2632 */
2633static double
2635{
2638 Size tuplen;
2641 oldCxt;
2642 double reltuples;
2643
2644 /* wait for workers to scan table and produce partial results */
2646
2647 /* do the actual sort in the leader */
2649
2650 /*
2651 * Initialize BrinMemTuple we'll use to union summaries from workers (in
2652 * case they happened to produce parts of the same page range).
2653 */
2655
2656 /*
2657 * Create a memory context we'll reset to combine results for a single
2658 * page range (received from the workers). We don't expect huge number of
2659 * overlaps under regular circumstances, because for large tables the
2660 * chunk size is likely larger than the BRIN page range), but it can
2661 * happen, and the union functions may do all kinds of stuff. So we better
2662 * reset the context once in a while.
2663 */
2665 "brin union",
2666 ALLOCSET_DEFAULT_SIZES);
2668
2669 /*
2670 * Read the BRIN tuples from the shared tuplesort, sorted by block number.
2671 * That probably gives us an index that is cheaper to scan, thanks to
2672 * mostly getting data from the same index page as before.
2673 */
2675 {
2676 /* Ranges should be multiples of pages_per_range for the index. */
2678
2679 /*
2680 * Do we need to union summaries for the same page range?
2681 *
2682 * If this is the first brin tuple we read, then just deform it into
2683 * the memtuple, and continue with the next one from tuplesort. We
2684 * however may need to insert empty summaries into the index.
2685 *
2686 * If it's the same block as the last we saw, we simply union the brin
2687 * tuple into it, and we're done - we don't even need to insert empty
2688 * ranges, because that was done earlier when we saw the first brin
2689 * tuple (for this range).
2690 *
2691 * Finally, if it's not the first brin tuple, and it's not the same
2692 * page range, we need to do the insert and then deform the tuple into
2693 * the memtuple. Then we'll insert empty ranges before the new brin
2694 * tuple, if needed.
2695 */
2697 {
2698 /* First brin tuples, just deform into memtuple. */
2700
2701 /* continue to insert empty pages before thisblock */
2702 }
2704 {
2705 /*
2706 * Not the first brin tuple, but same page range as the previous
2707 * one, so we can merge it into the memtuple.
2708 */
2710 continue;
2711 }
2712 else
2713 {
2714 BrinTuple *tmp;
2716
2717 /*
2718 * We got brin tuple for a different page range, so form a brin
2719 * tuple from the memtuple, insert it, and re-init the memtuple
2720 * from the new brin tuple.
2721 */
2724
2727
2728 /*
2729 * Reset the per-output-range context. This frees all the memory
2730 * possibly allocated by the union functions, and also the BRIN
2731 * tuple we just formed and inserted.
2732 */
2734
2736
2737 /* continue to insert empty pages before thisblock */
2738 }
2739
2740 /* Fill empty ranges for all ranges missing in the tuplesort. */
2742
2743 prevblkno = btup->bt_blkno;
2744 }
2745
2747
2748 /* Fill the BRIN tuple for the last page range with data. */
2750 {
2751 BrinTuple *tmp;
2753
2756
2759
2760 pfree(tmp);
2761 }
2762
2763 /* Fill empty ranges at the end, for all ranges missing in the tuplesort. */
2765
2766 /*
2767 * Switch back to the original memory context, and destroy the one we
2768 * created to isolate the union_tuple calls.
2769 */
2772
2773 return reltuples;
2774}
2775
2776/*
2777 * Returns size of shared memory required to store state for a parallel
2778 * brin index build based on the snapshot its parallel scan will use.
2779 */
2782{
2783 /* c.f. shm_toc_allocate as to why BUFFERALIGN is used */
2785 table_parallelscan_estimate(heap, snapshot));
2786}
2787
2788/*
2789 * Within leader, participate as a parallel worker.
2790 */
2791static void
2793{
2796
2797 /*
2798 * Might as well use reliable figure when doling out maintenance_work_mem
2799 * (when requested number of workers were not launched, this will be
2800 * somewhat higher than it is for other workers).
2801 */
2803
2804 /* Perform work common to all participants */
2807}
2808
2809/*
2810 * Perform a worker's portion of a parallel sort.
2811 *
2812 * This generates a tuplesort for the worker portion of the table.
2813 *
2814 * sortmem is the amount of working memory to use within each worker,
2815 * expressed in KBs.
2816 *
2817 * When this returns, workers are done, and need only release resources.
2818 */
2819static void
2824{
2826 TableScanDesc scan;
2827 double reltuples;
2828 IndexInfo *indexInfo;
2829
2830 /* Initialize local tuplesort coordination state */
2833 coordinate->nParticipants = -1;
2834 coordinate->sharedsort = sharedsort;
2835
2836 /* Begin "partial" tuplesort */
2838 TUPLESORT_NONE);
2839
2840 /* Join parallel scan */
2843
2844 scan = table_beginscan_parallel(heap,
2845 ParallelTableScanFromBrinShared(brinshared));
2846
2849
2850 /* insert the last item */
2852
2853 /* sort the BRIN ranges built by this worker */
2855
2856 state->bs_reltuples += reltuples;
2857
2858 /*
2859 * Done. Record ambuild statistics.
2860 */
2862 brinshared->nparticipantsdone++;
2866
2867 /* Notify leader */
2869
2871}
2872
2873/*
2874 * Perform work within a launched parallel process.
2875 */
2876void
2878{
2880 BrinShared *brinshared;
2881 Sharedsort *sharedsort;
2883 Relation heapRel;
2884 Relation indexRel;
2887 WalUsage *walusage;
2888 BufferUsage *bufferusage;
2890
2891 /*
2892 * The only possible status flag that can be set to the parallel worker is
2893 * PROC_IN_SAFE_IC.
2894 */
2897
2898 /* Set debug_query_string for individual workers first */
2901
2902 /* Report the query string from leader */
2904
2905 /* Look up brin shared state */
2907
2908 /* Open relations using lock modes known to be obtained by index.c */
2910 {
2913 }
2914 else
2915 {
2918 }
2919
2920 /* Track query ID */
2922
2923 /* Open relations within worker */
2926
2928 brinshared->pagesPerRange,
2929 InvalidBlockNumber);
2930
2931 /* Look up shared state private to tuplesort.c */
2933 tuplesort_attach_shared(sharedsort, seg);
2934
2935 /* Prepare to track buffer usage during parallel execution */
2936 InstrStartParallelQuery();
2937
2938 /*
2939 * Might as well use reliable figure when doling out maintenance_work_mem
2940 * (when requested number of workers were not launched, this will be
2941 * somewhat higher than it is for other workers).
2942 */
2944
2947
2948 /* Report WAL/buffer usage during parallel execution */
2952 &walusage[ParallelWorkerNumber]);
2953
2956}
2957
2958/*
2959 * brin_build_empty_tuple
2960 * Maybe initialize a BRIN tuple representing empty range.
2961 *
2962 * Returns a BRIN tuple representing an empty page range starting at the
2963 * specified block number. The empty tuple is initialized only once, when it's
2964 * needed for the first time, stored in the memory context bs_context to ensure
2965 * proper life span, and reused on following calls. All empty tuples are
2966 * exactly the same except for the bt_blkno field, which is set to the value
2967 * in blkno parameter.
2968 */
2969static void
2971{
2972 /* First time an empty tuple is requested? If yes, initialize it. */
2974 {
2977
2978 /* Allocate the tuple in context for the whole index build. */
2980
2982 &state->bs_emptyTupleLen);
2983
2985 }
2986 else
2987 {
2988 /* If we already have an empty tuple, just update the block. */
2989 state->bs_emptyTuple->bt_blkno = blkno;
2990 }
2991}
2992
2993/*
2994 * brin_fill_empty_ranges
2995 * Add BRIN index tuples representing empty page ranges.
2996 *
2997 * prevRange/nextRange determine for which page ranges to add empty summaries.
2998 * Both boundaries are exclusive, i.e. only ranges starting at blkno for which
2999 * (prevRange < blkno < nextRange) will be added to the index.
3000 *
3001 * If prevRange is InvalidBlockNumber, this means there was no previous page
3002 * range (i.e. the first empty range to add is for blkno=0).
3003 *
3004 * The empty tuple is built only once, and then reused for all future calls.
3005 */
3006static void
3009{
3010 BlockNumber blkno;
3011
3012 /*
3013 * If we already summarized some ranges, we need to start with the next
3014 * one. Otherwise start from the first range of the table.
3015 */
3017
3018 /* Generate empty ranges until we hit the next non-empty range. */
3020 {
3021 /* Did we already build the empty tuple? If not, do it now. */
3023
3025 &state->bs_currentInsertBuf,
3027
3028 /* try next page range */
3029 blkno += state->bs_pagesPerRange;
3030 }
3031}
void aclcheck_error(AclResult aclerr, ObjectType objtype, const char *objectname)
Definition aclchk.c:2654
bool object_ownercheck(Oid classid, Oid objectid, Oid roleid)
Definition aclchk.c:4090
bool AutoVacuumRequestWork(AutoVacuumWorkItemType type, Oid relationId, BlockNumber blkno)
Definition autovacuum.c:3304
void WaitForParallelWorkersToFinish(ParallelContext *pcxt)
Definition parallel.c:803
ParallelContext * CreateParallelContext(const char *library_name, const char *function_name, int nworkers)
Definition parallel.c:173
void WaitForParallelWorkersToAttach(ParallelContext *pcxt)
Definition parallel.c:700
void pgstat_report_query_id(int64 query_id, bool force)
Definition backend_status.c:686
void pgstat_report_activity(BackendState state, const char *cmd_str)
Definition backend_status.c:572
static void brin_vacuum_scan(Relation idxrel, BufferAccessStrategy strategy)
Definition brin.c:2173
void brinrescan(IndexScanDesc scan, ScanKey scankey, int nscankeys, ScanKey orderbys, int norderbys)
Definition brin.c:960
static void terminate_brin_buildstate(BrinBuildState *state)
Definition brin.c:1717
IndexBulkDeleteResult * brinbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
Definition brin.c:1304
static void brinsummarize(Relation index, Relation heapRel, BlockNumber pageRange, bool include_partial, double *numSummarized, double *numExisting)
Definition brin.c:1888
static void union_tuples(BrinDesc *bdesc, BrinMemTuple *a, BrinTuple *b)
Definition brin.c:2032
static void _brin_parallel_scan_and_build(BrinBuildState *state, BrinShared *brinshared, Sharedsort *sharedsort, Relation heap, Relation index, int sortmem, bool progress)
Definition brin.c:2821
static BrinBuildState * initialize_brin_buildstate(Relation idxRel, BrinRevmap *revmap, BlockNumber pagesPerRange, BlockNumber tablePages)
Definition brin.c:1670
static void _brin_begin_parallel(BrinBuildState *buildstate, Relation heap, Relation index, bool isconcurrent, int request)
Definition brin.c:2378
static void _brin_leader_participate_as_worker(BrinBuildState *buildstate, Relation heap, Relation index)
Definition brin.c:2793
static bool add_values_to_range(Relation idxRel, BrinDesc *bdesc, BrinMemTuple *dtup, const Datum *values, const bool *nulls)
Definition brin.c:2220
static void _brin_end_parallel(BrinLeader *brinleader, BrinBuildState *state)
Definition brin.c:2563
static Size _brin_parallel_estimate_shared(Relation heap, Snapshot snapshot)
Definition brin.c:2782
static void brin_fill_empty_ranges(BrinBuildState *state, BlockNumber prevRange, BlockNumber nextRange)
Definition brin.c:3008
IndexBuildResult * brinbuild(Relation heap, Relation index, IndexInfo *indexInfo)
Definition brin.c:1106
IndexBulkDeleteResult * brinvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
Definition brin.c:1319
static void summarize_range(IndexInfo *indexInfo, BrinBuildState *state, Relation heapRel, BlockNumber heapBlk, BlockNumber heapNumBlks)
Definition brin.c:1762
static void brinbuildCallbackParallel(Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *brstate)
Definition brin.c:1047
bool brininsert(Relation idxRel, Datum *values, bool *nulls, ItemPointer heaptid, Relation heapRel, IndexUniqueCheck checkUnique, bool indexUnchanged, IndexInfo *indexInfo)
Definition brin.c:345
void _brin_parallel_build_main(dsm_segment *seg, shm_toc *toc)
Definition brin.c:2878
static void brin_build_empty_tuple(BrinBuildState *state, BlockNumber blkno)
Definition brin.c:2971
static double _brin_parallel_heapscan(BrinBuildState *state)
Definition brin.c:2594
static BrinInsertState * initialize_brin_insertstate(Relation idxRel, IndexInfo *indexInfo)
Definition brin.c:316
static void brinbuildCallback(Relation index, ItemPointer tid, Datum *values, bool *isnull, bool tupleIsAlive, void *brstate)
Definition brin.c:996
static bool check_null_keys(BrinValues *bval, ScanKey *nullkeys, int nnullkeys)
Definition brin.c:2314
bool brin_doupdate(Relation idxrel, BlockNumber pagesPerRange, BrinRevmap *revmap, BlockNumber heapBlk, Buffer oldbuf, OffsetNumber oldoff, const BrinTuple *origtup, Size origsz, const BrinTuple *newtup, Size newsz, bool samepage)
Definition brin_pageops.c:53
OffsetNumber brin_doinsert(Relation idxrel, BlockNumber pagesPerRange, BrinRevmap *revmap, Buffer *buffer, BlockNumber heapBlk, const BrinTuple *tup, Size itemsz)
Definition brin_pageops.c:341
void brin_metapage_init(Page page, BlockNumber pagesPerRange, uint16 version)
Definition brin_pageops.c:484
bool brin_can_do_samepage_update(Buffer buffer, Size origsz, Size newsz)
Definition brin_pageops.c:322
bool brinRevmapDesummarizeRange(Relation idxrel, BlockNumber heapBlk)
Definition brin_revmap.c:323
BrinRevmap * brinRevmapInitialize(Relation idxrel, BlockNumber *pagesPerRange)
Definition brin_revmap.c:70
BrinTuple * brinGetTupleForHeapBlock(BrinRevmap *revmap, BlockNumber heapBlk, Buffer *buf, OffsetNumber *off, Size *size, int mode)
Definition brin_revmap.c:194
BrinTuple * brin_copy_tuple(BrinTuple *tuple, Size len, BrinTuple *dest, Size *destsz)
Definition brin_tuple.c:445
BrinTuple * brin_form_tuple(BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple, Size *size)
Definition brin_tuple.c:99
BrinTuple * brin_form_placeholder_tuple(BrinDesc *brdesc, BlockNumber blkno, Size *size)
Definition brin_tuple.c:387
BrinMemTuple * brin_memtuple_initialize(BrinMemTuple *dtuple, BrinDesc *brdesc)
Definition brin_tuple.c:510
BrinMemTuple * brin_deform_tuple(BrinDesc *brdesc, BrinTuple *tuple, BrinMemTuple *dMemtuple)
Definition brin_tuple.c:552
Buffer ExtendBufferedRel(BufferManagerRelation bmr, ForkNumber forkNum, BufferAccessStrategy strategy, uint32 flags)
Definition bufmgr.c:964
static ItemId PageGetItemId(Page page, OffsetNumber offsetNumber)
Definition bufpage.h:243
bool ConditionVariableCancelSleep(void)
Definition condition_variable.c:232
void ConditionVariableInit(ConditionVariable *cv)
Definition condition_variable.c:37
void ConditionVariableSleep(ConditionVariable *cv, uint32 wait_event_info)
Definition condition_variable.c:98
void ConditionVariableSignal(ConditionVariable *cv)
Definition condition_variable.c:261
Datum FunctionCall4Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3, Datum arg4)
Definition fmgr.c:1197
Datum FunctionCall3Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2, Datum arg3)
Definition fmgr.c:1172
void fmgr_info_copy(FmgrInfo *dstinfo, FmgrInfo *srcinfo, MemoryContext destcxt)
Definition fmgr.c:581
void FreeSpaceMapVacuumRange(Relation rel, BlockNumber start, BlockNumber end)
Definition freespace.c:377
void RecordPageWithFreeSpace(Relation rel, BlockNumber heapBlk, Size spaceAvail)
Definition freespace.c:194
IndexScanDesc RelationGetIndexScan(Relation indexRelation, int nkeys, int norderbys)
Definition genam.c:80
bool(* IndexBulkDeleteCallback)(ItemPointer itemptr, void *state)
Definition genam.h:93
FmgrInfo * index_getprocinfo(Relation irel, AttrNumber attnum, uint16 procnum)
Definition indexam.c:917
void InstrAccumParallelQuery(BufferUsage *bufusage, WalUsage *walusage)
Definition instrument.c:215
void InstrEndParallelQuery(BufferUsage *bufusage, WalUsage *walusage)
Definition instrument.c:205
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
Definition itemptr.h:124
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition itemptr.h:103
void GetUserIdAndSecContext(Oid *userid, int *sec_context)
Definition miscinit.c:612
void SetUserIdAndSecContext(Oid userid, int sec_context)
Definition miscinit.c:619
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:124
Buffer read_stream_next_buffer(ReadStream *stream, void **per_buffer_data)
Definition read_stream.c:791
ReadStream * read_stream_begin_relation(int flags, BufferAccessStrategy strategy, Relation rel, ForkNumber forknum, ReadStreamBlockNumberCB callback, void *callback_private_data, size_t per_buffer_data_size)
Definition read_stream.c:737
BlockNumber block_range_read_stream_cb(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
Definition read_stream.c:162
void * build_reloptions(Datum reloptions, bool validate, relopt_kind kind, Size relopt_struct_size, const relopt_parse_elt *relopt_elems, int num_relopt_elems)
Definition reloptions.c:2041
void brincostestimate(PlannerInfo *root, IndexPath *path, double loop_count, Cost *indexStartupCost, Cost *indexTotalCost, Selectivity *indexSelectivity, double *indexCorrelation, double *indexPages)
Definition selfuncs.c:8991
Definition read_stream.h:71
BlockNumber current_blocknum
Definition read_stream.h:72
Definition brin.c:156
Definition brin_internal.h:45
Definition brin.c:193
Definition brin.c:123
Definition brin_tuple.h:45
Definition brin_page.h:65
Definition brin.c:203
Definition brin_internal.h:26
Definition brin.h:23
Definition brin_revmap.c:47
Definition brin.h:34
Definition brin_tuple.h:64
Definition brin_tuple.h:30
Definition freelist.c:65
Definition instrument.h:25
Definition amapi.h:233
Definition genam.h:37
Definition genam.h:82
Definition execnodes.h:165
Definition relscan.h:135
Definition genam.h:51
Definition itemid.h:26
Definition itemptr.h:37
Definition memnodes.h:118
Definition parallel.h:32
Definition read_stream.c:93
Definition rel.h:56
Definition skey.h:65
Definition snapshot.h:139
Definition tuplesort.h:49
Definition tidbitmap.c:142
Definition relscan.h:33
Definition tupdesc.h:136
Definition tuplesort.c:184
Definition instrument.h:52
Definition dsm.c:67
Definition reloptions.h:159
Definition shm_toc.c:27
Definition regguts.h:323
Definition brin_xlog.h:51
TableScanDesc table_beginscan_parallel(Relation relation, ParallelTableScanDesc pscan)
Definition tableam.c:166
Size table_parallelscan_estimate(Relation rel, Snapshot snapshot)
Definition tableam.c:131
void table_parallelscan_initialize(Relation rel, ParallelTableScanDesc pscan, Snapshot snapshot)
Definition tableam.c:146
static double table_index_build_range_scan(Relation table_rel, Relation index_rel, IndexInfo *index_info, bool allow_sync, bool anyvisible, bool progress, BlockNumber start_blockno, BlockNumber numblocks, IndexBuildCallback callback, void *callback_state, TableScanDesc scan)
Definition tableam.h:1787
static double table_index_build_scan(Relation table_rel, Relation index_rel, IndexInfo *index_info, bool allow_sync, bool progress, IndexBuildCallback callback, void *callback_state, TableScanDesc scan)
Definition tableam.h:1754
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition test_ifaddrs.c:46
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:160
void tuplesort_initialize_shared(Sharedsort *shared, int nWorkers, dsm_segment *seg)
Definition tuplesort.c:2921
void tuplesort_attach_shared(Sharedsort *shared, dsm_segment *seg)
Definition tuplesort.c:2944
Tuplesortstate * tuplesort_begin_index_brin(int workMem, SortCoordinate coordinate, int sortopt)
Definition tuplesortvariants.c:556
BrinTuple * tuplesort_getbrintuple(Tuplesortstate *state, Size *len, bool forward)
Definition tuplesortvariants.c:1084
void tuplesort_putbrintuple(Tuplesortstate *state, BrinTuple *tuple, Size size)
Definition tuplesortvariants.c:871
XLogRecPtr log_newpage_buffer(Buffer buffer, bool page_std)
Definition xloginsert.c:1259
void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags)
Definition xloginsert.c:245
Typedef Documentation
◆ BrinBuildState
◆ BrinInsertState
◆ BrinLeader
◆ BrinOpaque
◆ BrinShared
Function Documentation
◆ _brin_begin_parallel()
|
static |
Definition at line 2378 of file brin.c.
2380{
2381 ParallelContext *pcxt;
2382 int scantuplesortstates;
2383 Snapshot snapshot;
2386 BrinShared *brinshared;
2387 Sharedsort *sharedsort;
2389 WalUsage *walusage;
2390 BufferUsage *bufferusage;
2393
2394#ifdef DISABLE_LEADER_PARTICIPATION
2396#endif
2397
2398 /*
2399 * Enter parallel mode, and create context for parallel build of brin
2400 * index
2401 */
2402 EnterParallelMode();
2405 request);
2406
2408
2409 /*
2410 * Prepare for scan of the base relation. In a normal index build, we use
2411 * SnapshotAny because we must retrieve all tuples and do our own time
2412 * qual checks (because we have to index RECENTLY_DEAD tuples). In a
2413 * concurrent build, we take a regular MVCC snapshot and index whatever's
2414 * live according to that.
2415 */
2416 if (!isconcurrent)
2417 snapshot = SnapshotAny;
2418 else
2420
2421 /*
2422 * Estimate size for our own PARALLEL_KEY_BRIN_SHARED workspace.
2423 */
2428
2430
2431 /*
2432 * Estimate space for WalUsage and BufferUsage -- PARALLEL_KEY_WAL_USAGE
2433 * and PARALLEL_KEY_BUFFER_USAGE.
2434 *
2435 * If there are no extensions loaded that care, we could skip this. We
2436 * have no way of knowing whether anyone's looking at pgWalUsage or
2437 * pgBufferUsage, so do it unconditionally.
2438 */
2445
2446 /* Finally, estimate PARALLEL_KEY_QUERY_TEXT space */
2448 {
2452 }
2453 else
2455
2456 /* Everyone's had a chance to ask for space, so now create the DSM */
2457 InitializeParallelDSM(pcxt);
2458
2459 /* If no DSM segment was available, back out (do serial build) */
2461 {
2463 UnregisterSnapshot(snapshot);
2464 DestroyParallelContext(pcxt);
2465 ExitParallelMode();
2466 return;
2467 }
2468
2469 /* Store shared build state, for which we reserved space */
2471 /* Initialize immutable state */
2474 brinshared->isconcurrent = isconcurrent;
2475 brinshared->scantuplesortstates = scantuplesortstates;
2480
2481 /* Initialize mutable state */
2482 brinshared->nparticipantsdone = 0;
2483 brinshared->reltuples = 0.0;
2484 brinshared->indtuples = 0.0;
2485
2486 table_parallelscan_initialize(heap,
2487 ParallelTableScanFromBrinShared(brinshared),
2488 snapshot);
2489
2490 /*
2491 * Store shared tuplesort-private state, for which we reserved space.
2492 * Then, initialize opaque state using tuplesort routine.
2493 */
2495 tuplesort_initialize_shared(sharedsort, scantuplesortstates,
2496 pcxt->seg);
2497
2498 /*
2499 * Store shared tuplesort-private state, for which we reserved space.
2500 * Then, initialize opaque state using tuplesort routine.
2501 */
2504
2505 /* Store query string for workers */
2507 {
2509
2513 }
2514
2515 /*
2516 * Allocate space for each worker's WalUsage and BufferUsage; no need to
2517 * initialize.
2518 */
2525
2526 /* Launch workers, saving status for leader/caller */
2527 LaunchParallelWorkers(pcxt);
2528 brinleader->pcxt = pcxt;
2531 brinleader->nparticipanttuplesorts++;
2532 brinleader->brinshared = brinshared;
2533 brinleader->sharedsort = sharedsort;
2534 brinleader->snapshot = snapshot;
2535 brinleader->walusage = walusage;
2536 brinleader->bufferusage = bufferusage;
2537
2538 /* If no workers were successfully launched, back out (do serial build) */
2540 {
2542 return;
2543 }
2544
2545 /* Save leader state now that it's clear build will be parallel */
2547
2548 /* Join heap scan ourselves */
2551
2552 /*
2553 * Caller needs to wait for all launched workers when we return. Make
2554 * sure that the failure-to-start case will not hang forever.
2555 */
2556 WaitForParallelWorkersToAttach(pcxt);
2557}
References _brin_end_parallel(), _brin_leader_participate_as_worker(), _brin_parallel_estimate_shared(), Assert, ConditionVariableInit(), CreateParallelContext(), debug_query_string, DestroyParallelContext(), EnterParallelMode(), ParallelContext::estimator, ExitParallelMode(), fb(), GetTransactionSnapshot(), BrinShared::heaprelid, BrinShared::indexrelid, BrinShared::indtuples, InitializeParallelDSM(), BrinShared::isconcurrent, IsMVCCSnapshot, LaunchParallelWorkers(), mul_size(), BrinShared::mutex, BrinShared::nparticipantsdone, ParallelContext::nworkers, ParallelContext::nworkers_launched, BrinShared::pagesPerRange, palloc0_object, PARALLEL_KEY_BRIN_SHARED, PARALLEL_KEY_BUFFER_USAGE, PARALLEL_KEY_QUERY_TEXT, PARALLEL_KEY_TUPLESORT, PARALLEL_KEY_WAL_USAGE, ParallelTableScanFromBrinShared, pgstat_get_my_query_id(), BrinShared::queryid, RegisterSnapshot(), RelationGetRelid, BrinShared::reltuples, BrinShared::scantuplesortstates, ParallelContext::seg, shm_toc_allocate(), shm_toc_estimate_chunk, shm_toc_estimate_keys, shm_toc_insert(), SnapshotAny, SpinLockInit, table_parallelscan_initialize(), ParallelContext::toc, tuplesort_estimate_shared(), tuplesort_initialize_shared(), UnregisterSnapshot(), WaitForParallelWorkersToAttach(), and BrinShared::workersdonecv.
Referenced by brinbuild().
◆ _brin_end_parallel()
|
static |
Definition at line 2563 of file brin.c.
2564{
2566
2567 /* Shutdown worker processes */
2569
2570 /*
2571 * Next, accumulate WAL usage. (This must wait for the workers to finish,
2572 * or we might get incomplete data.)
2573 */
2576
2577 /* Free last reference to MVCC snapshot, if one was used */
2581 ExitParallelMode();
2582}
References DestroyParallelContext(), ExitParallelMode(), fb(), i, InstrAccumParallelQuery(), IsMVCCSnapshot, UnregisterSnapshot(), and WaitForParallelWorkersToFinish().
Referenced by _brin_begin_parallel(), and brinbuild().
◆ _brin_leader_participate_as_worker()
|
static |
Definition at line 2793 of file brin.c.
2794{
2797
2798 /*
2799 * Might as well use reliable figure when doling out maintenance_work_mem
2800 * (when requested number of workers were not launched, this will be
2801 * somewhat higher than it is for other workers).
2802 */
2804
2805 /* Perform work common to all participants */
2808}
References _brin_parallel_scan_and_build(), fb(), maintenance_work_mem, and BrinLeader::nparticipanttuplesorts.
Referenced by _brin_begin_parallel().
◆ _brin_parallel_build_main()
| void _brin_parallel_build_main | ( | dsm_segment * | seg, |
| shm_toc * | toc | ||
| ) |
Definition at line 2878 of file brin.c.
2879{
2881 BrinShared *brinshared;
2882 Sharedsort *sharedsort;
2884 Relation heapRel;
2885 Relation indexRel;
2888 WalUsage *walusage;
2889 BufferUsage *bufferusage;
2891
2892 /*
2893 * The only possible status flag that can be set to the parallel worker is
2894 * PROC_IN_SAFE_IC.
2895 */
2898
2899 /* Set debug_query_string for individual workers first */
2902
2903 /* Report the query string from leader */
2905
2906 /* Look up brin shared state */
2908
2909 /* Open relations using lock modes known to be obtained by index.c */
2911 {
2914 }
2915 else
2916 {
2919 }
2920
2921 /* Track query ID */
2923
2924 /* Open relations within worker */
2927
2929 brinshared->pagesPerRange,
2930 InvalidBlockNumber);
2931
2932 /* Look up shared state private to tuplesort.c */
2934 tuplesort_attach_shared(sharedsort, seg);
2935
2936 /* Prepare to track buffer usage during parallel execution */
2937 InstrStartParallelQuery();
2938
2939 /*
2940 * Might as well use reliable figure when doling out maintenance_work_mem
2941 * (when requested number of workers were not launched, this will be
2942 * somewhat higher than it is for other workers).
2943 */
2945
2948
2949 /* Report WAL/buffer usage during parallel execution */
2953 &walusage[ParallelWorkerNumber]);
2954
2957}
References _brin_parallel_scan_and_build(), AccessExclusiveLock, Assert, debug_query_string, fb(), BrinShared::heaprelid, index_close(), index_open(), BrinShared::indexrelid, initialize_brin_buildstate(), InstrEndParallelQuery(), InstrStartParallelQuery(), InvalidBlockNumber, BrinShared::isconcurrent, maintenance_work_mem, MyProc, BrinShared::pagesPerRange, PARALLEL_KEY_BRIN_SHARED, PARALLEL_KEY_BUFFER_USAGE, PARALLEL_KEY_QUERY_TEXT, PARALLEL_KEY_TUPLESORT, PARALLEL_KEY_WAL_USAGE, ParallelWorkerNumber, pgstat_report_activity(), pgstat_report_query_id(), PROC_IN_SAFE_IC, BrinShared::queryid, RowExclusiveLock, BrinShared::scantuplesortstates, ShareLock, ShareUpdateExclusiveLock, shm_toc_lookup(), STATE_RUNNING, PGPROC::statusFlags, table_close(), table_open(), and tuplesort_attach_shared().
◆ _brin_parallel_estimate_shared()
Definition at line 2782 of file brin.c.
2783{
2784 /* c.f. shm_toc_allocate as to why BUFFERALIGN is used */
2786 table_parallelscan_estimate(heap, snapshot));
2787}
References add_size(), BUFFERALIGN, and table_parallelscan_estimate().
Referenced by _brin_begin_parallel().
◆ _brin_parallel_heapscan()
|
static |
Definition at line 2594 of file brin.c.
2595{
2597 int nparticipanttuplesorts;
2598
2599 nparticipanttuplesorts = state->bs_leader->nparticipanttuplesorts;
2600 for (;;)
2601 {
2604 {
2605 /* copy the data into leader state */
2608
2610 break;
2611 }
2613
2616 }
2617
2618 ConditionVariableCancelSleep();
2619
2621}
References ConditionVariableCancelSleep(), ConditionVariableSleep(), fb(), BrinShared::indtuples, BrinShared::mutex, BrinShared::nparticipantsdone, BrinShared::reltuples, SpinLockAcquire, SpinLockRelease, and BrinShared::workersdonecv.
Referenced by _brin_parallel_merge().
◆ _brin_parallel_merge()
|
static |
Definition at line 2635 of file brin.c.
2636{
2639 Size tuplen;
2642 oldCxt;
2643 double reltuples;
2644
2645 /* wait for workers to scan table and produce partial results */
2647
2648 /* do the actual sort in the leader */
2650
2651 /*
2652 * Initialize BrinMemTuple we'll use to union summaries from workers (in
2653 * case they happened to produce parts of the same page range).
2654 */
2656
2657 /*
2658 * Create a memory context we'll reset to combine results for a single
2659 * page range (received from the workers). We don't expect huge number of
2660 * overlaps under regular circumstances, because for large tables the
2661 * chunk size is likely larger than the BRIN page range), but it can
2662 * happen, and the union functions may do all kinds of stuff. So we better
2663 * reset the context once in a while.
2664 */
2666 "brin union",
2667 ALLOCSET_DEFAULT_SIZES);
2669
2670 /*
2671 * Read the BRIN tuples from the shared tuplesort, sorted by block number.
2672 * That probably gives us an index that is cheaper to scan, thanks to
2673 * mostly getting data from the same index page as before.
2674 */
2676 {
2677 /* Ranges should be multiples of pages_per_range for the index. */
2679
2680 /*
2681 * Do we need to union summaries for the same page range?
2682 *
2683 * If this is the first brin tuple we read, then just deform it into
2684 * the memtuple, and continue with the next one from tuplesort. We
2685 * however may need to insert empty summaries into the index.
2686 *
2687 * If it's the same block as the last we saw, we simply union the brin
2688 * tuple into it, and we're done - we don't even need to insert empty
2689 * ranges, because that was done earlier when we saw the first brin
2690 * tuple (for this range).
2691 *
2692 * Finally, if it's not the first brin tuple, and it's not the same
2693 * page range, we need to do the insert and then deform the tuple into
2694 * the memtuple. Then we'll insert empty ranges before the new brin
2695 * tuple, if needed.
2696 */
2698 {
2699 /* First brin tuples, just deform into memtuple. */
2701
2702 /* continue to insert empty pages before thisblock */
2703 }
2705 {
2706 /*
2707 * Not the first brin tuple, but same page range as the previous
2708 * one, so we can merge it into the memtuple.
2709 */
2711 continue;
2712 }
2713 else
2714 {
2715 BrinTuple *tmp;
2717
2718 /*
2719 * We got brin tuple for a different page range, so form a brin
2720 * tuple from the memtuple, insert it, and re-init the memtuple
2721 * from the new brin tuple.
2722 */
2725
2728
2729 /*
2730 * Reset the per-output-range context. This frees all the memory
2731 * possibly allocated by the union functions, and also the BRIN
2732 * tuple we just formed and inserted.
2733 */
2735
2737
2738 /* continue to insert empty pages before thisblock */
2739 }
2740
2741 /* Fill empty ranges for all ranges missing in the tuplesort. */
2743
2744 prevblkno = btup->bt_blkno;
2745 }
2746
2748
2749 /* Fill the BRIN tuple for the last page range with data. */
2751 {
2752 BrinTuple *tmp;
2754
2757
2760
2761 pfree(tmp);
2762 }
2763
2764 /* Fill empty ranges at the end, for all ranges missing in the tuplesort. */
2766
2767 /*
2768 * Switch back to the original memory context, and destroy the one we
2769 * created to isolate the union_tuple calls.
2770 */
2773
2774 return reltuples;
2775}
References _brin_parallel_heapscan(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, brin_deform_tuple(), brin_doinsert(), brin_fill_empty_ranges(), brin_form_tuple(), brin_new_memtuple(), BrinTuple::bt_blkno, CurrentMemoryContext, fb(), InvalidBlockNumber, len, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), pfree(), tuplesort_end(), tuplesort_getbrintuple(), tuplesort_performsort(), and union_tuples().
Referenced by brinbuild().
◆ _brin_parallel_scan_and_build()
|
static |
Definition at line 2821 of file brin.c.
2825{
2827 TableScanDesc scan;
2828 double reltuples;
2829 IndexInfo *indexInfo;
2830
2831 /* Initialize local tuplesort coordination state */
2834 coordinate->nParticipants = -1;
2835 coordinate->sharedsort = sharedsort;
2836
2837 /* Begin "partial" tuplesort */
2839 TUPLESORT_NONE);
2840
2841 /* Join parallel scan */
2844
2845 scan = table_beginscan_parallel(heap,
2846 ParallelTableScanFromBrinShared(brinshared));
2847
2850
2851 /* insert the last item */
2853
2854 /* sort the BRIN ranges built by this worker */
2856
2857 state->bs_reltuples += reltuples;
2858
2859 /*
2860 * Done. Record ambuild statistics.
2861 */
2863 brinshared->nparticipantsdone++;
2867
2868 /* Notify leader */
2870
2872}
References brinbuildCallbackParallel(), BuildIndexInfo(), ConditionVariableSignal(), fb(), form_and_spill_tuple(), IndexInfo::ii_Concurrent, BrinShared::indtuples, BrinShared::isconcurrent, BrinShared::mutex, BrinShared::nparticipantsdone, palloc0_object, ParallelTableScanFromBrinShared, BrinShared::reltuples, SpinLockAcquire, SpinLockRelease, table_beginscan_parallel(), table_index_build_scan(), tuplesort_begin_index_brin(), tuplesort_end(), TUPLESORT_NONE, tuplesort_performsort(), and BrinShared::workersdonecv.
Referenced by _brin_leader_participate_as_worker(), and _brin_parallel_build_main().
◆ add_values_to_range()
|
static |
Definition at line 2220 of file brin.c.
2222{
2223 int keyno;
2224
2225 /* If the range starts empty, we're certainly going to modify it. */
2227
2228 /*
2229 * Compare the key values of the new tuple to the stored index values; our
2230 * deformed tuple will get updated if the new tuple doesn't fit the
2231 * original range (note this means we can't break out of the loop early).
2232 * Make a note of whether this happens, so that we know to insert the
2233 * modified tuple later.
2234 */
2236 {
2237 Datum result;
2238 BrinValues *bval;
2240 bool has_nulls;
2241
2242 bval = &dtup->bt_columns[keyno];
2243
2244 /*
2245 * Does the range have actual NULL values? Either of the flags can be
2246 * set, but we ignore the state before adding first row.
2247 *
2248 * We have to remember this, because we'll modify the flags and we
2249 * need to know if the range started as empty.
2250 */
2251 has_nulls = ((!dtup->bt_empty_range) &&
2253
2254 /*
2255 * If the value we're adding is NULL, handle it locally. Otherwise
2256 * call the BRIN_PROCNUM_ADDVALUE procedure.
2257 */
2259 {
2260 /*
2261 * If the new value is null, we record that we saw it if it's the
2262 * first one; otherwise, there's nothing to do.
2263 */
2265 {
2268 }
2269
2270 continue;
2271 }
2272
2274 BRIN_PROCNUM_ADDVALUE);
2276 idxRel->rd_indcollation[keyno],
2278 PointerGetDatum(bval),
2279 values[keyno],
2280 BoolGetDatum(nulls[keyno]));
2281 /* if that returned true, we need to insert the updated tuple */
2283
2284 /*
2285 * If the range was had actual NULL values (i.e. did not start empty),
2286 * make sure we don't forget about the NULL values. Either the
2287 * allnulls flag is still set to true, or (if the opclass cleared it)
2288 * we need to set hasnulls=true.
2289 *
2290 * XXX This can only happen when the opclass modified the tuple, so
2291 * the modified flag should be set.
2292 */
2294 {
2297 }
2298 }
2299
2300 /*
2301 * After updating summaries for all the keys, mark it as not empty.
2302 *
2303 * If we're actually changing the flag value (i.e. tuple started as
2304 * empty), we should have modified the tuple. So we should not see empty
2305 * range that was not modified.
2306 */
2309
2311}
References Assert, BoolGetDatum(), BRIN_PROCNUM_ADDVALUE, BrinValues::bv_allnulls, BrinValues::bv_hasnulls, DatumGetBool(), fb(), FunctionCall4Coll(), index_getprocinfo(), PointerGetDatum(), and values.
Referenced by brinbuildCallback(), brinbuildCallbackParallel(), and brininsert().
◆ brin_build_desc()
Definition at line 1582 of file brin.c.
1583{
1586 TupleDesc tupdesc;
1588 int keyno;
1589 long totalsize;
1590 MemoryContext cxt;
1592
1594 "brin desc cxt",
1595 ALLOCSET_SMALL_SIZES);
1597 tupdesc = RelationGetDescr(rel);
1598
1599 /*
1600 * Obtain BrinOpcInfo for each indexed column. While at it, accumulate
1601 * the number of columns stored, since the number is opclass-defined.
1602 */
1605 {
1608
1610
1614 }
1615
1616 /* Allocate our result struct and fill it in */
1619
1621 bdesc->bd_context = cxt;
1622 bdesc->bd_index = rel;
1623 bdesc->bd_tupdesc = tupdesc;
1626
1630
1632
1634}
References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, BRIN_PROCNUM_OPCINFO, CurrentMemoryContext, DatumGetPointer(), fb(), FunctionCall1, index_getprocinfo(), MemoryContextSwitchTo(), TupleDescData::natts, ObjectIdGetDatum(), palloc(), palloc_array, pfree(), RelationGetDescr, and TupleDescAttr().
Referenced by brin_page_items(), brinbeginscan(), initialize_brin_buildstate(), and initialize_brin_insertstate().
◆ brin_build_empty_tuple()
|
static |
Definition at line 2971 of file brin.c.
2972{
2973 /* First time an empty tuple is requested? If yes, initialize it. */
2975 {
2978
2979 /* Allocate the tuple in context for the whole index build. */
2981
2983 &state->bs_emptyTupleLen);
2984
2986 }
2987 else
2988 {
2989 /* If we already have an empty tuple, just update the block. */
2990 state->bs_emptyTuple->bt_blkno = blkno;
2991 }
2992}
References brin_form_tuple(), brin_new_memtuple(), fb(), and MemoryContextSwitchTo().
Referenced by brin_fill_empty_ranges().
◆ brin_desummarize_range()
| Datum brin_desummarize_range | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1492 of file brin.c.
1493{
1496 BlockNumber heapBlk;
1498 Relation heapRel;
1499 Relation indexRel;
1500 bool done;
1501
1507
1512 heapBlk64)));
1514
1515 /*
1516 * We must lock table before index to avoid deadlocks. However, if the
1517 * passed indexoid isn't an index then IndexGetRelation() will fail.
1518 * Rather than emitting a not-very-helpful error message, postpone
1519 * complaining, expecting that the is-it-an-index test below will fail.
1520 *
1521 * Unlike brin_summarize_range(), autovacuum never calls this. Hence, we
1522 * don't switch userid.
1523 */
1527 else
1528 heapRel = NULL;
1529
1531
1532 /* Must be a BRIN index */
1538 RelationGetRelationName(indexRel))));
1539
1540 /* User must own the index (comparable to privileges needed for VACUUM) */
1543 RelationGetRelationName(indexRel));
1544
1545 /*
1546 * Since we did the IndexGetRelation call above without any lock, it's
1547 * barely possible that a race against an index drop/recreation could have
1548 * netted us the wrong table. Recheck.
1549 */
1554 RelationGetRelationName(indexRel))));
1555
1556 /* see gin_clean_pending_list() */
1558 {
1559 /* the revmap does the hard work */
1560 do
1561 {
1562 done = brinRevmapDesummarizeRange(indexRel, heapBlk);
1563 }
1564 while (!done);
1565 }
1566 else
1570 RelationGetRelationName(indexRel))));
1571
1574
1575 PG_RETURN_VOID();
1576}
References aclcheck_error(), ACLCHECK_NOT_OWNER, brinRevmapDesummarizeRange(), DEBUG1, ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errhint(), errmsg(), ERROR, fb(), GetUserId(), index_close(), index_open(), IndexGetRelation(), MaxBlockNumber, OBJECT_INDEX, object_ownercheck(), OidIsValid, PG_GETARG_INT64, PG_GETARG_OID, PG_RETURN_VOID, RelationData::rd_index, RelationData::rd_rel, RecoveryInProgress(), RelationGetRelationName, ShareUpdateExclusiveLock, table_close(), and table_open().
◆ brin_fill_empty_ranges()
|
static |
Definition at line 3008 of file brin.c.
3010{
3011 BlockNumber blkno;
3012
3013 /*
3014 * If we already summarized some ranges, we need to start with the next
3015 * one. Otherwise start from the first range of the table.
3016 */
3018
3019 /* Generate empty ranges until we hit the next non-empty range. */
3021 {
3022 /* Did we already build the empty tuple? If not, do it now. */
3024
3026 &state->bs_currentInsertBuf,
3028
3029 /* try next page range */
3030 blkno += state->bs_pagesPerRange;
3031 }
3032}
References brin_build_empty_tuple(), brin_doinsert(), fb(), and InvalidBlockNumber.
Referenced by _brin_parallel_merge(), and brinbuild().
◆ brin_free_desc()
Definition at line 1637 of file brin.c.
1638{
1639 /* make sure the tupdesc is still valid */
1641 /* no need for retail pfree */
1643}
References Assert, fb(), and MemoryContextDelete().
Referenced by brin_page_items(), brinendscan(), and terminate_brin_buildstate().
◆ brin_summarize_new_values()
| Datum brin_summarize_new_values | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1367 of file brin.c.
1368{
1370
1372 relation,
1374}
References BRIN_ALL_BLOCKRANGES, brin_summarize_range(), DirectFunctionCall2, Int64GetDatum(), and PG_GETARG_DATUM.
◆ brin_summarize_range()
| Datum brin_summarize_range | ( | PG_FUNCTION_ARGS | ) |
Definition at line 1382 of file brin.c.
1383{
1386 BlockNumber heapBlk;
1388 Relation indexRel;
1389 Relation heapRel;
1390 Oid save_userid;
1391 int save_sec_context;
1392 int save_nestlevel;
1394
1400
1406
1407 /*
1408 * We must lock table before index to avoid deadlocks. However, if the
1409 * passed indexoid isn't an index then IndexGetRelation() will fail.
1410 * Rather than emitting a not-very-helpful error message, postpone
1411 * complaining, expecting that the is-it-an-index test below will fail.
1412 */
1415 {
1417
1418 /*
1419 * Autovacuum calls us. For its benefit, switch to the table owner's
1420 * userid, so that any index functions are run as that user. Also
1421 * lock down security-restricted operations and arrange to make GUC
1422 * variable changes local to this command. This is harmless, albeit
1423 * unnecessary, when called from SQL, because we fail shortly if the
1424 * user does not own the index.
1425 */
1426 GetUserIdAndSecContext(&save_userid, &save_sec_context);
1428 save_sec_context | SECURITY_RESTRICTED_OPERATION);
1429 save_nestlevel = NewGUCNestLevel();
1430 RestrictSearchPath();
1431 }
1432 else
1433 {
1434 heapRel = NULL;
1435 /* Set these just to suppress "uninitialized variable" warnings */
1436 save_userid = InvalidOid;
1437 save_sec_context = -1;
1438 save_nestlevel = -1;
1439 }
1440
1442
1443 /* Must be a BRIN index */
1449 RelationGetRelationName(indexRel))));
1450
1451 /* User must own the index (comparable to privileges needed for VACUUM) */
1454 RelationGetRelationName(indexRel));
1455
1456 /*
1457 * Since we did the IndexGetRelation call above without any lock, it's
1458 * barely possible that a race against an index drop/recreation could have
1459 * netted us the wrong table. Recheck.
1460 */
1465 RelationGetRelationName(indexRel))));
1466
1467 /* see gin_clean_pending_list() */
1470 else
1474 RelationGetRelationName(indexRel))));
1475
1476 /* Roll back any GUC changes executed by index functions */
1478
1479 /* Restore userid and security context */
1480 SetUserIdAndSecContext(save_userid, save_sec_context);
1481
1484
1486}
References aclcheck_error(), ACLCHECK_NOT_OWNER, AtEOXact_GUC(), BRIN_ALL_BLOCKRANGES, brinsummarize(), DEBUG1, ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errhint(), errmsg(), ERROR, fb(), GetUserIdAndSecContext(), index_close(), index_open(), IndexGetRelation(), InvalidOid, NewGUCNestLevel(), OBJECT_INDEX, object_ownercheck(), OidIsValid, PG_GETARG_INT64, PG_GETARG_OID, PG_RETURN_INT32, RelationData::rd_index, RelationData::rd_rel, RecoveryInProgress(), RelationGetRelationName, RestrictSearchPath(), SECURITY_RESTRICTED_OPERATION, SetUserIdAndSecContext(), ShareUpdateExclusiveLock, table_close(), and table_open().
Referenced by brin_summarize_new_values(), and perform_work_item().
◆ brin_vacuum_scan()
|
static |
Definition at line 2173 of file brin.c.
2174{
2175 BlockRangeReadStreamPrivate p;
2176 ReadStream *stream;
2178
2179 p.current_blocknum = 0;
2181
2182 /*
2183 * It is safe to use batchmode as block_range_read_stream_cb takes no
2184 * locks.
2185 */
2187 READ_STREAM_FULL |
2188 READ_STREAM_USE_BATCHING,
2189 strategy,
2190 idxrel,
2191 MAIN_FORKNUM,
2193 &p,
2194 0);
2195
2196 /*
2197 * Scan the index in physical order, and clean up any possible mess in
2198 * each page.
2199 */
2201 {
2202 CHECK_FOR_INTERRUPTS();
2203
2205
2207 }
2208
2209 read_stream_end(stream);
2210
2211 /*
2212 * Update all upper pages in the index's FSM, as well. This ensures not
2213 * only that we propagate leaf-page FSM updates made by brin_page_cleanup,
2214 * but also that any pre-existing damage or out-of-dateness is repaired.
2215 */
2217}
References block_range_read_stream_cb(), brin_page_cleanup(), buf, CHECK_FOR_INTERRUPTS, BlockRangeReadStreamPrivate::current_blocknum, fb(), FreeSpaceMapVacuum(), InvalidBuffer, BlockRangeReadStreamPrivate::last_exclusive, MAIN_FORKNUM, read_stream_begin_relation(), read_stream_end(), READ_STREAM_FULL, READ_STREAM_MAINTENANCE, read_stream_next_buffer(), READ_STREAM_USE_BATCHING, RelationGetNumberOfBlocks, and ReleaseBuffer().
Referenced by brinvacuumcleanup().
◆ brinbeginscan()
| IndexScanDesc brinbeginscan | ( | Relation | r, |
| int | nkeys, | ||
| int | norderbys | ||
| ) |
Definition at line 540 of file brin.c.
541{
542 IndexScanDesc scan;
543 BrinOpaque *opaque;
544
545 scan = RelationGetIndexScan(r, nkeys, norderbys);
546
550 scan->opaque = opaque;
551
552 return scan;
553}
References BrinOpaque::bo_bdesc, BrinOpaque::bo_pagesPerRange, BrinOpaque::bo_rmAccess, brin_build_desc(), brinRevmapInitialize(), IndexScanDescData::opaque, palloc_object, and RelationGetIndexScan().
Referenced by brinhandler().
◆ brinbuild()
| IndexBuildResult * brinbuild | ( | Relation | heap, |
| Relation | index, | ||
| IndexInfo * | indexInfo | ||
| ) |
Definition at line 1106 of file brin.c.
1107{
1108 IndexBuildResult *result;
1109 double reltuples;
1113 Buffer meta;
1114 BlockNumber pagesPerRange;
1115
1116 /*
1117 * We expect to be called exactly once for any index relation.
1118 */
1122
1123 /*
1124 * Critical section not required, because on error the creation of the
1125 * whole relation will be rolled back.
1126 */
1127
1131
1133 BRIN_CURRENT_VERSION);
1134 MarkBufferDirty(meta);
1135
1137 {
1140 Page page;
1141
1144
1145 XLogBeginInsert();
1148
1150
1151 page = BufferGetPage(meta);
1153 }
1154
1155 UnlockReleaseBuffer(meta);
1156
1157 /*
1158 * Initialize our state, including the deformed tuple state.
1159 */
1162 RelationGetNumberOfBlocks(heap));
1163
1164 /*
1165 * Attempt to launch parallel worker scan when required
1166 *
1167 * XXX plan_create_index_workers makes the number of workers dependent on
1168 * maintenance_work_mem, requiring 32MB for each worker. That makes sense
1169 * for btree, but not for BRIN, which can do with much less memory. So
1170 * maybe make that somehow less strict, optionally?
1171 */
1174 indexInfo->ii_ParallelWorkers);
1175
1176 /*
1177 * If parallel build requested and at least one worker process was
1178 * successfully launched, set up coordination state, wait for workers to
1179 * complete. Then read all tuples from the shared tuplesort and insert
1180 * them into the index.
1181 *
1182 * In serial mode, simply scan the table and build the index one index
1183 * tuple at a time.
1184 */
1186 {
1188
1191 coordinate->nParticipants =
1192 state->bs_leader->nparticipanttuplesorts;
1194
1195 /*
1196 * Begin leader tuplesort.
1197 *
1198 * In cases where parallelism is involved, the leader receives the
1199 * same share of maintenance_work_mem as a serial sort (it is
1200 * generally treated in the same way as a serial sort once we return).
1201 * Parallel worker Tuplesortstates will have received only a fraction
1202 * of maintenance_work_mem, though.
1203 *
1204 * We rely on the lifetime of the Leader Tuplesortstate almost not
1205 * overlapping with any worker Tuplesortstate's lifetime. There may
1206 * be some small overlap, but that's okay because we rely on leader
1207 * Tuplesortstate only allocating a small, fixed amount of memory
1208 * here. When its tuplesort_performsort() is called (by our caller),
1209 * and significant amounts of memory are likely to be used, all
1210 * workers must have already freed almost all memory held by their
1211 * Tuplesortstates (they are about to go away completely, too). The
1212 * overall effect is that maintenance_work_mem always represents an
1213 * absolute high watermark on the amount of memory used by a CREATE
1214 * INDEX operation, regardless of the use of parallelism or any other
1215 * factor.
1216 */
1217 state->bs_sortstate =
1219 TUPLESORT_NONE);
1220
1221 /* scan the relation and merge per-worker results */
1223
1225 }
1226 else /* no parallel index build */
1227 {
1228 /*
1229 * Now scan the relation. No syncscan allowed here because we want
1230 * the heap blocks in physical order (we want to produce the ranges
1231 * starting from block 0, and the callback also relies on this to not
1232 * generate summary for the same range twice).
1233 */
1236
1237 /*
1238 * process the final batch
1239 *
1240 * XXX Note this does not update state->bs_currRangeStart, i.e. it
1241 * stays set to the last range added to the index. This is OK, because
1242 * that's what brin_fill_empty_ranges expects.
1243 */
1245
1246 /*
1247 * Backfill the final ranges with empty data.
1248 *
1249 * This saves us from doing what amounts to full table scans when the
1250 * index with a predicate like WHERE (nonnull_column IS NULL), or
1251 * other very selective predicates.
1252 */
1254 state->bs_currRangeStart,
1255 state->bs_maxRangeStart);
1256 }
1257
1258 /* release resources */
1262
1263 /*
1264 * Return statistics
1265 */
1267
1268 result->heap_tuples = reltuples;
1270
1271 return result;
1272}
References _brin_begin_parallel(), _brin_end_parallel(), _brin_parallel_merge(), Assert, BMR_REL, BRIN_CURRENT_VERSION, brin_fill_empty_ranges(), BRIN_METAPAGE_BLKNO, brin_metapage_init(), brinbuildCallback(), BrinGetPagesPerRange, brinRevmapInitialize(), brinRevmapTerminate(), BufferGetBlockNumber(), BufferGetPage(), EB_LOCK_FIRST, EB_SKIP_EXTENSION_LOCK, elog, ERROR, ExtendBufferedRel(), fb(), form_and_insert_tuple(), IndexBuildResult::heap_tuples, IndexInfo::ii_Concurrent, IndexInfo::ii_ParallelWorkers, IndexBuildResult::index_tuples, initialize_brin_buildstate(), MAIN_FORKNUM, maintenance_work_mem, MarkBufferDirty(), PageSetLSN(), palloc0_object, palloc_object, REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetNumberOfBlocks, RelationGetRelationName, RelationNeedsWAL, SizeOfBrinCreateIdx, table_index_build_scan(), terminate_brin_buildstate(), tuplesort_begin_index_brin(), TUPLESORT_NONE, UnlockReleaseBuffer(), xl_brin_createidx::version, XLOG_BRIN_CREATE_INDEX, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().
Referenced by brinhandler().
◆ brinbuildCallback()
|
static |
Definition at line 996 of file brin.c.
1002{
1005
1007
1008 /*
1009 * If we're in a block that belongs to a future range, summarize what
1010 * we've got and start afresh. Note the scan might have skipped many
1011 * pages, if they were devoid of live tuples; make sure to insert index
1012 * tuples for those too.
1013 */
1015 {
1016
1018 "brinbuildCallback: completed a range: %u--%u",
1019 state->bs_currRangeStart,
1021
1022 /* create the index tuple and insert it */
1024
1025 /* set state to correspond to the next range */
1027
1028 /* re-initialize state for it */
1030 }
1031
1032 /* Accumulate the current tuple into the running state */
1034 values, isnull);
1035}
References add_values_to_range(), BRIN_elog, brin_memtuple_initialize(), DEBUG2, fb(), form_and_insert_tuple(), ItemPointerGetBlockNumber(), and values.
Referenced by brinbuild(), and summarize_range().
◆ brinbuildCallbackParallel()
|
static |
Definition at line 1047 of file brin.c.
1053{
1056
1058
1059 /*
1060 * If we're in a block that belongs to a different range, summarize what
1061 * we've got and start afresh. Note the scan might have skipped many
1062 * pages, if they were devoid of live tuples; we do not create empty BRIN
1063 * ranges here - the leader is responsible for filling them in.
1064 *
1065 * Unlike serial builds, parallel index builds allow synchronized seqscans
1066 * (because that's what parallel scans do). This means the block may wrap
1067 * around to the beginning of the relation, so the condition needs to
1068 * check for both future and past ranges.
1069 */
1072 {
1073
1075 "brinbuildCallbackParallel: completed a range: %u--%u",
1076 state->bs_currRangeStart,
1078
1079 /* create the index tuple and write it into the tuplesort */
1081
1082 /*
1083 * Set state to correspond to the next range (for this block).
1084 *
1085 * This skips ranges that are either empty (and so we don't get any
1086 * tuples to summarize), or processed by other workers. We can't
1087 * differentiate those cases here easily, so we leave it up to the
1088 * leader to fill empty ranges where needed.
1089 */
1090 state->bs_currRangeStart
1092
1093 /* re-initialize state for it */
1095 }
1096
1097 /* Accumulate the current tuple into the running state */
1099 values, isnull);
1100}
References add_values_to_range(), BRIN_elog, brin_memtuple_initialize(), DEBUG2, fb(), form_and_spill_tuple(), ItemPointerGetBlockNumber(), and values.
Referenced by _brin_parallel_scan_and_build().
◆ brinbuildempty()
Definition at line 1275 of file brin.c.
1276{
1278
1279 /* An empty BRIN index has a metapage only. */
1282
1283 /* Initialize and xlog metabuffer. */
1284 START_CRIT_SECTION();
1286 BRIN_CURRENT_VERSION);
1289 END_CRIT_SECTION();
1290
1292}
References BMR_REL, BRIN_CURRENT_VERSION, brin_metapage_init(), BrinGetPagesPerRange, BufferGetPage(), EB_LOCK_FIRST, EB_SKIP_EXTENSION_LOCK, END_CRIT_SECTION, ExtendBufferedRel(), fb(), INIT_FORKNUM, log_newpage_buffer(), MarkBufferDirty(), START_CRIT_SECTION, and UnlockReleaseBuffer().
Referenced by brinhandler().
◆ brinbulkdelete()
| IndexBulkDeleteResult * brinbulkdelete | ( | IndexVacuumInfo * | info, |
| IndexBulkDeleteResult * | stats, | ||
| IndexBulkDeleteCallback | callback, | ||
| void * | callback_state | ||
| ) |
Definition at line 1304 of file brin.c.
1306{
1307 /* allocate stats if first time through, else re-use existing struct */
1310
1311 return stats;
1312}
References fb(), and palloc0_object.
Referenced by brinhandler().
◆ brinendscan()
| void brinendscan | ( | IndexScanDesc | scan | ) |
Definition at line 979 of file brin.c.
980{
982
983 brinRevmapTerminate(opaque->bo_rmAccess);
984 brin_free_desc(opaque->bo_bdesc);
985 pfree(opaque);
986}
References BrinOpaque::bo_bdesc, BrinOpaque::bo_rmAccess, brin_free_desc(), brinRevmapTerminate(), IndexScanDescData::opaque, and pfree().
Referenced by brinhandler().
◆ bringetbitmap()
| int64 bringetbitmap | ( | IndexScanDesc | scan, |
| TIDBitmap * | tbm | ||
| ) |
Definition at line 568 of file brin.c.
569{
573 Oid heapOid;
574 Relation heapRel;
575 BrinOpaque *opaque;
576 BlockNumber nblocks;
578 FmgrInfo *consistentFn;
584 ScanKey **keys,
585 **nullkeys;
586 int *nkeys,
587 *nnullkeys;
588 char *ptr;
591
593 bdesc = opaque->bo_bdesc;
597
598 /*
599 * We need to know the size of the table so that we know how long to
600 * iterate on the revmap.
601 */
604 nblocks = RelationGetNumberOfBlocks(heapRel);
606
607 /*
608 * Make room for the consistent support procedures of indexed columns. We
609 * don't look them up here; we do that lazily the first time we see a scan
610 * key reference each of them. We rely on zeroing fn_oid to InvalidOid.
611 */
613
614 /*
615 * Make room for per-attribute lists of scan keys that we'll pass to the
616 * consistent support procedure. We don't know which attributes have scan
617 * keys, so we allocate space for all attributes. That may use more memory
618 * but it's probably cheaper than determining which attributes are used.
619 *
620 * We keep null and regular keys separate, so that we can pass just the
621 * regular keys to the consistent function easily.
622 *
623 * To reduce the allocation overhead, we allocate one big chunk and then
624 * carve it into smaller arrays ourselves. All the pieces have exactly the
625 * same lifetime, so that's OK.
626 *
627 * XXX The widest index can have 32 attributes, so the amount of wasted
628 * memory is negligible. We could invent a more compact approach (with
629 * just space for used attributes) but that would make the matching more
630 * complex so it's not a good trade-off.
631 */
632 len =
639
641 tmp = ptr;
642
643 keys = (ScanKey **) ptr;
645
646 nullkeys = (ScanKey **) ptr;
648
649 nkeys = (int *) ptr;
651
654
656 {
659
662 }
663
665
666 /* zero the number of keys */
669
670 /* Preprocess the scan keys - split them into per-attribute arrays. */
672 {
675
676 /*
677 * The collation of the scan key must match the collation used in the
678 * index column (but only if the search is not IS NULL/ IS NOT NULL).
679 * Otherwise we shouldn't be using this index ...
680 */
682 (key->sk_collation ==
684 keyattno - 1)->attcollation));
685
686 /*
687 * First time we see this index attribute, so init as needed.
688 *
689 * This is a bit of an overkill - we don't know how many scan keys are
690 * there for this attribute, so we simply allocate the largest number
691 * possible (as if all keys were for this attribute). This may waste a
692 * bit of memory, but we only expect small number of scan keys in
693 * general, so this should be negligible, and repeated repalloc calls
694 * are not free either.
695 */
697 {
698 FmgrInfo *tmp;
699
700 /* First time we see this attribute, so no key/null keys. */
703
705 BRIN_PROCNUM_CONSISTENT);
707 CurrentMemoryContext);
708 }
709
710 /* Add key to the proper per-attribute array. */
712 {
715 }
716 else
717 {
719 nkeys[keyattno - 1]++;
720 }
721 }
722
723 /* allocate an initial in-memory tuple, out of the per-range memcxt */
725
726 /*
727 * Setup and use a per-range memory context, which is reset every time we
728 * loop below. This avoids having to free the tuples within the loop.
729 */
731 "bringetbitmap cxt",
732 ALLOCSET_DEFAULT_SIZES);
734
735 /*
736 * Now scan the revmap. We start by querying for heap page 0,
737 * incrementing by the number of pages per range; this gives us a full
738 * view of the table. We make use of uint64 for heapBlk as a BlockNumber
739 * could wrap for tables with close to 2^32 pages.
740 */
742 {
746 OffsetNumber off;
747 Size size;
748
749 CHECK_FOR_INTERRUPTS();
750
752
754 &off, &size, BUFFER_LOCK_SHARE);
756 {
760 }
761
762 /*
763 * For page ranges with no indexed tuple, we must return the whole
764 * range; otherwise, compare it to the scan keys.
765 */
767 {
769 }
770 else
771 {
774 {
775 /*
776 * Placeholder tuples are always returned, regardless of the
777 * values stored in them.
778 */
780 }
781 else
782 {
783 int attno;
784
785 /*
786 * Compare scan keys with summary values stored for the range.
787 * If scan keys are matched, the page range must be added to
788 * the bitmap. We initially assume the range needs to be
789 * added; in particular this serves the case where there are
790 * no keys.
791 */
794 {
795 BrinValues *bval;
797 Oid collation;
798
799 /*
800 * skip attributes without any scan keys (both regular and
801 * IS [NOT] NULL)
802 */
804 continue;
805
806 bval = &dtup->bt_columns[attno - 1];
807
808 /*
809 * If the BRIN tuple indicates that this range is empty,
810 * we can skip it: there's nothing to match. We don't
811 * need to examine the next columns.
812 */
814 {
816 break;
817 }
818
819 /*
820 * First check if there are any IS [NOT] NULL scan keys,
821 * and if we're violating them. In that case we can
822 * terminate early, without invoking the support function.
823 *
824 * As there may be more keys, we can only determine
825 * mismatch within this loop.
826 */
828 !check_null_keys(bval, nullkeys[attno - 1],
829 nnullkeys[attno - 1]))
830 {
831 /*
832 * If any of the IS [NOT] NULL keys failed, the page
833 * range as a whole can't pass. So terminate the loop.
834 */
836 break;
837 }
838
839 /*
840 * So either there are no IS [NOT] NULL keys, or all
841 * passed. If there are no regular scan keys, we're done -
842 * the page range matches. If there are regular keys, but
843 * the page range is marked as 'all nulls' it can't
844 * possibly pass (we're assuming the operators are
845 * strict).
846 */
847
848 /* No regular scan keys - page range as a whole passes. */
849 if (!nkeys[attno - 1])
850 continue;
851
852 Assert((nkeys[attno - 1] > 0) &&
853 (nkeys[attno - 1] <= scan->numberOfKeys));
854
855 /* If it is all nulls, it cannot possibly be consistent. */
857 {
859 break;
860 }
861
862 /*
863 * Collation from the first key (has to be the same for
864 * all keys for the same attribute).
865 */
866 collation = keys[attno - 1][0]->sk_collation;
867
868 /*
869 * Check whether the scan key is consistent with the page
870 * range values; if so, have the pages in the range added
871 * to the output bitmap.
872 *
873 * The opclass may or may not support processing of
874 * multiple scan keys. We can determine that based on the
875 * number of arguments - functions with extra parameter
876 * (number of scan keys) do support this, otherwise we
877 * have to simply pass the scan keys one by one.
878 */
879 if (consistentFn[attno - 1].fn_nargs >= 4)
880 {
881 /* Check all keys at once */
883 collation,
885 PointerGetDatum(bval),
886 PointerGetDatum(keys[attno - 1]),
887 Int32GetDatum(nkeys[attno - 1]));
889 }
890 else
891 {
892 /*
893 * Check keys one by one
894 *
895 * When there are multiple scan keys, failure to meet
896 * the criteria for a single one of them is enough to
897 * discard the range as a whole, so break out of the
898 * loop as soon as a false return value is obtained.
899 */
900 int keyno;
901
902 for (keyno = 0; keyno < nkeys[attno - 1]; keyno++)
903 {
905 keys[attno - 1][keyno]->sk_collation,
907 PointerGetDatum(bval),
908 PointerGetDatum(keys[attno - 1][keyno]));
911 break;
912 }
913 }
914
915 /*
916 * If we found a scan key eliminating the range, no need
917 * to check additional ones.
918 */
920 break;
921 }
922 }
923 }
924
925 /* add the pages in the range to the output bitmap, if needed */
927 {
928 uint64 pageno;
929
930 for (pageno = heapBlk;
931 pageno <= Min(nblocks, heapBlk + opaque->bo_pagesPerRange) - 1;
932 pageno++)
933 {
935 tbm_add_page(tbm, pageno);
936 totalpages++;
938 }
939 }
940 }
941
944
947
948 /*
949 * XXX We have an approximation of the number of *pages* that our scan
950 * returns, but we don't have a precise idea of the number of heap tuples
951 * involved.
952 */
954}
References AccessShareLock, addrange(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert, BrinOpaque::bo_bdesc, BrinOpaque::bo_pagesPerRange, BrinOpaque::bo_rmAccess, brin_copy_tuple(), brin_deform_tuple(), brin_new_memtuple(), BRIN_PROCNUM_CONSISTENT, brinGetTupleForHeapBlock(), buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BrinValues::bv_allnulls, CHECK_FOR_INTERRUPTS, check_null_keys(), CurrentMemoryContext, DatumGetBool(), fb(), fmgr_info_copy(), FunctionCall3Coll(), FunctionCall4Coll(), i, index_getprocinfo(), IndexGetRelation(), IndexScanDescData::indexRelation, IndexScanDescData::instrument, Int32GetDatum(), InvalidBuffer, InvalidOid, IndexScanDescData::keyData, len, LockBuffer(), MAXALIGN, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), Min, IndexScanInstrumentation::nsearches, IndexScanDescData::numberOfKeys, IndexScanDescData::opaque, palloc(), palloc0_array, PG_USED_FOR_ASSERTS_ONLY, pgstat_count_index_scan, PointerGetDatum(), RelationGetNumberOfBlocks, RelationGetRelid, ReleaseBuffer(), ScanKeyData::sk_collation, SK_ISNULL, table_close(), table_open(), tbm_add_page(), and TupleDescAttr().
Referenced by brinhandler().
◆ brinGetStats()
| void brinGetStats | ( | Relation | index, |
| BrinStatsData * | stats | ||
| ) |
Definition at line 1649 of file brin.c.
References BRIN_METAPAGE_BLKNO, BUFFER_LOCK_SHARE, BufferGetPage(), fb(), BrinMetaPageData::lastRevmapPage, LockBuffer(), PageGetContents(), BrinStatsData::pagesPerRange, BrinMetaPageData::pagesPerRange, ReadBuffer(), BrinStatsData::revmapNumPages, and UnlockReleaseBuffer().
Referenced by brincostestimate().
◆ brinhandler()
| Datum brinhandler | ( | PG_FUNCTION_ARGS | ) |
Definition at line 250 of file brin.c.
251{
254 .amstrategies = 0,
255 .amsupport = BRIN_LAST_OPTIONAL_PROCNUM,
256 .amoptsprocnum = BRIN_PROCNUM_OPTIONS,
257 .amcanorder = false,
258 .amcanorderbyop = false,
259 .amcanhash = false,
260 .amconsistentequality = false,
261 .amconsistentordering = false,
262 .amcanbackward = false,
263 .amcanunique = false,
264 .amcanmulticol = true,
265 .amoptionalkey = true,
266 .amsearcharray = false,
267 .amsearchnulls = true,
268 .amstorage = true,
269 .amclusterable = false,
270 .ampredlocks = false,
271 .amcanparallel = false,
272 .amcanbuildparallel = true,
273 .amcaninclude = false,
274 .amusemaintenanceworkmem = false,
275 .amsummarizing = true,
276 .amparallelvacuumoptions =
278 .amkeytype = InvalidOid,
279
280 .ambuild = brinbuild,
281 .ambuildempty = brinbuildempty,
282 .aminsert = brininsert,
283 .aminsertcleanup = brininsertcleanup,
284 .ambulkdelete = brinbulkdelete,
285 .amvacuumcleanup = brinvacuumcleanup,
286 .amcanreturn = NULL,
287 .amcostestimate = brincostestimate,
288 .amgettreeheight = NULL,
289 .amoptions = brinoptions,
290 .amproperty = NULL,
291 .ambuildphasename = NULL,
292 .amvalidate = brinvalidate,
293 .amadjustmembers = NULL,
294 .ambeginscan = brinbeginscan,
295 .amrescan = brinrescan,
296 .amgettuple = NULL,
297 .amgetbitmap = bringetbitmap,
298 .amendscan = brinendscan,
299 .ammarkpos = NULL,
300 .amrestrpos = NULL,
301 .amestimateparallelscan = NULL,
302 .aminitparallelscan = NULL,
303 .amparallelrescan = NULL,
304 .amtranslatestrategy = NULL,
305 .amtranslatecmptype = NULL,
306 };
307
309}
References BRIN_LAST_OPTIONAL_PROCNUM, BRIN_PROCNUM_OPTIONS, brinbeginscan(), brinbuild(), brinbuildempty(), brinbulkdelete(), brincostestimate(), brinendscan(), bringetbitmap(), brininsert(), brininsertcleanup(), brinoptions(), brinrescan(), brinvacuumcleanup(), brinvalidate(), fb(), InvalidOid, PG_RETURN_POINTER, IndexAmRoutine::type, and VACUUM_OPTION_PARALLEL_CLEANUP.
◆ brininsert()
| bool brininsert | ( | Relation | idxRel, |
| Datum * | values, | ||
| bool * | nulls, | ||
| ItemPointer | heaptid, | ||
| Relation | heapRel, | ||
| IndexUniqueCheck | checkUnique, | ||
| bool | indexUnchanged, | ||
| IndexInfo * | indexInfo | ||
| ) |
Definition at line 345 of file brin.c.
350{
351 BlockNumber pagesPerRange;
353 BlockNumber heapBlk;
361
362 /*
363 * If first time through in this statement, initialize the insert state
364 * that we keep for all the inserts in the command.
365 */
366 if (!bistate)
368
369 revmap = bistate->bis_rmAccess;
370 bdesc = bistate->bis_desc;
371 pagesPerRange = bistate->bis_pages_per_range;
372
373 /*
374 * origHeapBlk is the block number where the insertion occurred. heapBlk
375 * is the first block in the corresponding page range.
376 */
378 heapBlk = (origHeapBlk / pagesPerRange) * pagesPerRange;
379
380 for (;;)
381 {
383 OffsetNumber off;
386
387 CHECK_FOR_INTERRUPTS();
388
389 /*
390 * If auto-summarization is enabled and we just inserted the first
391 * tuple into the first block of a new non-first page range, request a
392 * summarization run of the previous range.
393 */
394 if (autosummarize &&
395 heapBlk > 0 &&
396 heapBlk == origHeapBlk &&
398 {
401
402 lastPageTuple =
406 {
408
411 lastPageRange);
417 lastPageRange)));
418 }
419 else
421 }
422
425
426 /* if range is unsummarized, there's nothing to do */
428 break;
429
430 /* First time through in this brininsert call? */
432 {
434 "brininsert cxt",
435 ALLOCSET_DEFAULT_SIZES);
437 }
438
440
442
444 {
445 /*
446 * The tuple is consistent with the new values, so there's nothing
447 * to do.
448 */
450 }
451 else
452 {
460
461 /*
462 * Make a copy of the old tuple, so that we can compare it after
463 * re-acquiring the lock.
464 */
467
468 /*
469 * Before releasing the lock, check if we can attempt a same-page
470 * update. Another process could insert a tuple concurrently in
471 * the same page though, so downstream we must be prepared to cope
472 * if this turns out to not be possible after all.
473 */
477
478 /*
479 * Try to update the tuple. If this doesn't work for whatever
480 * reason, we need to restart from the top; the revmap might be
481 * pointing at a different tuple for this block now, so we need to
482 * recompute to ensure both our new heap tuple and the other
483 * inserter's are covered by the combined tuple. It might be that
484 * we don't need to update at all.
485 */
488 samepage))
489 {
490 /* no luck; start over */
492 continue;
493 }
494 }
495
496 /* success! */
497 break;
498 }
499
505
506 return false;
507}
References add_values_to_range(), ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AutoVacuumRequestWork(), AVW_BRINSummarizeRange, BrinInsertState::bis_desc, BrinInsertState::bis_pages_per_range, BrinInsertState::bis_rmAccess, brin_can_do_samepage_update(), brin_copy_tuple(), brin_deform_tuple(), brin_doupdate(), brin_form_tuple(), BrinGetAutoSummarize, brinGetTupleForHeapBlock(), buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage(), BufferIsValid(), CHECK_FOR_INTERRUPTS, CurrentMemoryContext, ereport, errcode(), errmsg(), fb(), FirstOffsetNumber, IndexInfo::ii_AmCache, initialize_brin_insertstate(), InvalidBuffer, ItemIdGetLength, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), LockBuffer(), LOG, MemoryContextDelete(), MemoryContextReset(), MemoryContextSwitchTo(), PageGetItemId(), RelationGetRelationName, RelationGetRelid, ReleaseBuffer(), and values.
Referenced by brinhandler().
◆ brininsertcleanup()
Definition at line 513 of file brin.c.
514{
516
517 /* bail out if cache not initialized */
519 return;
520
521 /* do this first to avoid dangling pointer if we fail partway through */
523
524 /*
525 * Clean up the revmap. Note that the brinDesc has already been cleaned up
526 * as part of its own memory context.
527 */
528 brinRevmapTerminate(bistate->bis_rmAccess);
529 pfree(bistate);
530}
References BrinInsertState::bis_rmAccess, brinRevmapTerminate(), fb(), IndexInfo::ii_AmCache, and pfree().
Referenced by brinhandler().
◆ brinoptions()
Definition at line 1349 of file brin.c.
References build_reloptions(), fb(), lengthof, RELOPT_KIND_BRIN, RELOPT_TYPE_BOOL, RELOPT_TYPE_INT, and validate().
Referenced by brinhandler().
◆ brinrescan()
| void brinrescan | ( | IndexScanDesc | scan, |
| ScanKey | scankey, | ||
| int | nscankeys, | ||
| ScanKey | orderbys, | ||
| int | norderbys | ||
| ) |
Definition at line 960 of file brin.c.
962{
963 /*
964 * Other index AMs preprocess the scan keys at this point, or sometime
965 * early during the scan; this lets them optimize by removing redundant
966 * keys, or doing early returns when they are impossible to satisfy; see
967 * _bt_preprocess_keys for an example. Something like that could be added
968 * here someday, too.
969 */
970
973}
References fb(), IndexScanDescData::keyData, and IndexScanDescData::numberOfKeys.
Referenced by brinhandler().
◆ brinsummarize()
|
static |
Definition at line 1888 of file brin.c.
1890{
1895 BlockNumber pagesPerRange;
1898
1900
1901 /* determine range of pages to process */
1904 startBlk = 0;
1905 else
1906 {
1909 }
1911 {
1912 /* Nothing to do if start point is beyond end of table */
1914 return;
1915 }
1916
1917 /*
1918 * Scan the revmap to find unsummarized items.
1919 */
1922 {
1924 OffsetNumber off;
1925
1926 /*
1927 * Unless requested to summarize even a partial range, go away now if
1928 * we think the next range is partial. Caller would pass true when it
1929 * is typically run once bulk data loading is done
1930 * (brin_summarize_new_values), and false when it is typically the
1931 * result of arbitrarily-scheduled maintenance command (vacuuming).
1932 */
1935 break;
1936
1937 CHECK_FOR_INTERRUPTS();
1938
1940 BUFFER_LOCK_SHARE);
1942 {
1943 /* no revmap entry for this heap range. Summarize it. */
1945 {
1946 /* first time through */
1947 Assert(!indexInfo);
1949 pagesPerRange,
1950 InvalidBlockNumber);
1952 }
1954
1955 /* and re-initialize state for the next range */
1957
1959 *numSummarized += 1.0;
1960 }
1961 else
1962 {
1964 *numExisting += 1.0;
1966 }
1967 }
1968
1971
1972 /* free resources */
1975 {
1977 pfree(indexInfo);
1978 }
1979}
References Assert, BRIN_ALL_BLOCKRANGES, brin_memtuple_initialize(), brinGetTupleForHeapBlock(), brinRevmapInitialize(), brinRevmapTerminate(), buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferIsValid(), BuildIndexInfo(), CHECK_FOR_INTERRUPTS, fb(), initialize_brin_buildstate(), InvalidBlockNumber, InvalidBuffer, LockBuffer(), Min, pfree(), RelationGetNumberOfBlocks, ReleaseBuffer(), summarize_range(), and terminate_brin_buildstate().
Referenced by brin_summarize_range(), and brinvacuumcleanup().
◆ brinvacuumcleanup()
| IndexBulkDeleteResult * brinvacuumcleanup | ( | IndexVacuumInfo * | info, |
| IndexBulkDeleteResult * | stats | ||
| ) |
Definition at line 1319 of file brin.c.
1320{
1321 Relation heapRel;
1322
1323 /* No-op in ANALYZE ONLY mode */
1325 return stats;
1326
1327 if (!stats)
1330 /* rest of stats is initialized by zeroing */
1331
1333 AccessShareLock);
1334
1336
1339
1341
1342 return stats;
1343}
References AccessShareLock, IndexVacuumInfo::analyze_only, BRIN_ALL_BLOCKRANGES, brin_vacuum_scan(), brinsummarize(), IndexVacuumInfo::index, IndexGetRelation(), IndexBulkDeleteResult::num_index_tuples, IndexBulkDeleteResult::num_pages, palloc0_object, RelationGetNumberOfBlocks, RelationGetRelid, IndexVacuumInfo::strategy, table_close(), and table_open().
Referenced by brinhandler().
◆ check_null_keys()
|
static |
Definition at line 2314 of file brin.c.
2315{
2316 int keyno;
2317
2318 /*
2319 * First check if there are any IS [NOT] NULL scan keys, and if we're
2320 * violating them.
2321 */
2323 {
2325
2327
2328 /* Handle only IS NULL/IS NOT NULL tests */
2330 continue;
2331
2333 {
2334 /* IS NULL scan key, but range has no NULLs */
2336 return false;
2337 }
2339 {
2340 /*
2341 * For IS NOT NULL, we can only skip ranges that are known to have
2342 * only nulls.
2343 */
2345 return false;
2346 }
2347 else
2348 {
2349 /*
2350 * Neither IS NULL nor IS NOT NULL was used; assume all indexable
2351 * operators are strict and thus return false with NULL value in
2352 * the scan key.
2353 */
2354 return false;
2355 }
2356 }
2357
2358 return true;
2359}
References Assert, BrinValues::bv_allnulls, BrinValues::bv_attno, BrinValues::bv_hasnulls, fb(), SK_ISNULL, SK_SEARCHNOTNULL, and SK_SEARCHNULL.
Referenced by bringetbitmap().
◆ form_and_insert_tuple()
|
static |
Definition at line 1986 of file brin.c.
1987{
1989 Size size;
1990
1992 state->bs_dtuple, &size);
1995 tup, size);
1996 state->bs_numtuples++;
1997
1999}
References brin_doinsert(), brin_form_tuple(), fb(), and pfree().
Referenced by brinbuild(), and brinbuildCallback().
◆ form_and_spill_tuple()
|
static |
Definition at line 2007 of file brin.c.
2008{
2010 Size size;
2011
2012 /* don't insert empty tuples in parallel build */
2014 return;
2015
2017 state->bs_dtuple, &size);
2018
2019 /* write the BRIN tuple to the tuplesort */
2021
2022 state->bs_numtuples++;
2023
2025}
References brin_form_tuple(), fb(), pfree(), and tuplesort_putbrintuple().
Referenced by _brin_parallel_scan_and_build(), and brinbuildCallbackParallel().
◆ initialize_brin_buildstate()
|
static |
Definition at line 1670 of file brin.c.
1672{
1675
1677
1679 state->bs_numtuples = 0;
1680 state->bs_reltuples = 0;
1682 state->bs_pagesPerRange = pagesPerRange;
1683 state->bs_currRangeStart = 0;
1688 state->bs_worker_id = 0;
1692 state->bs_emptyTupleLen = 0;
1693
1694 /* Remember the memory context to use for an empty tuple, if needed. */
1697 state->bs_emptyTupleLen = 0;
1698
1699 /*
1700 * Calculate the start of the last page range. Page numbers are 0-based,
1701 * so to calculate the index we need to subtract one. The integer division
1702 * gives us the index of the page range.
1703 */
1706
1707 /* Now calculate the start of the next range. */
1709
1711}
References brin_build_desc(), brin_new_memtuple(), CurrentMemoryContext, fb(), InvalidBuffer, and palloc_object.
Referenced by _brin_parallel_build_main(), brinbuild(), and brinsummarize().
◆ initialize_brin_insertstate()
|
static |
Definition at line 316 of file brin.c.
317{
318 BrinInsertState *bistate;
320
325 &bistate->bis_pages_per_range);
326 indexInfo->ii_AmCache = bistate;
328
329 return bistate;
330}
References BrinInsertState::bis_desc, BrinInsertState::bis_pages_per_range, BrinInsertState::bis_rmAccess, brin_build_desc(), brinRevmapInitialize(), fb(), IndexInfo::ii_AmCache, IndexInfo::ii_Context, MemoryContextSwitchTo(), and palloc0_object.
Referenced by brininsert().
◆ summarize_range()
|
static |
Definition at line 1762 of file brin.c.
1764{
1768 OffsetNumber offset;
1770
1771 /*
1772 * Insert the placeholder tuple
1773 */
1779
1780 /*
1781 * Compute range end. We hold ShareUpdateExclusive lock on table, so it
1782 * cannot shrink concurrently (but it can grow).
1783 */
1786 {
1787 /*
1788 * If we're asked to scan what we believe to be the final range on the
1789 * table (i.e. a range that might be partial) we need to recompute our
1790 * idea of what the latest page is after inserting the placeholder
1791 * tuple. Anyone that grows the table later will update the
1792 * placeholder tuple, so it doesn't matter that we won't scan these
1793 * pages ourselves. Careful: the table might have been extended
1794 * beyond the current range, so clamp our result.
1795 *
1796 * Fortunately, this should occur infrequently.
1797 */
1799 state->bs_pagesPerRange);
1800 }
1801 else
1802 {
1803 /* Easy case: range is known to be complete */
1805 }
1806
1807 /*
1808 * Execute the partial heap scan covering the heap blocks in the specified
1809 * page range, summarizing the heap tuples in it. This scan stops just
1810 * short of brinbuildCallback creating the new index entry.
1811 *
1812 * Note that it is critical we use the "any visible" mode of
1813 * table_index_build_range_scan here: otherwise, we would miss tuples
1814 * inserted by transactions that are still in progress, among other corner
1815 * cases.
1816 */
1817 state->bs_currRangeStart = heapBlk;
1819 heapBlk, scanNumBlks,
1821
1822 /*
1823 * Now we update the values obtained by the scan with the placeholder
1824 * tuple. We do this in a loop which only terminates if we're able to
1825 * update the placeholder tuple successfully; if we are not, this means
1826 * somebody else modified the placeholder tuple after we read it.
1827 */
1828 for (;;)
1829 {
1834
1835 CHECK_FOR_INTERRUPTS();
1836
1837 /*
1838 * Update the summary tuple and try to update.
1839 */
1843 didupdate =
1849
1850 /* If the update succeeded, we're done. */
1852 break;
1853
1854 /*
1855 * If the update didn't work, it might be because somebody updated the
1856 * placeholder tuple concurrently. Extract the new version, union it
1857 * with the values we have from the scan, and start over. (There are
1858 * other reasons for the update to fail, but it's simple to treat them
1859 * the same.)
1860 */
1863 /* the placeholder tuple must exist */
1868
1869 /* merge it into the tuple from the heap scan */
1871 }
1872
1874}
References Assert, brin_can_do_samepage_update(), brin_copy_tuple(), brin_doinsert(), brin_doupdate(), brin_form_placeholder_tuple(), brin_form_tuple(), brin_free_tuple(), brinbuildCallback(), brinGetTupleForHeapBlock(), BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, CHECK_FOR_INTERRUPTS, elog, ERROR, fb(), InvalidBuffer, LockBuffer(), Min, RelationGetNumberOfBlocks, ReleaseBuffer(), table_index_build_range_scan(), and union_tuples().
Referenced by brinsummarize().
◆ terminate_brin_buildstate()
|
static |
Definition at line 1717 of file brin.c.
1718{
1719 /*
1720 * Release the last index buffer used. We might as well ensure that
1721 * whatever free space remains in that page is available in FSM, too.
1722 */
1724 {
1725 Page page;
1726 Size freespace;
1728
1730 freespace = PageGetFreeSpace(page);
1735 }
1736
1740}
References brin_free_desc(), BufferGetBlockNumber(), BufferGetPage(), BufferIsInvalid, fb(), FreeSpaceMapVacuumRange(), PageGetFreeSpace(), pfree(), RecordPageWithFreeSpace(), and ReleaseBuffer().
Referenced by brinbuild(), and brinsummarize().
◆ union_tuples()
|
static |
Definition at line 2032 of file brin.c.
2033{
2034 int keyno;
2035 BrinMemTuple *db;
2036 MemoryContext cxt;
2038
2039 /* Use our own memory context to avoid retail pfree */
2041 "brin union",
2042 ALLOCSET_DEFAULT_SIZES);
2046
2047 /*
2048 * Check if the ranges are empty.
2049 *
2050 * If at least one of them is empty, we don't need to call per-key union
2051 * functions at all. If "b" is empty, we just use "a" as the result (it
2052 * might be empty fine, but that's fine). If "a" is empty but "b" is not,
2053 * we use "b" as the result (but we have to copy the data into "a" first).
2054 *
2055 * Only when both ranges are non-empty, we actually do the per-key merge.
2056 */
2057
2058 /* If "b" is empty - ignore it and just use "a" (even if it's empty etc.). */
2060 {
2061 /* skip the per-key merge */
2062 MemoryContextDelete(cxt);
2063 return;
2064 }
2065
2066 /*
2067 * Now we know "b" is not empty. If "a" is empty, then "b" is the result.
2068 * But we need to copy the data from "b" to "a" first, because that's how
2069 * we pass result out.
2070 *
2071 * We have to copy all the global/per-key flags etc. too.
2072 */
2074 {
2076 {
2081
2084
2085 /* If "b" has no data, we're done. */
2087 continue;
2088
2094 }
2095
2096 /* "a" started empty, but "b" was not empty, so remember that */
2098
2099 /* skip the per-key merge */
2100 MemoryContextDelete(cxt);
2101 return;
2102 }
2103
2104 /* Now we know neither range is empty. */
2106 {
2107 FmgrInfo *unionFn;
2111
2113 {
2114 /* Does the "b" summary represent any NULL values? */
2116
2117 /* Adjust "hasnulls". */
2120
2121 /* If there are no values in B, there's nothing left to do. */
2123 continue;
2124
2125 /*
2126 * Adjust "allnulls". If A doesn't have values, just copy the
2127 * values from B into A, and we're done. We cannot run the
2128 * operators in this case, because values in A might contain
2129 * garbage. Note we already established that B contains values.
2130 *
2131 * Also adjust "hasnulls" in order not to forget the summary
2132 * represents NULL values. This is not redundant with the earlier
2133 * update, because that only happens when allnulls=false.
2134 */
2136 {
2138
2141
2147
2148 continue;
2149 }
2150 }
2151
2153 BRIN_PROCNUM_UNION);
2154 FunctionCall3Coll(unionFn,
2155 bdesc->bd_index->rd_indcollation[keyno],
2159 }
2160
2161 MemoryContextDelete(cxt);
2162}
References a, ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, b, brin_deform_tuple(), BRIN_PROCNUM_UNION, BrinMemTuple::bt_columns, BrinMemTuple::bt_empty_range, CurrentMemoryContext, datumCopy(), fb(), FunctionCall3Coll(), i, index_getprocinfo(), MemoryContextDelete(), MemoryContextSwitchTo(), and PointerGetDatum().
Referenced by _brin_parallel_merge(), and summarize_range().
