Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * blvacuum.c
4 : : * Bloom VACUUM functions.
5 : : *
6 : : * Copyright (c) 2016-2026, PostgreSQL Global Development Group
7 : : *
8 : : * IDENTIFICATION
9 : : * contrib/bloom/blvacuum.c
10 : : *
11 : : *-------------------------------------------------------------------------
12 : : */
13 : : #include "postgres.h"
14 : :
15 : : #include "access/genam.h"
16 : : #include "bloom.h"
17 : : #include "commands/vacuum.h"
18 : : #include "storage/bufmgr.h"
19 : : #include "storage/indexfsm.h"
20 : : #include "storage/read_stream.h"
21 : :
22 : :
23 : : /*
24 : : * Bulk deletion of all index entries pointing to a set of heap tuples.
25 : : * The set of target tuples is specified via a callback routine that tells
26 : : * whether any given heap tuple (identified by ItemPointer) is being deleted.
27 : : *
28 : : * Result: a palloc'd struct containing statistical info for VACUUM displays.
29 : : */
30 : : IndexBulkDeleteResult *
31 : 11 : blbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
32 : : IndexBulkDeleteCallback callback, void *callback_state)
33 : : {
34 : 11 : Relation index = info->index;
35 : : BlockNumber blkno,
36 : : npages;
37 : : FreeBlockNumberArray notFullPage;
38 : 11 : int countPage = 0;
39 : : BloomState state;
40 : : Buffer buffer;
41 : : Page page;
42 : : BloomMetaPageData *metaData;
43 : : GenericXLogState *gxlogState;
44 : : BlockRangeReadStreamPrivate p;
45 : : ReadStream *stream;
46 : :
47 [ + - ]: 11 : if (stats == NULL)
48 : 11 : stats = palloc0_object(IndexBulkDeleteResult);
49 : :
50 : 11 : initBloomState(&state, index);
51 : :
52 : : /*
53 : : * Iterate over the pages. We don't care about concurrently added pages,
54 : : * they can't contain tuples to delete.
55 : : */
56 : 11 : npages = RelationGetNumberOfBlocks(index);
57 : :
58 : : /* Scan all blocks except the metapage using streaming reads */
59 : 11 : p.current_blocknum = BLOOM_HEAD_BLKNO;
60 : 11 : p.last_exclusive = npages;
61 : :
62 : : /*
63 : : * It is safe to use batchmode as block_range_read_stream_cb takes no
64 : : * locks.
65 : : */
66 : 11 : stream = read_stream_begin_relation(READ_STREAM_MAINTENANCE |
67 : : READ_STREAM_FULL |
68 : : READ_STREAM_USE_BATCHING,
69 : : info->strategy,
70 : : index,
71 : : MAIN_FORKNUM,
72 : : block_range_read_stream_cb,
73 : : &p,
74 : : 0);
75 : :
76 [ + + ]: 678 : for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
77 : : {
78 : : BloomTuple *itup,
79 : : *itupPtr,
80 : : *itupEnd;
81 : :
82 : 667 : vacuum_delay_point(false);
83 : :
84 : 667 : buffer = read_stream_next_buffer(stream, NULL);
85 : :
86 : 667 : LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
87 : 667 : gxlogState = GenericXLogStart(index);
88 : 667 : page = GenericXLogRegisterBuffer(gxlogState, buffer, 0);
89 : :
90 : : /* Ignore empty/deleted pages until blvacuumcleanup() */
91 [ + - + + ]: 667 : if (PageIsNew(page) || BloomPageIsDeleted(page))
92 : : {
93 : 4 : UnlockReleaseBuffer(buffer);
94 : 4 : GenericXLogAbort(gxlogState);
95 : 4 : continue;
96 : : }
97 : :
98 : : /*
99 : : * Iterate over the tuples. itup points to current tuple being
100 : : * scanned, itupPtr points to where to save next non-deleted tuple.
101 : : */
102 : 663 : itup = itupPtr = BloomPageGetTuple(&state, page, FirstOffsetNumber);
103 : 663 : itupEnd = BloomPageGetTuple(&state, page,
104 : : OffsetNumberNext(BloomPageGetMaxOffset(page)));
105 [ + + ]: 336663 : while (itup < itupEnd)
106 : : {
107 : : /* Do we have to delete this tuple? */
108 [ + + ]: 336000 : if (callback(&itup->heapPtr, callback_state))
109 : : {
110 : : /* Yes; adjust count of tuples that will be left on page */
111 : 48625 : BloomPageGetOpaque(page)->maxoff--;
112 : 48625 : stats->tuples_removed += 1;
113 : : }
114 : : else
115 : : {
116 : : /* No; copy it to itupPtr++, but skip copy if not needed */
117 [ + + ]: 287375 : if (itupPtr != itup)
118 : 284079 : memmove(itupPtr, itup, state.sizeOfBloomTuple);
119 : 287375 : itupPtr = BloomPageGetNextTuple(&state, itupPtr);
120 : : }
121 : :
122 : 336000 : itup = BloomPageGetNextTuple(&state, itup);
123 : : }
124 : :
125 : : /* Assert that we counted correctly */
126 : : Assert(itupPtr == BloomPageGetTuple(&state, page,
127 : : OffsetNumberNext(BloomPageGetMaxOffset(page))));
128 : :
129 : : /*
130 : : * Add page to new notFullPage list if we will not mark page as
131 : : * deleted and there is free space on it
132 : : */
133 [ + + ]: 663 : if (BloomPageGetMaxOffset(page) != 0 &&
134 [ + + ]: 659 : BloomPageGetFreeSpace(&state, page) >= state.sizeOfBloomTuple &&
135 [ + - ]: 656 : countPage < BloomMetaBlockN)
136 : 656 : notFullPage[countPage++] = blkno;
137 : :
138 : : /* Did we delete something? */
139 [ + + ]: 663 : if (itupPtr != itup)
140 : : {
141 : : /* Is it empty page now? */
142 [ + + ]: 659 : if (BloomPageGetMaxOffset(page) == 0)
143 : 4 : BloomPageSetDeleted(page);
144 : : /* Adjust pd_lower */
145 : 659 : ((PageHeader) page)->pd_lower = (char *) itupPtr - page;
146 : : /* Finish WAL-logging */
147 : 659 : GenericXLogFinish(gxlogState);
148 : : }
149 : : else
150 : : {
151 : : /* Didn't change anything: abort WAL-logging */
152 : 4 : GenericXLogAbort(gxlogState);
153 : : }
154 : 663 : UnlockReleaseBuffer(buffer);
155 : : }
156 : :
157 : : Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
158 : 11 : read_stream_end(stream);
159 : :
160 : : /*
161 : : * Update the metapage's notFullPage list with whatever we found. Our
162 : : * info could already be out of date at this point, but blinsert() will
163 : : * cope if so.
164 : : */
165 : 11 : buffer = ReadBuffer(index, BLOOM_METAPAGE_BLKNO);
166 : 11 : LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
167 : :
168 : 11 : gxlogState = GenericXLogStart(index);
169 : 11 : page = GenericXLogRegisterBuffer(gxlogState, buffer, 0);
170 : :
171 : 11 : metaData = BloomPageGetMeta(page);
172 : 11 : memcpy(metaData->notFullPage, notFullPage, sizeof(BlockNumber) * countPage);
173 : 11 : metaData->nStart = 0;
174 : 11 : metaData->nEnd = countPage;
175 : :
176 : 11 : GenericXLogFinish(gxlogState);
177 : 11 : UnlockReleaseBuffer(buffer);
178 : :
179 : 11 : return stats;
180 : : }
181 : :
182 : : /*
183 : : * Post-VACUUM cleanup.
184 : : *
185 : : * Result: a palloc'd struct containing statistical info for VACUUM displays.
186 : : */
187 : : IndexBulkDeleteResult *
188 : 12 : blvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
189 : : {
190 : 12 : Relation index = info->index;
191 : : BlockNumber npages,
192 : : blkno;
193 : : BlockRangeReadStreamPrivate p;
194 : : ReadStream *stream;
195 : :
196 [ - + ]: 12 : if (info->analyze_only)
197 : 0 : return stats;
198 : :
199 [ + + ]: 12 : if (stats == NULL)
200 : 1 : stats = palloc0_object(IndexBulkDeleteResult);
201 : :
202 : : /*
203 : : * Iterate over the pages: insert deleted pages into FSM and collect
204 : : * statistics.
205 : : */
206 : 12 : npages = RelationGetNumberOfBlocks(index);
207 : 12 : stats->num_pages = npages;
208 : 12 : stats->pages_free = 0;
209 : 12 : stats->num_index_tuples = 0;
210 : :
211 : : /* Scan all blocks except the metapage using streaming reads */
212 : 12 : p.current_blocknum = BLOOM_HEAD_BLKNO;
213 : 12 : p.last_exclusive = npages;
214 : :
215 : : /*
216 : : * It is safe to use batchmode as block_range_read_stream_cb takes no
217 : : * locks.
218 : : */
219 : 12 : stream = read_stream_begin_relation(READ_STREAM_MAINTENANCE |
220 : : READ_STREAM_FULL |
221 : : READ_STREAM_USE_BATCHING,
222 : : info->strategy,
223 : : index,
224 : : MAIN_FORKNUM,
225 : : block_range_read_stream_cb,
226 : : &p,
227 : : 0);
228 : :
229 [ + + ]: 787 : for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
230 : : {
231 : : Buffer buffer;
232 : : Page page;
233 : :
234 : 775 : vacuum_delay_point(false);
235 : :
236 : 775 : buffer = read_stream_next_buffer(stream, NULL);
237 : 775 : LockBuffer(buffer, BUFFER_LOCK_SHARE);
238 : 775 : page = BufferGetPage(buffer);
239 : :
240 [ + - + + ]: 775 : if (PageIsNew(page) || BloomPageIsDeleted(page))
241 : : {
242 : 8 : RecordFreeIndexPage(index, blkno);
243 : 8 : stats->pages_free++;
244 : : }
245 : : else
246 : : {
247 : 767 : stats->num_index_tuples += BloomPageGetMaxOffset(page);
248 : : }
249 : :
250 : 775 : UnlockReleaseBuffer(buffer);
251 : : }
252 : :
253 : : Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
254 : 12 : read_stream_end(stream);
255 : :
256 : 12 : IndexFreeSpaceMapVacuum(info->index);
257 : :
258 : 12 : return stats;
259 : : }
|
