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