Debian Codegraph @

src/backend/replication/logical/decode.c

raw
1 /* -------------------------------------------------------------------------
2 *
3 * decode.c
4 * This module decodes WAL records read using xlogreader.h's APIs for the
5 * purpose of logical decoding by passing information to the
6 * reorderbuffer module (containing the actual changes) and to the
7 * snapbuild module to build a fitting catalog snapshot (to be able to
8 * properly decode the changes in the reorderbuffer).
9 *
10 * NOTE:
11 * This basically tries to handle all low level xlog stuff for
12 * reorderbuffer.c and snapbuild.c. There's some minor leakage where a
13 * specific record's struct is used to pass data along, but those just
14 * happen to contain the right amount of data in a convenient
15 * format. There isn't and shouldn't be much intelligence about the
16 * contents of records in here except turning them into a more usable
17 * format.
18 *
19 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
20 * Portions Copyright (c) 1994, Regents of the University of California
21 *
22 * IDENTIFICATION
23 * src/backend/replication/logical/decode.c
24 *
25 * -------------------------------------------------------------------------
26 */
27 #include "postgres.h"
28
29 #include "access/heapam_xlog.h"
30 #include "access/transam.h"
31 #include "access/xact.h"
32 #include "access/xlog_internal.h"
33 #include "access/xlogreader.h"
34 #include "access/xlogrecord.h"
35 #include "catalog/pg_control.h"
36 #include "replication/decode.h"
37 #include "replication/logical.h"
38 #include "replication/message.h"
39 #include "replication/reorderbuffer.h"
40 #include "replication/snapbuild.h"
41 #include "storage/standbydefs.h"
42
43 /* individual record(group)'s handlers */
44 static void DecodeInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf);
45 static void DecodeUpdate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf);
46 static void DecodeDelete(LogicalDecodingContext *ctx, XLogRecordBuffer *buf);
47 static void DecodeTruncate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf);
48 static void DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf);
49 static void DecodeSpecConfirm(LogicalDecodingContext *ctx, XLogRecordBuffer *buf);
50
51 static void DecodeCommit(LogicalDecodingContext *ctx, XLogRecordBuffer *buf,
52 xl_xact_parsed_commit *parsed, TransactionId xid,
53 bool two_phase);
54 static void DecodeAbort(LogicalDecodingContext *ctx, XLogRecordBuffer *buf,
55 xl_xact_parsed_abort *parsed, TransactionId xid,
56 bool two_phase);
57 static void DecodePrepare(LogicalDecodingContext *ctx, XLogRecordBuffer *buf,
58 xl_xact_parsed_prepare *parsed);
59
60
61 /* common function to decode tuples */
62 static void DecodeXLogTuple(char *data, Size len, HeapTuple tuple);
63
64 /* helper functions for decoding transactions */
65 static inline bool FilterPrepare(LogicalDecodingContext *ctx,
66 TransactionId xid, const char *gid);
67 static bool DecodeTXNNeedSkip(LogicalDecodingContext *ctx,
68 XLogRecordBuffer *buf, Oid txn_dbid,
69 RepOriginId origin_id);
70
71 /*
72 * Take every XLogReadRecord()ed record and perform the actions required to
73 * decode it using the output plugin already setup in the logical decoding
74 * context.
75 *
76 * NB: Note that every record's xid needs to be processed by reorderbuffer
77 * (xids contained in the content of records are not relevant for this rule).
78 * That means that for records which'd otherwise not go through the
79 * reorderbuffer ReorderBufferProcessXid() has to be called. We don't want to
80 * call ReorderBufferProcessXid for each record type by default, because
81 * e.g. empty xacts can be handled more efficiently if there's no previous
82 * state for them.
83 *
84 * We also support the ability to fast forward thru records, skipping some
85 * record types completely - see individual record types for details.
86 */
87 void
88 LogicalDecodingProcessRecord(LogicalDecodingContext *ctx, XLogReaderState *record)
89 {
90 XLogRecordBuffer buf;
91 TransactionId txid;
92 RmgrData rmgr;
93
94 buf.origptr = ctx->reader->ReadRecPtr;
95 buf.endptr = ctx->reader->EndRecPtr;
96 buf.record = record;
97
98 txid = XLogRecGetTopXid(record);
99
100 /*
101 * If the top-level xid is valid, we need to assign the subxact to the
102 * top-level xact. We need to do this for all records, hence we do it
103 * before the switch.
104 */
105 if (TransactionIdIsValid(txid))
106 {
107 ReorderBufferAssignChild(ctx->reorder,
108 txid,
109 XLogRecGetXid(record),
110 buf.origptr);
111 }
112
113 rmgr = GetRmgr(XLogRecGetRmid(record));
114
115 if (rmgr.rm_decode != NULL)
116 rmgr.rm_decode(ctx, &buf);
117 else
118 {
119 /* just deal with xid, and done */
120 ReorderBufferProcessXid(ctx->reorder, XLogRecGetXid(record),
121 buf.origptr);
122 }
123 }
124
125 /*
126 * Handle rmgr XLOG_ID records for LogicalDecodingProcessRecord().
127 */
128 void
129 xlog_decode(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
130 {
131 SnapBuild *builder = ctx->snapshot_builder;
132 uint8 info = XLogRecGetInfo(buf->record) & ~XLR_INFO_MASK;
133
134 ReorderBufferProcessXid(ctx->reorder, XLogRecGetXid(buf->record),
135 buf->origptr);
136
137 switch (info)
138 {
139 /* this is also used in END_OF_RECOVERY checkpoints */
140 case XLOG_CHECKPOINT_SHUTDOWN:
141 case XLOG_END_OF_RECOVERY:
142 SnapBuildSerializationPoint(builder, buf->origptr);
143
144 break;
145 case XLOG_CHECKPOINT_ONLINE:
146
147 /*
148 * a RUNNING_XACTS record will have been logged near to this, we
149 * can restart from there.
150 */
151 break;
152 case XLOG_PARAMETER_CHANGE:
153 {
154 xl_parameter_change *xlrec =
155 (xl_parameter_change *) XLogRecGetData(buf->record);
156
157 /*
158 * If wal_level on the primary is reduced to less than
159 * logical, we want to prevent existing logical slots from
160 * being used. Existing logical slots on the standby get
161 * invalidated when this WAL record is replayed; and further,
162 * slot creation fails when wal_level is not sufficient; but
163 * all these operations are not synchronized, so a logical
164 * slot may creep in while the wal_level is being reduced.
165 * Hence this extra check.
166 */
167 if (xlrec->wal_level < WAL_LEVEL_LOGICAL)
168 {
169 /*
170 * This can occur only on a standby, as a primary would
171 * not allow to restart after changing wal_level < logical
172 * if there is pre-existing logical slot.
173 */
174 Assert(RecoveryInProgress());
175 ereport(ERROR,
176 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
177 errmsg("logical decoding on standby requires \"wal_level\" >= \"logical\" on the primary")));
178 }
179 break;
180 }
181 case XLOG_NOOP:
182 case XLOG_NEXTOID:
183 case XLOG_SWITCH:
184 case XLOG_BACKUP_END:
185 case XLOG_RESTORE_POINT:
186 case XLOG_FPW_CHANGE:
187 case XLOG_FPI_FOR_HINT:
188 case XLOG_FPI:
189 case XLOG_OVERWRITE_CONTRECORD:
190 case XLOG_CHECKPOINT_REDO:
191 break;
192 default:
193 elog(ERROR, "unexpected RM_XLOG_ID record type: %u", info);
194 }
195 }
196
197 /*
198 * Handle rmgr XACT_ID records for LogicalDecodingProcessRecord().
199 */
200 void
201 xact_decode(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
202 {
203 SnapBuild *builder = ctx->snapshot_builder;
204 ReorderBuffer *reorder = ctx->reorder;
205 XLogReaderState *r = buf->record;
206 uint8 info = XLogRecGetInfo(r) & XLOG_XACT_OPMASK;
207
208 /*
209 * If the snapshot isn't yet fully built, we cannot decode anything, so
210 * bail out.
211 */
212 if (SnapBuildCurrentState(builder) < SNAPBUILD_FULL_SNAPSHOT)
213 return;
214
215 switch (info)
216 {
217 case XLOG_XACT_COMMIT:
218 case XLOG_XACT_COMMIT_PREPARED:
219 {
220 xl_xact_commit *xlrec;
221 xl_xact_parsed_commit parsed;
222 TransactionId xid;
223 bool two_phase = false;
224
225 xlrec = (xl_xact_commit *) XLogRecGetData(r);
226 ParseCommitRecord(XLogRecGetInfo(buf->record), xlrec, &parsed);
227
228 if (!TransactionIdIsValid(parsed.twophase_xid))
229 xid = XLogRecGetXid(r);
230 else
231 xid = parsed.twophase_xid;
232
233 /*
234 * We would like to process the transaction in a two-phase
235 * manner iff output plugin supports two-phase commits and
236 * doesn't filter the transaction at prepare time.
237 */
238 if (info == XLOG_XACT_COMMIT_PREPARED)
239 two_phase = !(FilterPrepare(ctx, xid,
240 parsed.twophase_gid));
241
242 DecodeCommit(ctx, buf, &parsed, xid, two_phase);
243 break;
244 }
245 case XLOG_XACT_ABORT:
246 case XLOG_XACT_ABORT_PREPARED:
247 {
248 xl_xact_abort *xlrec;
249 xl_xact_parsed_abort parsed;
250 TransactionId xid;
251 bool two_phase = false;
252
253 xlrec = (xl_xact_abort *) XLogRecGetData(r);
254 ParseAbortRecord(XLogRecGetInfo(buf->record), xlrec, &parsed);
255
256 if (!TransactionIdIsValid(parsed.twophase_xid))
257 xid = XLogRecGetXid(r);
258 else
259 xid = parsed.twophase_xid;
260
261 /*
262 * We would like to process the transaction in a two-phase
263 * manner iff output plugin supports two-phase commits and
264 * doesn't filter the transaction at prepare time.
265 */
266 if (info == XLOG_XACT_ABORT_PREPARED)
267 two_phase = !(FilterPrepare(ctx, xid,
268 parsed.twophase_gid));
269
270 DecodeAbort(ctx, buf, &parsed, xid, two_phase);
271 break;
272 }
273 case XLOG_XACT_ASSIGNMENT:
274
275 /*
276 * We assign subxact to the toplevel xact while processing each
277 * record if required. So, we don't need to do anything here. See
278 * LogicalDecodingProcessRecord.
279 */
280 break;
281 case XLOG_XACT_INVALIDATIONS:
282 {
283 TransactionId xid;
284 xl_xact_invals *invals;
285
286 xid = XLogRecGetXid(r);
287 invals = (xl_xact_invals *) XLogRecGetData(r);
288
289 /*
290 * Execute the invalidations for xid-less transactions,
291 * otherwise, accumulate them so that they can be processed at
292 * the commit time.
293 */
294 if (TransactionIdIsValid(xid))
295 {
296 if (!ctx->fast_forward)
297 ReorderBufferAddInvalidations(reorder, xid,
298 buf->origptr,
299 invals->nmsgs,
300 invals->msgs);
301 ReorderBufferXidSetCatalogChanges(ctx->reorder, xid,
302 buf->origptr);
303 }
304 else if (!ctx->fast_forward)
305 ReorderBufferImmediateInvalidation(ctx->reorder,
306 invals->nmsgs,
307 invals->msgs);
308
309 break;
310 }
311 case XLOG_XACT_PREPARE:
312 {
313 xl_xact_parsed_prepare parsed;
314 xl_xact_prepare *xlrec;
315
316 /* ok, parse it */
317 xlrec = (xl_xact_prepare *) XLogRecGetData(r);
318 ParsePrepareRecord(XLogRecGetInfo(buf->record),
319 xlrec, &parsed);
320
321 /*
322 * We would like to process the transaction in a two-phase
323 * manner iff output plugin supports two-phase commits and
324 * doesn't filter the transaction at prepare time.
325 */
326 if (FilterPrepare(ctx, parsed.twophase_xid,
327 parsed.twophase_gid))
328 {
329 ReorderBufferProcessXid(reorder, parsed.twophase_xid,
330 buf->origptr);
331 break;
332 }
333
334 /*
335 * Note that if the prepared transaction has locked [user]
336 * catalog tables exclusively then decoding prepare can block
337 * till the main transaction is committed because it needs to
338 * lock the catalog tables.
339 *
340 * XXX Now, this can even lead to a deadlock if the prepare
341 * transaction is waiting to get it logically replicated for
342 * distributed 2PC. This can be avoided by disallowing
343 * preparing transactions that have locked [user] catalog
344 * tables exclusively but as of now, we ask users not to do
345 * such an operation.
346 */
347 DecodePrepare(ctx, buf, &parsed);
348 break;
349 }
350 default:
351 elog(ERROR, "unexpected RM_XACT_ID record type: %u", info);
352 }
353 }
354
355 /*
356 * Handle rmgr STANDBY_ID records for LogicalDecodingProcessRecord().
357 */
358 void
359 standby_decode(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
360 {
361 SnapBuild *builder = ctx->snapshot_builder;
362 XLogReaderState *r = buf->record;
363 uint8 info = XLogRecGetInfo(r) & ~XLR_INFO_MASK;
364
365 ReorderBufferProcessXid(ctx->reorder, XLogRecGetXid(r), buf->origptr);
366
367 switch (info)
368 {
369 case XLOG_RUNNING_XACTS:
370 {
371 xl_running_xacts *running = (xl_running_xacts *) XLogRecGetData(r);
372
373 SnapBuildProcessRunningXacts(builder, buf->origptr, running);
374
375 /*
376 * Abort all transactions that we keep track of, that are
377 * older than the record's oldestRunningXid. This is the most
378 * convenient spot for doing so since, in contrast to shutdown
379 * or end-of-recovery checkpoints, we have information about
380 * all running transactions which includes prepared ones,
381 * while shutdown checkpoints just know that no non-prepared
382 * transactions are in progress.
383 */
384 ReorderBufferAbortOld(ctx->reorder, running->oldestRunningXid);
385 }
386 break;
387 case XLOG_STANDBY_LOCK:
388 break;
389 case XLOG_INVALIDATIONS:
390
391 /*
392 * We are processing the invalidations at the command level via
393 * XLOG_XACT_INVALIDATIONS. So we don't need to do anything here.
394 */
395 break;
396 default:
397 elog(ERROR, "unexpected RM_STANDBY_ID record type: %u", info);
398 }
399 }
400
401 /*
402 * Handle rmgr HEAP2_ID records for LogicalDecodingProcessRecord().
403 */
404 void
405 heap2_decode(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
406 {
407 uint8 info = XLogRecGetInfo(buf->record) & XLOG_HEAP_OPMASK;
408 TransactionId xid = XLogRecGetXid(buf->record);
409 SnapBuild *builder = ctx->snapshot_builder;
410
411 ReorderBufferProcessXid(ctx->reorder, xid, buf->origptr);
412
413 /*
414 * If we don't have snapshot or we are just fast-forwarding, there is no
415 * point in decoding data changes. However, it's crucial to build the base
416 * snapshot during fast-forward mode (as is done in
417 * SnapBuildProcessChange()) because we require the snapshot's xmin when
418 * determining the candidate catalog_xmin for the replication slot. See
419 * SnapBuildProcessRunningXacts().
420 */
421 if (SnapBuildCurrentState(builder) < SNAPBUILD_FULL_SNAPSHOT)
422 return;
423
424 switch (info)
425 {
426 case XLOG_HEAP2_MULTI_INSERT:
427 if (SnapBuildProcessChange(builder, xid, buf->origptr) &&
428 !ctx->fast_forward)
429 DecodeMultiInsert(ctx, buf);
430 break;
431 case XLOG_HEAP2_NEW_CID:
432 if (!ctx->fast_forward)
433 {
434 xl_heap_new_cid *xlrec;
435
436 xlrec = (xl_heap_new_cid *) XLogRecGetData(buf->record);
437 SnapBuildProcessNewCid(builder, xid, buf->origptr, xlrec);
438
439 break;
440 }
441 case XLOG_HEAP2_REWRITE:
442
443 /*
444 * Although these records only exist to serve the needs of logical
445 * decoding, all the work happens as part of crash or archive
446 * recovery, so we don't need to do anything here.
447 */
448 break;
449
450 /*
451 * Everything else here is just low level physical stuff we're not
452 * interested in.
453 */
454 case XLOG_HEAP2_PRUNE_ON_ACCESS:
455 case XLOG_HEAP2_PRUNE_VACUUM_SCAN:
456 case XLOG_HEAP2_PRUNE_VACUUM_CLEANUP:
457 case XLOG_HEAP2_VISIBLE:
458 case XLOG_HEAP2_LOCK_UPDATED:
459 break;
460 default:
461 elog(ERROR, "unexpected RM_HEAP2_ID record type: %u", info);
462 }
463 }
464
465 /*
466 * Handle rmgr HEAP_ID records for LogicalDecodingProcessRecord().
467 */
468 void
469 heap_decode(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
470 {
471 uint8 info = XLogRecGetInfo(buf->record) & XLOG_HEAP_OPMASK;
472 TransactionId xid = XLogRecGetXid(buf->record);
473 SnapBuild *builder = ctx->snapshot_builder;
474
475 ReorderBufferProcessXid(ctx->reorder, xid, buf->origptr);
476
477 /*
478 * If we don't have snapshot or we are just fast-forwarding, there is no
479 * point in decoding data changes. However, it's crucial to build the base
480 * snapshot during fast-forward mode (as is done in
481 * SnapBuildProcessChange()) because we require the snapshot's xmin when
482 * determining the candidate catalog_xmin for the replication slot. See
483 * SnapBuildProcessRunningXacts().
484 */
485 if (SnapBuildCurrentState(builder) < SNAPBUILD_FULL_SNAPSHOT)
486 return;
487
488 switch (info)
489 {
490 case XLOG_HEAP_INSERT:
491 if (SnapBuildProcessChange(builder, xid, buf->origptr) &&
492 !ctx->fast_forward)
493 DecodeInsert(ctx, buf);
494 break;
495
496 /*
497 * Treat HOT update as normal updates. There is no useful
498 * information in the fact that we could make it a HOT update
499 * locally and the WAL layout is compatible.
500 */
501 case XLOG_HEAP_HOT_UPDATE:
502 case XLOG_HEAP_UPDATE:
503 if (SnapBuildProcessChange(builder, xid, buf->origptr) &&
504 !ctx->fast_forward)
505 DecodeUpdate(ctx, buf);
506 break;
507
508 case XLOG_HEAP_DELETE:
509 if (SnapBuildProcessChange(builder, xid, buf->origptr) &&
510 !ctx->fast_forward)
511 DecodeDelete(ctx, buf);
512 break;
513
514 case XLOG_HEAP_TRUNCATE:
515 if (SnapBuildProcessChange(builder, xid, buf->origptr) &&
516 !ctx->fast_forward)
517 DecodeTruncate(ctx, buf);
518 break;
519
520 case XLOG_HEAP_INPLACE:
521
522 /*
523 * Inplace updates are only ever performed on catalog tuples and
524 * can, per definition, not change tuple visibility. Since we
525 * also don't decode catalog tuples, we're not interested in the
526 * record's contents.
527 */
528 break;
529
530 case XLOG_HEAP_CONFIRM:
531 if (SnapBuildProcessChange(builder, xid, buf->origptr) &&
532 !ctx->fast_forward)
533 DecodeSpecConfirm(ctx, buf);
534 break;
535
536 case XLOG_HEAP_LOCK:
537 /* we don't care about row level locks for now */
538 break;
539
540 default:
541 elog(ERROR, "unexpected RM_HEAP_ID record type: %u", info);
542 break;
543 }
544 }
545
546 /*
547 * Ask output plugin whether we want to skip this PREPARE and send
548 * this transaction as a regular commit later.
549 */
550 static inline bool
551 FilterPrepare(LogicalDecodingContext *ctx, TransactionId xid,
552 const char *gid)
553 {
554 /*
555 * Skip if decoding of two-phase transactions at PREPARE time is not
556 * enabled. In that case, all two-phase transactions are considered
557 * filtered out and will be applied as regular transactions at COMMIT
558 * PREPARED.
559 */
560 if (!ctx->twophase)
561 return true;
562
563 /*
564 * The filter_prepare callback is optional. When not supplied, all
565 * prepared transactions should go through.
566 */
567 if (ctx->callbacks.filter_prepare_cb == NULL)
568 return false;
569
570 return filter_prepare_cb_wrapper(ctx, xid, gid);
571 }
572
573 static inline bool
574 FilterByOrigin(LogicalDecodingContext *ctx, RepOriginId origin_id)
575 {
576 if (ctx->callbacks.filter_by_origin_cb == NULL)
577 return false;
578
579 return filter_by_origin_cb_wrapper(ctx, origin_id);
580 }
581
582 /*
583 * Handle rmgr LOGICALMSG_ID records for LogicalDecodingProcessRecord().
584 */
585 void
586 logicalmsg_decode(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
587 {
588 SnapBuild *builder = ctx->snapshot_builder;
589 XLogReaderState *r = buf->record;
590 TransactionId xid = XLogRecGetXid(r);
591 uint8 info = XLogRecGetInfo(r) & ~XLR_INFO_MASK;
592 RepOriginId origin_id = XLogRecGetOrigin(r);
593 Snapshot snapshot = NULL;
594 xl_logical_message *message;
595
596 if (info != XLOG_LOGICAL_MESSAGE)
597 elog(ERROR, "unexpected RM_LOGICALMSG_ID record type: %u", info);
598
599 ReorderBufferProcessXid(ctx->reorder, XLogRecGetXid(r), buf->origptr);
600
601 /* If we don't have snapshot, there is no point in decoding messages */
602 if (SnapBuildCurrentState(builder) < SNAPBUILD_FULL_SNAPSHOT)
603 return;
604
605 message = (xl_logical_message *) XLogRecGetData(r);
606
607 if (message->dbId != ctx->slot->data.database ||
608 FilterByOrigin(ctx, origin_id))
609 return;
610
611 if (message->transactional &&
612 !SnapBuildProcessChange(builder, xid, buf->origptr))
613 return;
614 else if (!message->transactional &&
615 (SnapBuildCurrentState(builder) != SNAPBUILD_CONSISTENT ||
616 SnapBuildXactNeedsSkip(builder, buf->origptr)))
617 return;
618
619 /*
620 * We also skip decoding in fast_forward mode. This check must be last
621 * because we don't want to set the processing_required flag unless we
622 * have a decodable message.
623 */
624 if (ctx->fast_forward)
625 {
626 /*
627 * We need to set processing_required flag to notify the message's
628 * existence to the caller. Usually, the flag is set when either the
629 * COMMIT or ABORT records are decoded, but this must be turned on
630 * here because the non-transactional logical message is decoded
631 * without waiting for these records.
632 */
633 if (!message->transactional)
634 ctx->processing_required = true;
635
636 return;
637 }
638
639 /*
640 * If this is a non-transactional change, get the snapshot we're expected
641 * to use. We only get here when the snapshot is consistent, and the
642 * change is not meant to be skipped.
643 *
644 * For transactional changes we don't need a snapshot, we'll use the
645 * regular snapshot maintained by ReorderBuffer. We just leave it NULL.
646 */
647 if (!message->transactional)
648 snapshot = SnapBuildGetOrBuildSnapshot(builder);
649
650 ReorderBufferQueueMessage(ctx->reorder, xid, snapshot, buf->endptr,
651 message->transactional,
652 message->message, /* first part of message is
653 * prefix */
654 message->message_size,
655 message->message + message->prefix_size);
656 }
657
658 /*
659 * Consolidated commit record handling between the different form of commit
660 * records.
661 *
662 * 'two_phase' indicates that caller wants to process the transaction in two
663 * phases, first process prepare if not already done and then process
664 * commit_prepared.
665 */
666 static void
667 DecodeCommit(LogicalDecodingContext *ctx, XLogRecordBuffer *buf,
668 xl_xact_parsed_commit *parsed, TransactionId xid,
669 bool two_phase)
670 {
671 XLogRecPtr origin_lsn = InvalidXLogRecPtr;
672 TimestampTz commit_time = parsed->xact_time;
673 RepOriginId origin_id = XLogRecGetOrigin(buf->record);
674 int i;
675
676 if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
677 {
678 origin_lsn = parsed->origin_lsn;
679 commit_time = parsed->origin_timestamp;
680 }
681
682 SnapBuildCommitTxn(ctx->snapshot_builder, buf->origptr, xid,
683 parsed->nsubxacts, parsed->subxacts,
684 parsed->xinfo);
685
686 /* ----
687 * Check whether we are interested in this specific transaction, and tell
688 * the reorderbuffer to forget the content of the (sub-)transactions
689 * if not.
690 *
691 * We can't just use ReorderBufferAbort() here, because we need to execute
692 * the transaction's invalidations. This currently won't be needed if
693 * we're just skipping over the transaction because currently we only do
694 * so during startup, to get to the first transaction the client needs. As
695 * we have reset the catalog caches before starting to read WAL, and we
696 * haven't yet touched any catalogs, there can't be anything to invalidate.
697 * But if we're "forgetting" this commit because it happened in another
698 * database, the invalidations might be important, because they could be
699 * for shared catalogs and we might have loaded data into the relevant
700 * syscaches.
701 * ---
702 */
703 if (DecodeTXNNeedSkip(ctx, buf, parsed->dbId, origin_id))
704 {
705 for (i = 0; i < parsed->nsubxacts; i++)
706 {
707 ReorderBufferForget(ctx->reorder, parsed->subxacts[i], buf->origptr);
708 }
709 ReorderBufferForget(ctx->reorder, xid, buf->origptr);
710
711 return;
712 }
713
714 /* tell the reorderbuffer about the surviving subtransactions */
715 for (i = 0; i < parsed->nsubxacts; i++)
716 {
717 ReorderBufferCommitChild(ctx->reorder, xid, parsed->subxacts[i],
718 buf->origptr, buf->endptr);
719 }
720
721 /*
722 * Send the final commit record if the transaction data is already
723 * decoded, otherwise, process the entire transaction.
724 */
725 if (two_phase)
726 {
727 ReorderBufferFinishPrepared(ctx->reorder, xid, buf->origptr, buf->endptr,
728 SnapBuildGetTwoPhaseAt(ctx->snapshot_builder),
729 commit_time, origin_id, origin_lsn,
730 parsed->twophase_gid, true);
731 }
732 else
733 {
734 ReorderBufferCommit(ctx->reorder, xid, buf->origptr, buf->endptr,
735 commit_time, origin_id, origin_lsn);
736 }
737
738 /*
739 * Update the decoding stats at transaction prepare/commit/abort.
740 * Additionally we send the stats when we spill or stream the changes to
741 * avoid losing them in case the decoding is interrupted. It is not clear
742 * that sending more or less frequently than this would be better.
743 */
744 UpdateDecodingStats(ctx);
745 }
746
747 /*
748 * Decode PREPARE record. Similar logic as in DecodeCommit.
749 *
750 * Note that we don't skip prepare even if have detected concurrent abort
751 * because it is quite possible that we had already sent some changes before we
752 * detect abort in which case we need to abort those changes in the subscriber.
753 * To abort such changes, we do send the prepare and then the rollback prepared
754 * which is what happened on the publisher-side as well. Now, we can invent a
755 * new abort API wherein in such cases we send abort and skip sending prepared
756 * and rollback prepared but then it is not that straightforward because we
757 * might have streamed this transaction by that time in which case it is
758 * handled when the rollback is encountered. It is not impossible to optimize
759 * the concurrent abort case but it can introduce design complexity w.r.t
760 * handling different cases so leaving it for now as it doesn't seem worth it.
761 */
762 static void
763 DecodePrepare(LogicalDecodingContext *ctx, XLogRecordBuffer *buf,
764 xl_xact_parsed_prepare *parsed)
765 {
766 SnapBuild *builder = ctx->snapshot_builder;
767 XLogRecPtr origin_lsn = parsed->origin_lsn;
768 TimestampTz prepare_time = parsed->xact_time;
769 RepOriginId origin_id = XLogRecGetOrigin(buf->record);
770 int i;
771 TransactionId xid = parsed->twophase_xid;
772
773 if (parsed->origin_timestamp != 0)
774 prepare_time = parsed->origin_timestamp;
775
776 /*
777 * Remember the prepare info for a txn so that it can be used later in
778 * commit prepared if required. See ReorderBufferFinishPrepared.
779 */
780 if (!ReorderBufferRememberPrepareInfo(ctx->reorder, xid, buf->origptr,
781 buf->endptr, prepare_time, origin_id,
782 origin_lsn))
783 return;
784
785 /* We can't start streaming unless a consistent state is reached. */
786 if (SnapBuildCurrentState(builder) < SNAPBUILD_CONSISTENT)
787 {
788 ReorderBufferSkipPrepare(ctx->reorder, xid);
789 return;
790 }
791
792 /*
793 * Check whether we need to process this transaction. See
794 * DecodeTXNNeedSkip for the reasons why we sometimes want to skip the
795 * transaction.
796 *
797 * We can't call ReorderBufferForget as we did in DecodeCommit as the txn
798 * hasn't yet been committed, removing this txn before a commit might
799 * result in the computation of an incorrect restart_lsn. See
800 * SnapBuildProcessRunningXacts. But we need to process cache
801 * invalidations if there are any for the reasons mentioned in
802 * DecodeCommit.
803 */
804 if (DecodeTXNNeedSkip(ctx, buf, parsed->dbId, origin_id))
805 {
806 ReorderBufferSkipPrepare(ctx->reorder, xid);
807 ReorderBufferInvalidate(ctx->reorder, xid, buf->origptr);
808 return;
809 }
810
811 /* Tell the reorderbuffer about the surviving subtransactions. */
812 for (i = 0; i < parsed->nsubxacts; i++)
813 {
814 ReorderBufferCommitChild(ctx->reorder, xid, parsed->subxacts[i],
815 buf->origptr, buf->endptr);
816 }
817
818 /* replay actions of all transaction + subtransactions in order */
819 ReorderBufferPrepare(ctx->reorder, xid, parsed->twophase_gid);
820
821 /*
822 * Update the decoding stats at transaction prepare/commit/abort.
823 * Additionally we send the stats when we spill or stream the changes to
824 * avoid losing them in case the decoding is interrupted. It is not clear
825 * that sending more or less frequently than this would be better.
826 */
827 UpdateDecodingStats(ctx);
828 }
829
830
831 /*
832 * Get the data from the various forms of abort records and pass it on to
833 * snapbuild.c and reorderbuffer.c.
834 *
835 * 'two_phase' indicates to finish prepared transaction.
836 */
837 static void
838 DecodeAbort(LogicalDecodingContext *ctx, XLogRecordBuffer *buf,
839 xl_xact_parsed_abort *parsed, TransactionId xid,
840 bool two_phase)
841 {
842 int i;
843 XLogRecPtr origin_lsn = InvalidXLogRecPtr;
844 TimestampTz abort_time = parsed->xact_time;
845 RepOriginId origin_id = XLogRecGetOrigin(buf->record);
846 bool skip_xact;
847
848 if (parsed->xinfo & XACT_XINFO_HAS_ORIGIN)
849 {
850 origin_lsn = parsed->origin_lsn;
851 abort_time = parsed->origin_timestamp;
852 }
853
854 /*
855 * Check whether we need to process this transaction. See
856 * DecodeTXNNeedSkip for the reasons why we sometimes want to skip the
857 * transaction.
858 */
859 skip_xact = DecodeTXNNeedSkip(ctx, buf, parsed->dbId, origin_id);
860
861 /*
862 * Send the final rollback record for a prepared transaction unless we
863 * need to skip it. For non-two-phase xacts, simply forget the xact.
864 */
865 if (two_phase && !skip_xact)
866 {
867 ReorderBufferFinishPrepared(ctx->reorder, xid, buf->origptr, buf->endptr,
868 InvalidXLogRecPtr,
869 abort_time, origin_id, origin_lsn,
870 parsed->twophase_gid, false);
871 }
872 else
873 {
874 for (i = 0; i < parsed->nsubxacts; i++)
875 {
876 ReorderBufferAbort(ctx->reorder, parsed->subxacts[i],
877 buf->record->EndRecPtr, abort_time);
878 }
879
880 ReorderBufferAbort(ctx->reorder, xid, buf->record->EndRecPtr,
881 abort_time);
882 }
883
884 /* update the decoding stats */
885 UpdateDecodingStats(ctx);
886 }
887
888 /*
889 * Parse XLOG_HEAP_INSERT (not MULTI_INSERT!) records into tuplebufs.
890 *
891 * Inserts can contain the new tuple.
892 */
893 static void
894 DecodeInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
895 {
896 Size datalen;
897 char *tupledata;
898 Size tuplelen;
899 XLogReaderState *r = buf->record;
900 xl_heap_insert *xlrec;
901 ReorderBufferChange *change;
902 RelFileLocator target_locator;
903
904 xlrec = (xl_heap_insert *) XLogRecGetData(r);
905
906 /*
907 * Ignore insert records without new tuples (this does happen when
908 * raw_heap_insert marks the TOAST record as HEAP_INSERT_NO_LOGICAL).
909 */
910 if (!(xlrec->flags & XLH_INSERT_CONTAINS_NEW_TUPLE))
911 return;
912
913 /* only interested in our database */
914 XLogRecGetBlockTag(r, 0, &target_locator, NULL, NULL);
915 if (target_locator.dbOid != ctx->slot->data.database)
916 return;
917
918 /* output plugin doesn't look for this origin, no need to queue */
919 if (FilterByOrigin(ctx, XLogRecGetOrigin(r)))
920 return;
921
922 change = ReorderBufferAllocChange(ctx->reorder);
923 if (!(xlrec->flags & XLH_INSERT_IS_SPECULATIVE))
924 change->action = REORDER_BUFFER_CHANGE_INSERT;
925 else
926 change->action = REORDER_BUFFER_CHANGE_INTERNAL_SPEC_INSERT;
927 change->origin_id = XLogRecGetOrigin(r);
928
929 memcpy(&change->data.tp.rlocator, &target_locator, sizeof(RelFileLocator));
930
931 tupledata = XLogRecGetBlockData(r, 0, &datalen);
932 tuplelen = datalen - SizeOfHeapHeader;
933
934 change->data.tp.newtuple =
935 ReorderBufferAllocTupleBuf(ctx->reorder, tuplelen);
936
937 DecodeXLogTuple(tupledata, datalen, change->data.tp.newtuple);
938
939 change->data.tp.clear_toast_afterwards = true;
940
941 ReorderBufferQueueChange(ctx->reorder, XLogRecGetXid(r), buf->origptr,
942 change,
943 xlrec->flags & XLH_INSERT_ON_TOAST_RELATION);
944 }
945
946 /*
947 * Parse XLOG_HEAP_UPDATE and XLOG_HEAP_HOT_UPDATE, which have the same layout
948 * in the record, from wal into proper tuplebufs.
949 *
950 * Updates can possibly contain a new tuple and the old primary key.
951 */
952 static void
953 DecodeUpdate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
954 {
955 XLogReaderState *r = buf->record;
956 xl_heap_update *xlrec;
957 ReorderBufferChange *change;
958 char *data;
959 RelFileLocator target_locator;
960
961 xlrec = (xl_heap_update *) XLogRecGetData(r);
962
963 /* only interested in our database */
964 XLogRecGetBlockTag(r, 0, &target_locator, NULL, NULL);
965 if (target_locator.dbOid != ctx->slot->data.database)
966 return;
967
968 /* output plugin doesn't look for this origin, no need to queue */
969 if (FilterByOrigin(ctx, XLogRecGetOrigin(r)))
970 return;
971
972 change = ReorderBufferAllocChange(ctx->reorder);
973 change->action = REORDER_BUFFER_CHANGE_UPDATE;
974 change->origin_id = XLogRecGetOrigin(r);
975 memcpy(&change->data.tp.rlocator, &target_locator, sizeof(RelFileLocator));
976
977 if (xlrec->flags & XLH_UPDATE_CONTAINS_NEW_TUPLE)
978 {
979 Size datalen;
980 Size tuplelen;
981
982 data = XLogRecGetBlockData(r, 0, &datalen);
983
984 tuplelen = datalen - SizeOfHeapHeader;
985
986 change->data.tp.newtuple =
987 ReorderBufferAllocTupleBuf(ctx->reorder, tuplelen);
988
989 DecodeXLogTuple(data, datalen, change->data.tp.newtuple);
990 }
991
992 if (xlrec->flags & XLH_UPDATE_CONTAINS_OLD)
993 {
994 Size datalen;
995 Size tuplelen;
996
997 /* caution, remaining data in record is not aligned */
998 data = XLogRecGetData(r) + SizeOfHeapUpdate;
999 datalen = XLogRecGetDataLen(r) - SizeOfHeapUpdate;
1000 tuplelen = datalen - SizeOfHeapHeader;
1001
1002 change->data.tp.oldtuple =
1003 ReorderBufferAllocTupleBuf(ctx->reorder, tuplelen);
1004
1005 DecodeXLogTuple(data, datalen, change->data.tp.oldtuple);
1006 }
1007
1008 change->data.tp.clear_toast_afterwards = true;
1009
1010 ReorderBufferQueueChange(ctx->reorder, XLogRecGetXid(r), buf->origptr,
1011 change, false);
1012 }
1013
1014 /*
1015 * Parse XLOG_HEAP_DELETE from wal into proper tuplebufs.
1016 *
1017 * Deletes can possibly contain the old primary key.
1018 */
1019 static void
1020 DecodeDelete(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
1021 {
1022 XLogReaderState *r = buf->record;
1023 xl_heap_delete *xlrec;
1024 ReorderBufferChange *change;
1025 RelFileLocator target_locator;
1026
1027 xlrec = (xl_heap_delete *) XLogRecGetData(r);
1028
1029 /* only interested in our database */
1030 XLogRecGetBlockTag(r, 0, &target_locator, NULL, NULL);
1031 if (target_locator.dbOid != ctx->slot->data.database)
1032 return;
1033
1034 /* output plugin doesn't look for this origin, no need to queue */
1035 if (FilterByOrigin(ctx, XLogRecGetOrigin(r)))
1036 return;
1037
1038 change = ReorderBufferAllocChange(ctx->reorder);
1039
1040 if (xlrec->flags & XLH_DELETE_IS_SUPER)
1041 change->action = REORDER_BUFFER_CHANGE_INTERNAL_SPEC_ABORT;
1042 else
1043 change->action = REORDER_BUFFER_CHANGE_DELETE;
1044
1045 change->origin_id = XLogRecGetOrigin(r);
1046
1047 memcpy(&change->data.tp.rlocator, &target_locator, sizeof(RelFileLocator));
1048
1049 /* old primary key stored */
1050 if (xlrec->flags & XLH_DELETE_CONTAINS_OLD)
1051 {
1052 Size datalen = XLogRecGetDataLen(r) - SizeOfHeapDelete;
1053 Size tuplelen = datalen - SizeOfHeapHeader;
1054
1055 Assert(XLogRecGetDataLen(r) > (SizeOfHeapDelete + SizeOfHeapHeader));
1056
1057 change->data.tp.oldtuple =
1058 ReorderBufferAllocTupleBuf(ctx->reorder, tuplelen);
1059
1060 DecodeXLogTuple((char *) xlrec + SizeOfHeapDelete,
1061 datalen, change->data.tp.oldtuple);
1062 }
1063
1064 change->data.tp.clear_toast_afterwards = true;
1065
1066 ReorderBufferQueueChange(ctx->reorder, XLogRecGetXid(r), buf->origptr,
1067 change, false);
1068 }
1069
1070 /*
1071 * Parse XLOG_HEAP_TRUNCATE from wal
1072 */
1073 static void
1074 DecodeTruncate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
1075 {
1076 XLogReaderState *r = buf->record;
1077 xl_heap_truncate *xlrec;
1078 ReorderBufferChange *change;
1079
1080 xlrec = (xl_heap_truncate *) XLogRecGetData(r);
1081
1082 /* only interested in our database */
1083 if (xlrec->dbId != ctx->slot->data.database)
1084 return;
1085
1086 /* output plugin doesn't look for this origin, no need to queue */
1087 if (FilterByOrigin(ctx, XLogRecGetOrigin(r)))
1088 return;
1089
1090 change = ReorderBufferAllocChange(ctx->reorder);
1091 change->action = REORDER_BUFFER_CHANGE_TRUNCATE;
1092 change->origin_id = XLogRecGetOrigin(r);
1093 if (xlrec->flags & XLH_TRUNCATE_CASCADE)
1094 change->data.truncate.cascade = true;
1095 if (xlrec->flags & XLH_TRUNCATE_RESTART_SEQS)
1096 change->data.truncate.restart_seqs = true;
1097 change->data.truncate.nrelids = xlrec->nrelids;
1098 change->data.truncate.relids = ReorderBufferAllocRelids(ctx->reorder,
1099 xlrec->nrelids);
1100 memcpy(change->data.truncate.relids, xlrec->relids,
1101 xlrec->nrelids * sizeof(Oid));
1102 ReorderBufferQueueChange(ctx->reorder, XLogRecGetXid(r),
1103 buf->origptr, change, false);
1104 }
1105
1106 /*
1107 * Decode XLOG_HEAP2_MULTI_INSERT record into multiple tuplebufs.
1108 *
1109 * Currently MULTI_INSERT will always contain the full tuples.
1110 */
1111 static void
1112 DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
1113 {
1114 XLogReaderState *r = buf->record;
1115 xl_heap_multi_insert *xlrec;
1116 int i;
1117 char *data;
1118 char *tupledata;
1119 Size tuplelen;
1120 RelFileLocator rlocator;
1121
1122 xlrec = (xl_heap_multi_insert *) XLogRecGetData(r);
1123
1124 /*
1125 * Ignore insert records without new tuples. This happens when a
1126 * multi_insert is done on a catalog or on a non-persistent relation.
1127 */
1128 if (!(xlrec->flags & XLH_INSERT_CONTAINS_NEW_TUPLE))
1129 return;
1130
1131 /* only interested in our database */
1132 XLogRecGetBlockTag(r, 0, &rlocator, NULL, NULL);
1133 if (rlocator.dbOid != ctx->slot->data.database)
1134 return;
1135
1136 /* output plugin doesn't look for this origin, no need to queue */
1137 if (FilterByOrigin(ctx, XLogRecGetOrigin(r)))
1138 return;
1139
1140 /*
1141 * We know that this multi_insert isn't for a catalog, so the block should
1142 * always have data even if a full-page write of it is taken.
1143 */
1144 tupledata = XLogRecGetBlockData(r, 0, &tuplelen);
1145 Assert(tupledata != NULL);
1146
1147 data = tupledata;
1148 for (i = 0; i < xlrec->ntuples; i++)
1149 {
1150 ReorderBufferChange *change;
1151 xl_multi_insert_tuple *xlhdr;
1152 int datalen;
1153 HeapTuple tuple;
1154 HeapTupleHeader header;
1155
1156 change = ReorderBufferAllocChange(ctx->reorder);
1157 change->action = REORDER_BUFFER_CHANGE_INSERT;
1158 change->origin_id = XLogRecGetOrigin(r);
1159
1160 memcpy(&change->data.tp.rlocator, &rlocator, sizeof(RelFileLocator));
1161
1162 xlhdr = (xl_multi_insert_tuple *) SHORTALIGN(data);
1163 data = ((char *) xlhdr) + SizeOfMultiInsertTuple;
1164 datalen = xlhdr->datalen;
1165
1166 change->data.tp.newtuple =
1167 ReorderBufferAllocTupleBuf(ctx->reorder, datalen);
1168
1169 tuple = change->data.tp.newtuple;
1170 header = tuple->t_data;
1171
1172 /* not a disk based tuple */
1173 ItemPointerSetInvalid(&tuple->t_self);
1174
1175 /*
1176 * We can only figure this out after reassembling the transactions.
1177 */
1178 tuple->t_tableOid = InvalidOid;
1179
1180 tuple->t_len = datalen + SizeofHeapTupleHeader;
1181
1182 memset(header, 0, SizeofHeapTupleHeader);
1183
1184 memcpy((char *) tuple->t_data + SizeofHeapTupleHeader, data, datalen);
1185 header->t_infomask = xlhdr->t_infomask;
1186 header->t_infomask2 = xlhdr->t_infomask2;
1187 header->t_hoff = xlhdr->t_hoff;
1188
1189 /*
1190 * Reset toast reassembly state only after the last row in the last
1191 * xl_multi_insert_tuple record emitted by one heap_multi_insert()
1192 * call.
1193 */
1194 if (xlrec->flags & XLH_INSERT_LAST_IN_MULTI &&
1195 (i + 1) == xlrec->ntuples)
1196 change->data.tp.clear_toast_afterwards = true;
1197 else
1198 change->data.tp.clear_toast_afterwards = false;
1199
1200 ReorderBufferQueueChange(ctx->reorder, XLogRecGetXid(r),
1201 buf->origptr, change, false);
1202
1203 /* move to the next xl_multi_insert_tuple entry */
1204 data += datalen;
1205 }
1206 Assert(data == tupledata + tuplelen);
1207 }
1208
1209 /*
1210 * Parse XLOG_HEAP_CONFIRM from wal into a confirmation change.
1211 *
1212 * This is pretty trivial, all the state essentially already setup by the
1213 * speculative insertion.
1214 */
1215 static void
1216 DecodeSpecConfirm(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
1217 {
1218 XLogReaderState *r = buf->record;
1219 ReorderBufferChange *change;
1220 RelFileLocator target_locator;
1221
1222 /* only interested in our database */
1223 XLogRecGetBlockTag(r, 0, &target_locator, NULL, NULL);
1224 if (target_locator.dbOid != ctx->slot->data.database)
1225 return;
1226
1227 /* output plugin doesn't look for this origin, no need to queue */
1228 if (FilterByOrigin(ctx, XLogRecGetOrigin(r)))
1229 return;
1230
1231 change = ReorderBufferAllocChange(ctx->reorder);
1232 change->action = REORDER_BUFFER_CHANGE_INTERNAL_SPEC_CONFIRM;
1233 change->origin_id = XLogRecGetOrigin(r);
1234
1235 memcpy(&change->data.tp.rlocator, &target_locator, sizeof(RelFileLocator));
1236
1237 change->data.tp.clear_toast_afterwards = true;
1238
1239 ReorderBufferQueueChange(ctx->reorder, XLogRecGetXid(r), buf->origptr,
1240 change, false);
1241 }
1242
1243
1244 /*
1245 * Read a HeapTuple as WAL logged by heap_insert, heap_update and heap_delete
1246 * (but not by heap_multi_insert) into a tuplebuf.
1247 *
1248 * The size 'len' and the pointer 'data' in the record need to be
1249 * computed outside as they are record specific.
1250 */
1251 static void
1252 DecodeXLogTuple(char *data, Size len, HeapTuple tuple)
1253 {
1254 xl_heap_header xlhdr;
1255 int datalen = len - SizeOfHeapHeader;
1256 HeapTupleHeader header;
1257
1258 Assert(datalen >= 0);
1259
1260 tuple->t_len = datalen + SizeofHeapTupleHeader;
1261 header = tuple->t_data;
1262
1263 /* not a disk based tuple */
1264 ItemPointerSetInvalid(&tuple->t_self);
1265
1266 /* we can only figure this out after reassembling the transactions */
1267 tuple->t_tableOid = InvalidOid;
1268
1269 /* data is not stored aligned, copy to aligned storage */
1270 memcpy(&xlhdr, data, SizeOfHeapHeader);
1271
1272 memset(header, 0, SizeofHeapTupleHeader);
1273
1274 memcpy(((char *) tuple->t_data) + SizeofHeapTupleHeader,
1275 data + SizeOfHeapHeader,
1276 datalen);
1277
1278 header->t_infomask = xlhdr.t_infomask;
1279 header->t_infomask2 = xlhdr.t_infomask2;
1280 header->t_hoff = xlhdr.t_hoff;
1281 }
1282
1283 /*
1284 * Check whether we are interested in this specific transaction.
1285 *
1286 * There can be several reasons we might not be interested in this
1287 * transaction:
1288 * 1) We might not be interested in decoding transactions up to this
1289 * LSN. This can happen because we previously decoded it and now just
1290 * are restarting or if we haven't assembled a consistent snapshot yet.
1291 * 2) The transaction happened in another database.
1292 * 3) The output plugin is not interested in the origin.
1293 * 4) We are doing fast-forwarding
1294 */
1295 static bool
1296 DecodeTXNNeedSkip(LogicalDecodingContext *ctx, XLogRecordBuffer *buf,
1297 Oid txn_dbid, RepOriginId origin_id)
1298 {
1299 if (SnapBuildXactNeedsSkip(ctx->snapshot_builder, buf->origptr) ||
1300 (txn_dbid != InvalidOid && txn_dbid != ctx->slot->data.database) ||
1301 FilterByOrigin(ctx, origin_id))
1302 return true;
1303
1304 /*
1305 * We also skip decoding in fast_forward mode. In passing set the
1306 * processing_required flag to indicate that if it were not for
1307 * fast_forward mode, processing would have been required.
1308 */
1309 if (ctx->fast_forward)
1310 {
1311 ctx->processing_required = true;
1312 return true;
1313 }
1314
1315 return false;
1316 }