Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * gistxlog.c
4 : : * WAL replay logic for GiST.
5 : : *
6 : : *
7 : : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
8 : : * Portions Copyright (c) 1994, Regents of the University of California
9 : : *
10 : : * IDENTIFICATION
11 : : * src/backend/access/gist/gistxlog.c
12 : : *-------------------------------------------------------------------------
13 : : */
14 : : #include "postgres.h"
15 : :
16 : : #include "access/bufmask.h"
17 : : #include "access/gist_private.h"
18 : : #include "access/gistxlog.h"
19 : : #include "access/transam.h"
20 : : #include "access/xloginsert.h"
21 : : #include "access/xlogutils.h"
22 : : #include "storage/standby.h"
23 : : #include "utils/memutils.h"
24 : : #include "utils/rel.h"
25 : :
26 : : static MemoryContext opCtx; /* working memory for operations */
27 : :
28 : : /*
29 : : * Replay the clearing of F_FOLLOW_RIGHT flag on a child page.
30 : : *
31 : : * Even if the WAL record includes a full-page image, we have to update the
32 : : * follow-right flag, because that change is not included in the full-page
33 : : * image. To be sure that the intermediate state with the wrong flag value is
34 : : * not visible to concurrent Hot Standby queries, this function handles
35 : : * restoring the full-page image as well as updating the flag. (Note that
36 : : * we never need to do anything else to the child page in the current WAL
37 : : * action.)
38 : : */
39 : : static void
4044 heikki.linnakangas@i 40 :CBC 444 : gistRedoClearFollowRight(XLogReaderState *record, uint8 block_id)
41 : : {
42 : 444 : XLogRecPtr lsn = record->EndRecPtr;
43 : : Buffer buffer;
44 : : Page page;
45 : : XLogRedoAction action;
46 : :
47 : : /*
48 : : * Note that we still update the page even if it was restored from a full
49 : : * page image, because the updated NSN is not included in the image.
50 : : */
51 : 444 : action = XLogReadBufferForRedo(record, block_id, &buffer);
4143 52 [ - + - - ]: 444 : if (action == BLK_NEEDS_REDO || action == BLK_RESTORED)
53 : : {
3527 kgrittn@postgresql.o 54 : 444 : page = BufferGetPage(buffer);
55 : :
4716 heikki.linnakangas@i 56 : 444 : GistPageSetNSN(page, lsn);
4782 tgl@sss.pgh.pa.us 57 : 444 : GistClearFollowRight(page);
58 : :
59 : 444 : PageSetLSN(page, lsn);
60 : 444 : MarkBufferDirty(buffer);
61 : : }
4143 heikki.linnakangas@i 62 [ + - ]: 444 : if (BufferIsValid(buffer))
63 : 444 : UnlockReleaseBuffer(buffer);
7490 teodor@sigaev.ru 64 : 444 : }
65 : :
66 : : /*
67 : : * redo any page update (except page split)
68 : : */
69 : : static void
4044 heikki.linnakangas@i 70 : 57486 : gistRedoPageUpdateRecord(XLogReaderState *record)
71 : : {
72 : 57486 : XLogRecPtr lsn = record->EndRecPtr;
73 : 57486 : gistxlogPageUpdate *xldata = (gistxlogPageUpdate *) XLogRecGetData(record);
74 : : Buffer buffer;
75 : : Page page;
76 : :
77 [ + + ]: 57486 : if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
78 : : {
79 : : char *begin;
80 : : char *data;
81 : : Size datalen;
1183 tgl@sss.pgh.pa.us 82 : 57131 : int ninserted PG_USED_FOR_ASSERTS_ONLY = 0;
83 : :
4044 heikki.linnakangas@i 84 : 57131 : data = begin = XLogRecGetBlockData(record, 0, &datalen);
85 : :
109 peter@eisentraut.org 86 :GNC 57131 : page = BufferGetPage(buffer);
87 : :
3385 tgl@sss.pgh.pa.us 88 [ + + + + ]:CBC 57131 : if (xldata->ntodelete == 1 && xldata->ntoinsert == 1)
4143 heikki.linnakangas@i 89 : 20877 : {
90 : : /*
91 : : * When replacing one tuple with one other tuple, we must use
92 : : * PageIndexTupleOverwrite for consistency with gistplacetopage.
93 : : */
3385 tgl@sss.pgh.pa.us 94 : 20877 : OffsetNumber offnum = *((OffsetNumber *) data);
95 : : IndexTuple itup;
96 : : Size itupsize;
97 : :
98 : 20877 : data += sizeof(OffsetNumber);
99 : 20877 : itup = (IndexTuple) data;
100 : 20877 : itupsize = IndexTupleSize(itup);
50 peter@eisentraut.org 101 [ - + ]:GNC 20877 : if (!PageIndexTupleOverwrite(page, offnum, itup, itupsize))
7 peter@eisentraut.org 102 [ # # ]:UNC 0 : elog(ERROR, "failed to add item to GiST index page, size %zu bytes", itupsize);
3385 tgl@sss.pgh.pa.us 103 :CBC 20877 : data += itupsize;
104 : : /* should be nothing left after consuming 1 tuple */
105 [ - + ]: 20877 : Assert(data - begin == datalen);
106 : : /* update insertion count for assert check below */
107 : 20877 : ninserted++;
108 : : }
109 [ + + ]: 36254 : else if (xldata->ntodelete > 0)
110 : : {
111 : : /* Otherwise, delete old tuples if any */
4143 heikki.linnakangas@i 112 : 450 : OffsetNumber *todelete = (OffsetNumber *) data;
113 : :
114 : 450 : data += sizeof(OffsetNumber) * xldata->ntodelete;
115 : :
3743 teodor@sigaev.ru 116 : 450 : PageIndexMultiDelete(page, todelete, xldata->ntodelete);
4143 heikki.linnakangas@i 117 [ + + ]: 450 : if (GistPageIsLeaf(page))
118 : 10 : GistMarkTuplesDeleted(page);
119 : : }
120 : :
121 : : /* Add new tuples if any */
4044 122 [ + + ]: 57131 : if (data - begin < datalen)
123 : : {
4143 124 [ + + ]: 36244 : OffsetNumber off = (PageIsEmpty(page)) ? FirstOffsetNumber :
942 tgl@sss.pgh.pa.us 125 : 36180 : OffsetNumberNext(PageGetMaxOffsetNumber(page));
126 : :
4044 heikki.linnakangas@i 127 [ + + ]: 72928 : while (data - begin < datalen)
128 : : {
4143 129 : 36684 : IndexTuple itup = (IndexTuple) data;
130 : 36684 : Size sz = IndexTupleSize(itup);
131 : : OffsetNumber l;
132 : :
133 : 36684 : data += sz;
134 : :
50 peter@eisentraut.org 135 :GNC 36684 : l = PageAddItem(page, itup, sz, off, false, false);
4143 heikki.linnakangas@i 136 [ - + ]:CBC 36684 : if (l == InvalidOffsetNumber)
7 peter@eisentraut.org 137 [ # # ]:UNC 0 : elog(ERROR, "failed to add item to GiST index page, size %zu bytes", sz);
4143 heikki.linnakangas@i 138 :CBC 36684 : off++;
4044 139 : 36684 : ninserted++;
140 : : }
141 : : }
142 : :
143 : : /* Check that XLOG record contained expected number of tuples */
144 [ - + ]: 57131 : Assert(ninserted == xldata->ntoinsert);
145 : :
4143 146 : 57131 : PageSetLSN(page, lsn);
147 : 57131 : MarkBufferDirty(buffer);
148 : : }
149 : :
150 : : /*
151 : : * Fix follow-right data on left child page
152 : : *
153 : : * This must be done while still holding the lock on the target page. Note
154 : : * that even if the target page no longer exists, we still attempt to
155 : : * replay the change on the child page.
156 : : */
4044 157 [ + + + - ]: 57486 : if (XLogRecHasBlockRef(record, 1))
158 : 442 : gistRedoClearFollowRight(record, 1);
159 : :
4143 160 [ + - ]: 57486 : if (BufferIsValid(buffer))
161 : 57486 : UnlockReleaseBuffer(buffer);
7490 teodor@sigaev.ru 162 : 57486 : }
163 : :
164 : :
165 : : /*
166 : : * redo delete on gist index page to remove tuples marked as DEAD during index
167 : : * tuple insertion
168 : : */
169 : : static void
2552 akorotkov@postgresql 170 :UBC 0 : gistRedoDeleteRecord(XLogReaderState *record)
171 : : {
172 : 0 : XLogRecPtr lsn = record->EndRecPtr;
173 : 0 : gistxlogDelete *xldata = (gistxlogDelete *) XLogRecGetData(record);
174 : : Buffer buffer;
175 : : Page page;
989 andres@anarazel.de 176 : 0 : OffsetNumber *toDelete = xldata->offsets;
177 : :
178 : : /*
179 : : * If we have any conflict processing to do, it must happen before we
180 : : * update the page.
181 : : *
182 : : * GiST delete records can conflict with standby queries. You might think
183 : : * that vacuum records would conflict as well, but we've handled that
184 : : * already. XLOG_HEAP2_PRUNE_VACUUM_SCAN records provide the highest xid
185 : : * cleaned by the vacuum of the heap and so we can resolve any conflicts
186 : : * just once when that arrives. After that we know that no conflicts
187 : : * exist from individual gist vacuum records on that index.
188 : : */
2552 akorotkov@postgresql 189 [ # # ]: 0 : if (InHotStandby)
190 : : {
191 : : RelFileLocator rlocator;
192 : :
1259 rhaas@postgresql.org 193 : 0 : XLogRecGetBlockTag(record, 0, &rlocator, NULL, NULL);
194 : :
1125 pg@bowt.ie 195 : 0 : ResolveRecoveryConflictWithSnapshot(xldata->snapshotConflictHorizon,
984 andres@anarazel.de 196 : 0 : xldata->isCatalogRel,
197 : : rlocator);
198 : : }
199 : :
2552 akorotkov@postgresql 200 [ # # ]: 0 : if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
201 : : {
109 peter@eisentraut.org 202 :UNC 0 : page = BufferGetPage(buffer);
203 : :
989 andres@anarazel.de 204 :UBC 0 : PageIndexMultiDelete(page, toDelete, xldata->ntodelete);
205 : :
2552 akorotkov@postgresql 206 : 0 : GistClearPageHasGarbage(page);
207 : 0 : GistMarkTuplesDeleted(page);
208 : :
209 : 0 : PageSetLSN(page, lsn);
210 : 0 : MarkBufferDirty(buffer);
211 : : }
212 : :
213 [ # # ]: 0 : if (BufferIsValid(buffer))
214 : 0 : UnlockReleaseBuffer(buffer);
215 : 0 : }
216 : :
217 : : /*
218 : : * Returns an array of index pointers.
219 : : */
220 : : static IndexTuple *
4044 heikki.linnakangas@i 221 :CBC 903 : decodePageSplitRecord(char *begin, int len, int *n)
222 : : {
223 : : char *ptr;
224 : 903 : int i = 0;
225 : : IndexTuple *tuples;
226 : :
227 : : /* extract the number of tuples */
228 : 903 : memcpy(n, begin, sizeof(int));
229 : 903 : ptr = begin + sizeof(int);
230 : :
231 : 903 : tuples = palloc(*n * sizeof(IndexTuple));
232 : :
233 [ + + ]: 78519 : for (i = 0; i < *n; i++)
234 : : {
235 [ - + ]: 77616 : Assert(ptr - begin < len);
236 : 77616 : tuples[i] = (IndexTuple) ptr;
237 : 77616 : ptr += IndexTupleSize((IndexTuple) ptr);
238 : : }
239 [ - + ]: 903 : Assert(ptr - begin == len);
240 : :
241 : 903 : return tuples;
242 : : }
243 : :
244 : : static void
245 : 449 : gistRedoPageSplitRecord(XLogReaderState *record)
246 : : {
247 : 449 : XLogRecPtr lsn = record->EndRecPtr;
5472 248 : 449 : gistxlogPageSplit *xldata = (gistxlogPageSplit *) XLogRecGetData(record);
4782 tgl@sss.pgh.pa.us 249 : 449 : Buffer firstbuffer = InvalidBuffer;
250 : : Buffer buffer;
251 : : Page page;
252 : : int i;
5472 heikki.linnakangas@i 253 : 449 : bool isrootsplit = false;
254 : :
255 : : /*
256 : : * We must hold lock on the first-listed page throughout the action,
257 : : * including while updating the left child page (if any). We can unlock
258 : : * remaining pages in the list as soon as they've been written, because
259 : : * there is no path for concurrent queries to reach those pages without
260 : : * first visiting the first-listed page.
261 : : */
262 : :
263 : : /* loop around all pages */
4044 264 [ + + ]: 1352 : for (i = 0; i < xldata->npage; i++)
265 : : {
266 : : int flags;
267 : : char *data;
268 : : Size datalen;
269 : : int num;
270 : : BlockNumber blkno;
271 : : IndexTuple *tuples;
272 : :
273 : 903 : XLogRecGetBlockTag(record, i + 1, NULL, NULL, &blkno);
274 [ + + ]: 903 : if (blkno == GIST_ROOT_BLKNO)
275 : : {
5472 276 [ - + ]: 5 : Assert(i == 0);
277 : 5 : isrootsplit = true;
278 : : }
279 : :
4044 280 : 903 : buffer = XLogInitBufferForRedo(record, i + 1);
109 peter@eisentraut.org 281 :GNC 903 : page = BufferGetPage(buffer);
4044 heikki.linnakangas@i 282 :CBC 903 : data = XLogRecGetBlockData(record, i + 1, &datalen);
283 : :
284 : 903 : tuples = decodePageSplitRecord(data, datalen, &num);
285 : :
286 : : /* ok, clear buffer */
287 [ + + + + ]: 903 : if (xldata->origleaf && blkno != GIST_ROOT_BLKNO)
5472 288 : 894 : flags = F_LEAF;
289 : : else
290 : 9 : flags = 0;
7390 bruce@momjian.us 291 : 903 : GISTInitBuffer(buffer, flags);
292 : :
293 : : /* and fill it */
4044 heikki.linnakangas@i 294 : 903 : gistfillbuffer(page, tuples, num, FirstOffsetNumber);
295 : :
296 [ + + ]: 903 : if (blkno == GIST_ROOT_BLKNO)
297 : : {
5472 298 : 5 : GistPageGetOpaque(page)->rightlink = InvalidBlockNumber;
4716 299 : 5 : GistPageSetNSN(page, xldata->orignsn);
5472 300 : 5 : GistClearFollowRight(page);
301 : : }
302 : : else
303 : : {
4044 304 [ + + ]: 898 : if (i < xldata->npage - 1)
305 : : {
306 : : BlockNumber nextblkno;
307 : :
308 : 449 : XLogRecGetBlockTag(record, i + 2, NULL, NULL, &nextblkno);
309 : 449 : GistPageGetOpaque(page)->rightlink = nextblkno;
310 : : }
311 : : else
5472 312 : 449 : GistPageGetOpaque(page)->rightlink = xldata->origrlink;
4716 313 : 898 : GistPageSetNSN(page, xldata->orignsn);
4044 314 [ + + + + ]: 898 : if (i < xldata->npage - 1 && !isrootsplit &&
5213 315 [ + - ]: 444 : xldata->markfollowright)
5472 316 : 444 : GistMarkFollowRight(page);
317 : : else
318 : 454 : GistClearFollowRight(page);
319 : : }
320 : :
7484 teodor@sigaev.ru 321 : 903 : PageSetLSN(page, lsn);
7200 tgl@sss.pgh.pa.us 322 : 903 : MarkBufferDirty(buffer);
323 : :
4782 324 [ + + ]: 903 : if (i == 0)
325 : 449 : firstbuffer = buffer;
326 : : else
327 : 454 : UnlockReleaseBuffer(buffer);
328 : : }
329 : :
330 : : /* Fix follow-right data on left child page, if any */
4044 heikki.linnakangas@i 331 [ + - + + ]: 449 : if (XLogRecHasBlockRef(record, 0))
332 : 2 : gistRedoClearFollowRight(record, 0);
333 : :
334 : : /* Finally, release lock on the first page */
4782 tgl@sss.pgh.pa.us 335 : 449 : UnlockReleaseBuffer(firstbuffer);
7490 teodor@sigaev.ru 336 : 449 : }
337 : :
338 : : /* redo page deletion */
339 : : static void
2461 heikki.linnakangas@i 340 : 81 : gistRedoPageDelete(XLogReaderState *record)
341 : : {
342 : 81 : XLogRecPtr lsn = record->EndRecPtr;
343 : 81 : gistxlogPageDelete *xldata = (gistxlogPageDelete *) XLogRecGetData(record);
344 : : Buffer parentBuffer;
345 : : Buffer leafBuffer;
346 : :
347 [ + - ]: 81 : if (XLogReadBufferForRedo(record, 0, &leafBuffer) == BLK_NEEDS_REDO)
348 : : {
109 peter@eisentraut.org 349 :GNC 81 : Page page = BufferGetPage(leafBuffer);
350 : :
2337 heikki.linnakangas@i 351 :CBC 81 : GistPageSetDeleted(page, xldata->deleteXid);
352 : :
2461 353 : 81 : PageSetLSN(page, lsn);
354 : 81 : MarkBufferDirty(leafBuffer);
355 : : }
356 : :
357 [ + + ]: 81 : if (XLogReadBufferForRedo(record, 1, &parentBuffer) == BLK_NEEDS_REDO)
358 : : {
109 peter@eisentraut.org 359 :GNC 80 : Page page = BufferGetPage(parentBuffer);
360 : :
2461 heikki.linnakangas@i 361 :CBC 80 : PageIndexTupleDelete(page, xldata->downlinkOffset);
362 : :
363 : 80 : PageSetLSN(page, lsn);
364 : 80 : MarkBufferDirty(parentBuffer);
365 : : }
366 : :
367 [ + - ]: 81 : if (BufferIsValid(parentBuffer))
368 : 81 : UnlockReleaseBuffer(parentBuffer);
369 [ + - ]: 81 : if (BufferIsValid(leafBuffer))
370 : 81 : UnlockReleaseBuffer(leafBuffer);
371 : 81 : }
372 : :
373 : : static void
2461 heikki.linnakangas@i 374 :UBC 0 : gistRedoPageReuse(XLogReaderState *record)
375 : : {
376 : 0 : gistxlogPageReuse *xlrec = (gistxlogPageReuse *) XLogRecGetData(record);
377 : :
378 : : /*
379 : : * PAGE_REUSE records exist to provide a conflict point when we reuse
380 : : * pages in the index via the FSM. That's all they do though.
381 : : *
382 : : * snapshotConflictHorizon was the page's deleteXid. The
383 : : * GlobalVisCheckRemovableFullXid(deleteXid) test in gistPageRecyclable()
384 : : * conceptually mirrors the PGPROC->xmin > limitXmin test in
385 : : * GetConflictingVirtualXIDs(). Consequently, one XID value achieves the
386 : : * same exclusion effect on primary and standby.
387 : : */
388 [ # # ]: 0 : if (InHotStandby)
1125 pg@bowt.ie 389 : 0 : ResolveRecoveryConflictWithSnapshotFullXid(xlrec->snapshotConflictHorizon,
984 andres@anarazel.de 390 : 0 : xlrec->isCatalogRel,
391 : : xlrec->locator);
2461 heikki.linnakangas@i 392 : 0 : }
393 : :
394 : : void
4044 heikki.linnakangas@i 395 :CBC 58016 : gist_redo(XLogReaderState *record)
396 : : {
397 : 58016 : uint8 info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
398 : : MemoryContext oldCxt;
399 : :
400 : : /*
401 : : * GiST indexes do not require any conflict processing. NB: If we ever
402 : : * implement a similar optimization we have in b-tree, and remove killed
403 : : * tuples outside VACUUM, we'll need to handle that here.
404 : : */
405 : :
7490 teodor@sigaev.ru 406 : 58016 : oldCxt = MemoryContextSwitchTo(opCtx);
7390 bruce@momjian.us 407 [ + - - + : 58016 : switch (info)
+ - - ]
408 : : {
7201 tgl@sss.pgh.pa.us 409 : 57486 : case XLOG_GIST_PAGE_UPDATE:
4044 heikki.linnakangas@i 410 : 57486 : gistRedoPageUpdateRecord(record);
7490 teodor@sigaev.ru 411 : 57486 : break;
2552 akorotkov@postgresql 412 :UBC 0 : case XLOG_GIST_DELETE:
413 : 0 : gistRedoDeleteRecord(record);
414 : 0 : break;
2461 heikki.linnakangas@i 415 : 0 : case XLOG_GIST_PAGE_REUSE:
416 : 0 : gistRedoPageReuse(record);
417 : 0 : break;
7390 bruce@momjian.us 418 :CBC 449 : case XLOG_GIST_PAGE_SPLIT:
4044 heikki.linnakangas@i 419 : 449 : gistRedoPageSplitRecord(record);
7490 teodor@sigaev.ru 420 : 449 : break;
2461 heikki.linnakangas@i 421 : 81 : case XLOG_GIST_PAGE_DELETE:
422 : 81 : gistRedoPageDelete(record);
423 : 81 : break;
2082 noah@leadboat.com 424 :UBC 0 : case XLOG_GIST_ASSIGN_LSN:
425 : : /* nop. See gistGetFakeLSN(). */
426 : 0 : break;
7490 teodor@sigaev.ru 427 : 0 : default:
428 [ # # ]: 0 : elog(PANIC, "gist_redo: unknown op code %u", info);
429 : : }
430 : :
7490 teodor@sigaev.ru 431 :CBC 58016 : MemoryContextSwitchTo(oldCxt);
432 : 58016 : MemoryContextReset(opCtx);
433 : 58016 : }
434 : :
435 : : void
7390 bruce@momjian.us 436 : 198 : gist_xlog_startup(void)
437 : : {
7490 teodor@sigaev.ru 438 : 198 : opCtx = createTempGistContext();
439 : 198 : }
440 : :
441 : : void
7390 bruce@momjian.us 442 : 144 : gist_xlog_cleanup(void)
443 : : {
7490 teodor@sigaev.ru 444 : 144 : MemoryContextDelete(opCtx);
7071 tgl@sss.pgh.pa.us 445 : 144 : }
446 : :
447 : : /*
448 : : * Mask a Gist page before running consistency checks on it.
449 : : */
450 : : void
3233 rhaas@postgresql.org 451 : 117278 : gist_mask(char *pagedata, BlockNumber blkno)
452 : : {
453 : 117278 : Page page = (Page) pagedata;
454 : :
3007 455 : 117278 : mask_page_lsn_and_checksum(page);
456 : :
3233 457 : 117278 : mask_page_hint_bits(page);
458 : 117278 : mask_unused_space(page);
459 : :
460 : : /*
461 : : * NSN is nothing but a special purpose LSN. Hence, mask it for the same
462 : : * reason as mask_page_lsn_and_checksum.
463 : : */
464 : 117278 : GistPageSetNSN(page, (uint64) MASK_MARKER);
465 : :
466 : : /*
467 : : * We update F_FOLLOW_RIGHT flag on the left child after writing WAL
468 : : * record. Hence, mask this flag. See gistplacetopage() for details.
469 : : */
470 : 117278 : GistMarkFollowRight(page);
471 : :
472 [ + + ]: 117278 : if (GistPageIsLeaf(page))
473 : : {
474 : : /*
475 : : * In gist leaf pages, it is possible to modify the LP_FLAGS without
476 : : * emitting any WAL record. Hence, mask the line pointer flags. See
477 : : * gistkillitems() for details.
478 : : */
479 : 74466 : mask_lp_flags(page);
480 : : }
481 : :
482 : : /*
483 : : * During gist redo, we never mark a page as garbage. Hence, mask it to
484 : : * ignore any differences.
485 : : */
486 : 117278 : GistClearPageHasGarbage(page);
487 : 117278 : }
488 : :
489 : : /*
490 : : * Write WAL record of a page split.
491 : : */
492 : : XLogRecPtr
3458 alvherre@alvh.no-ip. 493 : 1724 : gistXLogSplit(bool page_is_leaf,
494 : : SplitPageLayout *dist,
495 : : BlockNumber origrlink, GistNSN orignsn,
496 : : Buffer leftchildbuf, bool markfollowright)
497 : : {
498 : : gistxlogPageSplit xlrec;
499 : : SplitPageLayout *ptr;
4044 heikki.linnakangas@i 500 : 1724 : int npage = 0;
501 : : XLogRecPtr recptr;
502 : : int i;
503 : :
5472 504 [ + + ]: 5228 : for (ptr = dist; ptr; ptr = ptr->next)
7484 teodor@sigaev.ru 505 : 3504 : npage++;
506 : :
5472 heikki.linnakangas@i 507 : 1724 : xlrec.origrlink = origrlink;
508 : 1724 : xlrec.orignsn = orignsn;
509 : 1724 : xlrec.origleaf = page_is_leaf;
510 : 1724 : xlrec.npage = (uint16) npage;
5213 511 : 1724 : xlrec.markfollowright = markfollowright;
512 : :
4044 513 : 1724 : XLogBeginInsert();
514 : :
515 : : /*
516 : : * Include a full page image of the child buf. (only necessary if a
517 : : * checkpoint happened since the child page was split)
518 : : */
5472 519 [ + + ]: 1724 : if (BufferIsValid(leftchildbuf))
4044 520 : 6 : XLogRegisterBuffer(0, leftchildbuf, REGBUF_STANDARD);
521 : :
522 : : /*
523 : : * NOTE: We register a lot of data. The caller must've called
524 : : * XLogEnsureRecordSpace() to prepare for that. We cannot do it here,
525 : : * because we're already in a critical section. If you change the number
526 : : * of buffer or data registrations here, make sure you modify the
527 : : * XLogEnsureRecordSpace() calls accordingly!
528 : : */
308 peter@eisentraut.org 529 : 1724 : XLogRegisterData(&xlrec, sizeof(gistxlogPageSplit));
530 : :
4044 heikki.linnakangas@i 531 : 1724 : i = 1;
5472 532 [ + + ]: 5228 : for (ptr = dist; ptr; ptr = ptr->next)
533 : : {
4044 534 : 3504 : XLogRegisterBuffer(i, ptr->buffer, REGBUF_WILL_INIT);
308 peter@eisentraut.org 535 : 3504 : XLogRegisterBufData(i, &(ptr->block.num), sizeof(int));
536 : 3504 : XLogRegisterBufData(i, ptr->list, ptr->lenlist);
4044 heikki.linnakangas@i 537 : 3504 : i++;
538 : : }
539 : :
540 : 1724 : recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_SPLIT);
541 : :
5472 542 : 1724 : return recptr;
543 : : }
544 : :
545 : : /*
546 : : * Write XLOG record describing a page deletion. This also includes removal of
547 : : * downlink from the parent page.
548 : : */
549 : : XLogRecPtr
2337 550 : 243 : gistXLogPageDelete(Buffer buffer, FullTransactionId xid,
551 : : Buffer parentBuffer, OffsetNumber downlinkOffset)
552 : : {
553 : : gistxlogPageDelete xlrec;
554 : : XLogRecPtr recptr;
555 : :
2461 556 : 243 : xlrec.deleteXid = xid;
557 : 243 : xlrec.downlinkOffset = downlinkOffset;
558 : :
559 : 243 : XLogBeginInsert();
308 peter@eisentraut.org 560 : 243 : XLogRegisterData(&xlrec, SizeOfGistxlogPageDelete);
561 : :
2461 heikki.linnakangas@i 562 : 243 : XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
563 : 243 : XLogRegisterBuffer(1, parentBuffer, REGBUF_STANDARD);
564 : :
565 : 243 : recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_DELETE);
566 : :
567 : 243 : return recptr;
568 : : }
569 : :
570 : : /*
571 : : * Write an empty XLOG record to assign a distinct LSN.
572 : : */
573 : : XLogRecPtr
2082 noah@leadboat.com 574 :UBC 0 : gistXLogAssignLSN(void)
575 : : {
576 : 0 : int dummy = 0;
577 : :
578 : : /*
579 : : * Records other than XLOG_SWITCH must have content. We use an integer 0
580 : : * to follow the restriction.
581 : : */
582 : 0 : XLogBeginInsert();
583 : 0 : XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
308 peter@eisentraut.org 584 : 0 : XLogRegisterData(&dummy, sizeof(dummy));
2082 noah@leadboat.com 585 : 0 : return XLogInsert(RM_GIST_ID, XLOG_GIST_ASSIGN_LSN);
586 : : }
587 : :
588 : : /*
589 : : * Write XLOG record about reuse of a deleted page.
590 : : */
591 : : void
990 andres@anarazel.de 592 : 0 : gistXLogPageReuse(Relation rel, Relation heaprel,
593 : : BlockNumber blkno, FullTransactionId deleteXid)
594 : : {
595 : : gistxlogPageReuse xlrec_reuse;
596 : :
597 : : /*
598 : : * Note that we don't register the buffer with the record, because this
599 : : * operation doesn't modify the page. This record only exists to provide a
600 : : * conflict point for Hot Standby.
601 : : */
602 : :
603 : : /* XLOG stuff */
989 604 [ # # # # : 0 : xlrec_reuse.isCatalogRel = RelationIsAccessibleInLogicalDecoding(heaprel);
# # # # #
# # # # #
# # # # #
# ]
1259 rhaas@postgresql.org 605 : 0 : xlrec_reuse.locator = rel->rd_locator;
2461 heikki.linnakangas@i 606 : 0 : xlrec_reuse.block = blkno;
1125 pg@bowt.ie 607 : 0 : xlrec_reuse.snapshotConflictHorizon = deleteXid;
608 : :
2461 heikki.linnakangas@i 609 : 0 : XLogBeginInsert();
308 peter@eisentraut.org 610 : 0 : XLogRegisterData(&xlrec_reuse, SizeOfGistxlogPageReuse);
611 : :
2461 heikki.linnakangas@i 612 : 0 : XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_REUSE);
613 : 0 : }
614 : :
615 : : /*
616 : : * Write XLOG record describing a page update. The update can include any
617 : : * number of deletions and/or insertions of tuples on a single index page.
618 : : *
619 : : * If this update inserts a downlink for a split page, also record that
620 : : * the F_FOLLOW_RIGHT flag on the child page is cleared and NSN set.
621 : : *
622 : : * Note that both the todelete array and the tuples are marked as belonging
623 : : * to the target buffer; they need not be stored in XLOG if XLogInsert decides
624 : : * to log the whole buffer contents instead.
625 : : */
626 : : XLogRecPtr
3458 alvherre@alvh.no-ip. 627 :CBC 247775 : gistXLogUpdate(Buffer buffer,
628 : : OffsetNumber *todelete, int ntodelete,
629 : : IndexTuple *itup, int ituplen,
630 : : Buffer leftchildbuf)
631 : : {
632 : : gistxlogPageUpdate xlrec;
633 : : int i;
634 : : XLogRecPtr recptr;
635 : :
4782 tgl@sss.pgh.pa.us 636 : 247775 : xlrec.ntodelete = ntodelete;
4044 heikki.linnakangas@i 637 : 247775 : xlrec.ntoinsert = ituplen;
638 : :
639 : 247775 : XLogBeginInsert();
308 peter@eisentraut.org 640 : 247775 : XLogRegisterData(&xlrec, sizeof(gistxlogPageUpdate));
641 : :
4044 heikki.linnakangas@i 642 : 247775 : XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
308 peter@eisentraut.org 643 : 247775 : XLogRegisterBufData(0, todelete, sizeof(OffsetNumber) * ntodelete);
644 : :
645 : : /* new tuples */
7201 tgl@sss.pgh.pa.us 646 [ + + ]: 496669 : for (i = 0; i < ituplen; i++)
308 peter@eisentraut.org 647 : 248894 : XLogRegisterBufData(0, itup[i], IndexTupleSize(itup[i]));
648 : :
649 : : /*
650 : : * Include a full page image of the child buf. (only necessary if a
651 : : * checkpoint happened since the child page was split)
652 : : */
5472 heikki.linnakangas@i 653 [ + + ]: 247775 : if (BufferIsValid(leftchildbuf))
4044 654 : 1662 : XLogRegisterBuffer(1, leftchildbuf, REGBUF_STANDARD);
655 : :
656 : 247775 : recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_UPDATE);
657 : :
7484 teodor@sigaev.ru 658 : 247775 : return recptr;
659 : : }
660 : :
661 : : /*
662 : : * Write XLOG record describing a delete of leaf index tuples marked as DEAD
663 : : * during new tuple insertion. One may think that this case is already covered
664 : : * by gistXLogUpdate(). But deletion of index tuples might conflict with
665 : : * standby queries and needs special handling.
666 : : */
667 : : XLogRecPtr
2552 akorotkov@postgresql 668 :UBC 0 : gistXLogDelete(Buffer buffer, OffsetNumber *todelete, int ntodelete,
669 : : TransactionId snapshotConflictHorizon, Relation heaprel)
670 : : {
671 : : gistxlogDelete xlrec;
672 : : XLogRecPtr recptr;
673 : :
989 andres@anarazel.de 674 [ # # # # : 0 : xlrec.isCatalogRel = RelationIsAccessibleInLogicalDecoding(heaprel);
# # # # #
# # # # #
# # # # #
# ]
1125 pg@bowt.ie 675 : 0 : xlrec.snapshotConflictHorizon = snapshotConflictHorizon;
2552 akorotkov@postgresql 676 : 0 : xlrec.ntodelete = ntodelete;
677 : :
678 : 0 : XLogBeginInsert();
308 peter@eisentraut.org 679 : 0 : XLogRegisterData(&xlrec, SizeOfGistxlogDelete);
680 : :
681 : : /*
682 : : * We need the target-offsets array whether or not we store the whole
683 : : * buffer, to allow us to find the snapshotConflictHorizon on a standby
684 : : * server.
685 : : */
686 : 0 : XLogRegisterData(todelete, ntodelete * sizeof(OffsetNumber));
687 : :
2552 akorotkov@postgresql 688 : 0 : XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
689 : :
690 : 0 : recptr = XLogInsert(RM_GIST_ID, XLOG_GIST_DELETE);
691 : :
692 : 0 : return recptr;
693 : : }
|
