PostgreSQL Source Code: contrib/bloom/blvacuum.c Source File

PostgreSQL Source Code git master
blvacuum.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * blvacuum.c
4 * Bloom VACUUM functions.
5 *
6 * Copyright (c) 2016-2025, 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
21
22/*
23 * Bulk deletion of all index entries pointing to a set of heap tuples.
24 * The set of target tuples is specified via a callback routine that tells
25 * whether any given heap tuple (identified by ItemPointer) is being deleted.
26 *
27 * Result: a palloc'd struct containing statistical info for VACUUM displays.
28 */
29IndexBulkDeleteResult *
30 blbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
31 IndexBulkDeleteCallback callback, void *callback_state)
32{
33 Relation index = info->index;
34 BlockNumber blkno,
35 npages;
36 FreeBlockNumberArray notFullPage;
37 int countPage = 0;
38 BloomState state;
39 Buffer buffer;
40 Page page;
41 BloomMetaPageData *metaData;
42 GenericXLogState *gxlogState;
43
44 if (stats == NULL)
45 stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
46
47 initBloomState(&state, index);
48
49 /*
50 * Iterate over the pages. We don't care about concurrently added pages,
51 * they can't contain tuples to delete.
52 */
53 npages = RelationGetNumberOfBlocks(index);
54 for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
55 {
56 BloomTuple *itup,
57 *itupPtr,
58 *itupEnd;
59
60 vacuum_delay_point(false);
61
62 buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
63 RBM_NORMAL, info->strategy);
64
65 LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
66 gxlogState = GenericXLogStart(index);
67 page = GenericXLogRegisterBuffer(gxlogState, buffer, 0);
68
69 /* Ignore empty/deleted pages until blvacuumcleanup() */
70 if (PageIsNew(page) || BloomPageIsDeleted(page))
71 {
72 UnlockReleaseBuffer(buffer);
73 GenericXLogAbort(gxlogState);
74 continue;
75 }
76
77 /*
78 * Iterate over the tuples. itup points to current tuple being
79 * scanned, itupPtr points to where to save next non-deleted tuple.
80 */
81 itup = itupPtr = BloomPageGetTuple(&state, page, FirstOffsetNumber);
82 itupEnd = BloomPageGetTuple(&state, page,
83 OffsetNumberNext(BloomPageGetMaxOffset(page)));
84 while (itup < itupEnd)
85 {
86 /* Do we have to delete this tuple? */
87 if (callback(&itup->heapPtr, callback_state))
88 {
89 /* Yes; adjust count of tuples that will be left on page */
90 BloomPageGetOpaque(page)->maxoff--;
91 stats->tuples_removed += 1;
92 }
93 else
94 {
95 /* No; copy it to itupPtr++, but skip copy if not needed */
96 if (itupPtr != itup)
97 memmove((Pointer) itupPtr, (Pointer) itup,
98 state.sizeOfBloomTuple);
99 itupPtr = BloomPageGetNextTuple(&state, itupPtr);
100 }
101
102 itup = BloomPageGetNextTuple(&state, itup);
103 }
104
105 /* Assert that we counted correctly */
106 Assert(itupPtr == BloomPageGetTuple(&state, page,
107 OffsetNumberNext(BloomPageGetMaxOffset(page))));
108
109 /*
110 * Add page to new notFullPage list if we will not mark page as
111 * deleted and there is free space on it
112 */
113 if (BloomPageGetMaxOffset(page) != 0 &&
114 BloomPageGetFreeSpace(&state, page) >= state.sizeOfBloomTuple &&
115 countPage < BloomMetaBlockN)
116 notFullPage[countPage++] = blkno;
117
118 /* Did we delete something? */
119 if (itupPtr != itup)
120 {
121 /* Is it empty page now? */
122 if (BloomPageGetMaxOffset(page) == 0)
123 BloomPageSetDeleted(page);
124 /* Adjust pd_lower */
125 ((PageHeader) page)->pd_lower = (Pointer) itupPtr - page;
126 /* Finish WAL-logging */
127 GenericXLogFinish(gxlogState);
128 }
129 else
130 {
131 /* Didn't change anything: abort WAL-logging */
132 GenericXLogAbort(gxlogState);
133 }
134 UnlockReleaseBuffer(buffer);
135 }
136
137 /*
138 * Update the metapage's notFullPage list with whatever we found. Our
139 * info could already be out of date at this point, but blinsert() will
140 * cope if so.
141 */
142 buffer = ReadBuffer(index, BLOOM_METAPAGE_BLKNO);
143 LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
144
145 gxlogState = GenericXLogStart(index);
146 page = GenericXLogRegisterBuffer(gxlogState, buffer, 0);
147
148 metaData = BloomPageGetMeta(page);
149 memcpy(metaData->notFullPage, notFullPage, sizeof(BlockNumber) * countPage);
150 metaData->nStart = 0;
151 metaData->nEnd = countPage;
152
153 GenericXLogFinish(gxlogState);
154 UnlockReleaseBuffer(buffer);
155
156 return stats;
157}
158
159/*
160 * Post-VACUUM cleanup.
161 *
162 * Result: a palloc'd struct containing statistical info for VACUUM displays.
163 */
164IndexBulkDeleteResult *
165 blvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
166{
167 Relation index = info->index;
168 BlockNumber npages,
169 blkno;
170
171 if (info->analyze_only)
172 return stats;
173
174 if (stats == NULL)
175 stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
176
177 /*
178 * Iterate over the pages: insert deleted pages into FSM and collect
179 * statistics.
180 */
181 npages = RelationGetNumberOfBlocks(index);
182 stats->num_pages = npages;
183 stats->pages_free = 0;
184 stats->num_index_tuples = 0;
185 for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
186 {
187 Buffer buffer;
188 Page page;
189
190 vacuum_delay_point(false);
191
192 buffer = ReadBufferExtended(index, MAIN_FORKNUM, blkno,
193 RBM_NORMAL, info->strategy);
194 LockBuffer(buffer, BUFFER_LOCK_SHARE);
195 page = BufferGetPage(buffer);
196
197 if (PageIsNew(page) || BloomPageIsDeleted(page))
198 {
199 RecordFreeIndexPage(index, blkno);
200 stats->pages_free++;
201 }
202 else
203 {
204 stats->num_index_tuples += BloomPageGetMaxOffset(page);
205 }
206
207 UnlockReleaseBuffer(buffer);
208 }
209
210 IndexFreeSpaceMapVacuum(info->index);
211
212 return stats;
213}
uint32 BlockNumber
Definition: block.h:31
#define BloomPageGetOpaque(page)
Definition: bloom.h:60
#define BloomPageGetFreeSpace(state, page)
Definition: bloom.h:149
#define BloomPageGetMeta(page)
Definition: bloom.h:133
BlockNumber FreeBlockNumberArray[MAXALIGN_DOWN(BLCKSZ - SizeOfPageHeaderData - MAXALIGN(sizeof(BloomPageOpaqueData)) - MAXALIGN(sizeof(uint16) *2+sizeof(uint32)+sizeof(BloomOptions)))/sizeof(BlockNumber)]
Definition: bloom.h:115
#define BloomPageGetMaxOffset(page)
Definition: bloom.h:61
#define BloomPageGetTuple(state, page, offset)
Definition: bloom.h:71
#define BloomPageSetDeleted(page)
Definition: bloom.h:66
#define BloomPageGetNextTuple(state, tuple)
Definition: bloom.h:74
#define BloomPageIsDeleted(page)
Definition: bloom.h:64
void initBloomState(BloomState *state, Relation index)
Definition: blutils.c:166
#define BLOOM_HEAD_BLKNO
Definition: bloom.h:79
#define BloomMetaBlockN
Definition: bloom.h:131
#define BLOOM_METAPAGE_BLKNO
Definition: bloom.h:78
IndexBulkDeleteResult * blbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
Definition: blvacuum.c:30
IndexBulkDeleteResult * blvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
Definition: blvacuum.c:165
int Buffer
Definition: buf.h:23
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:5355
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:5572
Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy)
Definition: bufmgr.c:805
Buffer ReadBuffer(Relation reln, BlockNumber blockNum)
Definition: bufmgr.c:758
#define BUFFER_LOCK_SHARE
Definition: bufmgr.h:197
#define RelationGetNumberOfBlocks(reln)
Definition: bufmgr.h:283
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:417
#define BUFFER_LOCK_EXCLUSIVE
Definition: bufmgr.h:198
@ RBM_NORMAL
Definition: bufmgr.h:46
PageHeaderData * PageHeader
Definition: bufpage.h:174
static bool PageIsNew(const PageData *page)
Definition: bufpage.h:234
PageData * Page
Definition: bufpage.h:82
char * Pointer
Definition: c.h:529
bool(* IndexBulkDeleteCallback)(ItemPointer itemptr, void *state)
Definition: genam.h:114
Page GenericXLogRegisterBuffer(GenericXLogState *state, Buffer buffer, int flags)
Definition: generic_xlog.c:299
GenericXLogState * GenericXLogStart(Relation relation)
Definition: generic_xlog.c:269
XLogRecPtr GenericXLogFinish(GenericXLogState *state)
Definition: generic_xlog.c:337
void GenericXLogAbort(GenericXLogState *state)
Definition: generic_xlog.c:444
Assert(PointerIsAligned(start, uint64))
void IndexFreeSpaceMapVacuum(Relation rel)
Definition: indexfsm.c:71
void RecordFreeIndexPage(Relation rel, BlockNumber freeBlock)
Definition: indexfsm.c:52
void * palloc0(Size size)
Definition: mcxt.c:1395
#define OffsetNumberNext(offsetNumber)
Definition: off.h:52
#define FirstOffsetNumber
Definition: off.h:27
@ MAIN_FORKNUM
Definition: relpath.h:58
FreeBlockNumberArray notFullPage
Definition: bloom.h:124
uint16 nEnd
Definition: bloom.h:122
uint16 nStart
Definition: bloom.h:121
Definition: bloom.h:136
Definition: bloom.h:158
ItemPointerData heapPtr
Definition: bloom.h:159
BlockNumber pages_free
Definition: genam.h:110
BlockNumber num_pages
Definition: genam.h:104
double tuples_removed
Definition: genam.h:107
double num_index_tuples
Definition: genam.h:106
Relation index
Definition: genam.h:73
bool analyze_only
Definition: genam.h:75
BufferAccessStrategy strategy
Definition: genam.h:80
Definition: rel.h:56
Definition: type.h:96
Definition: regguts.h:323
static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)
Definition: test_ifaddrs.c:46
void vacuum_delay_point(bool is_analyze)
Definition: vacuum.c:2423

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