database/postgres
database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-04-20 00:42:27 +03:00
Code

Rename alloc/free functions in reorderbuffer.c

Browse Source 
There used to be bespoken pools for these structs to reduce the
palloc/pfree overhead, but that was ripped out a long time ago and
replaced with the generic, cheaper generational memory allocator
(commit a4ccc1cef5). The Get/Return terminology made sense with the
pools, as you "got" an object from the pool and "returned" it later,
but now it just looks weird. Rename to Alloc/Free.

Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us>
Discussion: https://www.postgresql.org/message-id/c9e43d2d-8e83-444f-b111-430377368989@iki.fi
This commit is contained in:
Heikki Linnakangas 2025-03-12 22:03:39 +02:00
parent 025e7e1eb4
commit ac4494646d
3 changed files with 64 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/backend/replication/logical/decode.c
View File

@ -915,7 +915,7 @@ DecodeInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
if (FilterByOrigin(ctx, XLogRecGetOrigin(r))) if (FilterByOrigin(ctx, XLogRecGetOrigin(r)))
return; return;
change = ReorderBufferGetChange(ctx->reorder); change = ReorderBufferAllocChange(ctx->reorder);
if (!(xlrec->flags & XLH_INSERT_IS_SPECULATIVE)) if (!(xlrec->flags & XLH_INSERT_IS_SPECULATIVE))
change->action = REORDER_BUFFER_CHANGE_INSERT; change->action = REORDER_BUFFER_CHANGE_INSERT;
else else
@ -928,7 +928,7 @@ DecodeInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
tuplelen = datalen - SizeOfHeapHeader; tuplelen = datalen - SizeOfHeapHeader;
change->data.tp.newtuple = change->data.tp.newtuple =
ReorderBufferGetTupleBuf(ctx->reorder, tuplelen); ReorderBufferAllocTupleBuf(ctx->reorder, tuplelen);
DecodeXLogTuple(tupledata, datalen, change->data.tp.newtuple); DecodeXLogTuple(tupledata, datalen, change->data.tp.newtuple);
@ -965,7 +965,7 @@ DecodeUpdate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
if (FilterByOrigin(ctx, XLogRecGetOrigin(r))) if (FilterByOrigin(ctx, XLogRecGetOrigin(r)))
return; return;
change = ReorderBufferGetChange(ctx->reorder); change = ReorderBufferAllocChange(ctx->reorder);
change->action = REORDER_BUFFER_CHANGE_UPDATE; change->action = REORDER_BUFFER_CHANGE_UPDATE;
change->origin_id = XLogRecGetOrigin(r); change->origin_id = XLogRecGetOrigin(r);
memcpy(&change->data.tp.rlocator, &target_locator, sizeof(RelFileLocator)); memcpy(&change->data.tp.rlocator, &target_locator, sizeof(RelFileLocator));
@ -980,7 +980,7 @@ DecodeUpdate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
tuplelen = datalen - SizeOfHeapHeader; tuplelen = datalen - SizeOfHeapHeader;
change->data.tp.newtuple = change->data.tp.newtuple =
ReorderBufferGetTupleBuf(ctx->reorder, tuplelen); ReorderBufferAllocTupleBuf(ctx->reorder, tuplelen);
DecodeXLogTuple(data, datalen, change->data.tp.newtuple); DecodeXLogTuple(data, datalen, change->data.tp.newtuple);
} }
@ -996,7 +996,7 @@ DecodeUpdate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
tuplelen = datalen - SizeOfHeapHeader; tuplelen = datalen - SizeOfHeapHeader;
change->data.tp.oldtuple = change->data.tp.oldtuple =
ReorderBufferGetTupleBuf(ctx->reorder, tuplelen); ReorderBufferAllocTupleBuf(ctx->reorder, tuplelen);
DecodeXLogTuple(data, datalen, change->data.tp.oldtuple); DecodeXLogTuple(data, datalen, change->data.tp.oldtuple);
} }
@ -1031,7 +1031,7 @@ DecodeDelete(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
if (FilterByOrigin(ctx, XLogRecGetOrigin(r))) if (FilterByOrigin(ctx, XLogRecGetOrigin(r)))
return; return;
change = ReorderBufferGetChange(ctx->reorder); change = ReorderBufferAllocChange(ctx->reorder);
if (xlrec->flags & XLH_DELETE_IS_SUPER) if (xlrec->flags & XLH_DELETE_IS_SUPER)
change->action = REORDER_BUFFER_CHANGE_INTERNAL_SPEC_ABORT; change->action = REORDER_BUFFER_CHANGE_INTERNAL_SPEC_ABORT;
@ -1051,7 +1051,7 @@ DecodeDelete(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
Assert(XLogRecGetDataLen(r) > (SizeOfHeapDelete + SizeOfHeapHeader)); Assert(XLogRecGetDataLen(r) > (SizeOfHeapDelete + SizeOfHeapHeader));
change->data.tp.oldtuple = change->data.tp.oldtuple =
ReorderBufferGetTupleBuf(ctx->reorder, tuplelen); ReorderBufferAllocTupleBuf(ctx->reorder, tuplelen);
DecodeXLogTuple((char *) xlrec + SizeOfHeapDelete, DecodeXLogTuple((char *) xlrec + SizeOfHeapDelete,
datalen, change->data.tp.oldtuple); datalen, change->data.tp.oldtuple);
@ -1083,7 +1083,7 @@ DecodeTruncate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
if (FilterByOrigin(ctx, XLogRecGetOrigin(r))) if (FilterByOrigin(ctx, XLogRecGetOrigin(r)))
return; return;
change = ReorderBufferGetChange(ctx->reorder); change = ReorderBufferAllocChange(ctx->reorder);
change->action = REORDER_BUFFER_CHANGE_TRUNCATE; change->action = REORDER_BUFFER_CHANGE_TRUNCATE;
change->origin_id = XLogRecGetOrigin(r); change->origin_id = XLogRecGetOrigin(r);
if (xlrec->flags & XLH_TRUNCATE_CASCADE) if (xlrec->flags & XLH_TRUNCATE_CASCADE)
@ -1091,8 +1091,8 @@ DecodeTruncate(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
if (xlrec->flags & XLH_TRUNCATE_RESTART_SEQS) if (xlrec->flags & XLH_TRUNCATE_RESTART_SEQS)
change->data.truncate.restart_seqs = true; change->data.truncate.restart_seqs = true;
change->data.truncate.nrelids = xlrec->nrelids; change->data.truncate.nrelids = xlrec->nrelids;
change->data.truncate.relids = ReorderBufferGetRelids(ctx->reorder, change->data.truncate.relids = ReorderBufferAllocRelids(ctx->reorder,
xlrec->nrelids); xlrec->nrelids);
memcpy(change->data.truncate.relids, xlrec->relids, memcpy(change->data.truncate.relids, xlrec->relids,
xlrec->nrelids * sizeof(Oid)); xlrec->nrelids * sizeof(Oid));
ReorderBufferQueueChange(ctx->reorder, XLogRecGetXid(r), ReorderBufferQueueChange(ctx->reorder, XLogRecGetXid(r),
@ -1149,7 +1149,7 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
HeapTuple tuple; HeapTuple tuple;
HeapTupleHeader header; HeapTupleHeader header;
change = ReorderBufferGetChange(ctx->reorder); change = ReorderBufferAllocChange(ctx->reorder);
change->action = REORDER_BUFFER_CHANGE_INSERT; change->action = REORDER_BUFFER_CHANGE_INSERT;
change->origin_id = XLogRecGetOrigin(r); change->origin_id = XLogRecGetOrigin(r);
@ -1160,7 +1160,7 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
datalen = xlhdr->datalen; datalen = xlhdr->datalen;
change->data.tp.newtuple = change->data.tp.newtuple =
ReorderBufferGetTupleBuf(ctx->reorder, datalen); ReorderBufferAllocTupleBuf(ctx->reorder, datalen);
tuple = change->data.tp.newtuple; tuple = change->data.tp.newtuple;
header = tuple->t_data; header = tuple->t_data;
@ -1224,7 +1224,7 @@ DecodeSpecConfirm(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
if (FilterByOrigin(ctx, XLogRecGetOrigin(r))) if (FilterByOrigin(ctx, XLogRecGetOrigin(r)))
return; return;
change = ReorderBufferGetChange(ctx->reorder); change = ReorderBufferAllocChange(ctx->reorder);
change->action = REORDER_BUFFER_CHANGE_INTERNAL_SPEC_CONFIRM; change->action = REORDER_BUFFER_CHANGE_INTERNAL_SPEC_CONFIRM;
change->origin_id = XLogRecGetOrigin(r); change->origin_id = XLogRecGetOrigin(r);

89
src/backend/replication/logical/reorderbuffer.c
View File

@ -220,8 +220,8 @@ int debug_logical_replication_streaming = DEBUG_LOGICAL_REP_STREAMING_BUFFERED
* primary reorderbuffer support routines * primary reorderbuffer support routines
* --------------------------------------- * ---------------------------------------
*/ */
static ReorderBufferTXN *ReorderBufferGetTXN(ReorderBuffer *rb); static ReorderBufferTXN *ReorderBufferAllocTXN(ReorderBuffer *rb);
static void ReorderBufferReturnTXN(ReorderBuffer *rb, ReorderBufferTXN *txn); static void ReorderBufferFreeTXN(ReorderBuffer *rb, ReorderBufferTXN *txn);
static ReorderBufferTXN *ReorderBufferTXNByXid(ReorderBuffer *rb, static ReorderBufferTXN *ReorderBufferTXNByXid(ReorderBuffer *rb,
TransactionId xid, bool create, bool *is_new, TransactionId xid, bool create, bool *is_new,
XLogRecPtr lsn, bool create_as_top); XLogRecPtr lsn, bool create_as_top);
@ -416,10 +416,10 @@ ReorderBufferFree(ReorderBuffer *rb)
} }
/* /*
* Get an unused, possibly preallocated, ReorderBufferTXN. * Allocate a new ReorderBufferTXN.
*/ */
static ReorderBufferTXN * static ReorderBufferTXN *
ReorderBufferGetTXN(ReorderBuffer *rb) ReorderBufferAllocTXN(ReorderBuffer *rb)
{ {
ReorderBufferTXN *txn; ReorderBufferTXN *txn;
@ -443,7 +443,7 @@ ReorderBufferGetTXN(ReorderBuffer *rb)
* Free a ReorderBufferTXN. * Free a ReorderBufferTXN.
*/ */
static void static void
ReorderBufferReturnTXN(ReorderBuffer *rb, ReorderBufferTXN *txn) ReorderBufferFreeTXN(ReorderBuffer *rb, ReorderBufferTXN *txn)
{ {
/* clean the lookup cache if we were cached (quite likely) */ /* clean the lookup cache if we were cached (quite likely) */
if (rb->by_txn_last_xid == txn->xid) if (rb->by_txn_last_xid == txn->xid)
@ -482,10 +482,10 @@ ReorderBufferReturnTXN(ReorderBuffer *rb, ReorderBufferTXN *txn)
} }
/* /*
* Get a fresh ReorderBufferChange. * Allocate a ReorderBufferChange.
*/ */
ReorderBufferChange * ReorderBufferChange *
ReorderBufferGetChange(ReorderBuffer *rb) ReorderBufferAllocChange(ReorderBuffer *rb)
{ {
ReorderBufferChange *change; ReorderBufferChange *change;
@ -500,8 +500,8 @@ ReorderBufferGetChange(ReorderBuffer *rb)
* Free a ReorderBufferChange and update memory accounting, if requested. * Free a ReorderBufferChange and update memory accounting, if requested.
*/ */
void void
ReorderBufferReturnChange(ReorderBuffer *rb, ReorderBufferChange *change, ReorderBufferFreeChange(ReorderBuffer *rb, ReorderBufferChange *change,
bool upd_mem) bool upd_mem)
{ {
/* update memory accounting info */ /* update memory accounting info */
if (upd_mem) if (upd_mem)
@ -517,13 +517,13 @@ ReorderBufferReturnChange(ReorderBuffer *rb, ReorderBufferChange *change,
case REORDER_BUFFER_CHANGE_INTERNAL_SPEC_INSERT: case REORDER_BUFFER_CHANGE_INTERNAL_SPEC_INSERT:
if (change->data.tp.newtuple) if (change->data.tp.newtuple)
{ {
ReorderBufferReturnTupleBuf(change->data.tp.newtuple); ReorderBufferFreeTupleBuf(change->data.tp.newtuple);
change->data.tp.newtuple = NULL; change->data.tp.newtuple = NULL;
} }
if (change->data.tp.oldtuple) if (change->data.tp.oldtuple)
{ {
ReorderBufferReturnTupleBuf(change->data.tp.oldtuple); ReorderBufferFreeTupleBuf(change->data.tp.oldtuple);
change->data.tp.oldtuple = NULL; change->data.tp.oldtuple = NULL;
} }
break; break;
@ -551,7 +551,7 @@ ReorderBufferReturnChange(ReorderBuffer *rb, ReorderBufferChange *change,
case REORDER_BUFFER_CHANGE_TRUNCATE: case REORDER_BUFFER_CHANGE_TRUNCATE:
if (change->data.truncate.relids != NULL) if (change->data.truncate.relids != NULL)
{ {
ReorderBufferReturnRelids(rb, change->data.truncate.relids); ReorderBufferFreeRelids(rb, change->data.truncate.relids);
change->data.truncate.relids = NULL; change->data.truncate.relids = NULL;
} }
break; break;
@ -566,11 +566,11 @@ ReorderBufferReturnChange(ReorderBuffer *rb, ReorderBufferChange *change,
} }
/* /*
* Get a fresh HeapTuple fitting a tuple of size tuple_len (excluding header * Allocate a HeapTuple fitting a tuple of size tuple_len (excluding header
* overhead). * overhead).
*/ */
HeapTuple HeapTuple
ReorderBufferGetTupleBuf(ReorderBuffer *rb, Size tuple_len) ReorderBufferAllocTupleBuf(ReorderBuffer *rb, Size tuple_len)
{ {
HeapTuple tuple; HeapTuple tuple;
Size alloc_len; Size alloc_len;
@ -585,16 +585,16 @@ ReorderBufferGetTupleBuf(ReorderBuffer *rb, Size tuple_len)
} }
/* /*
* Free a HeapTuple returned by ReorderBufferGetTupleBuf(). * Free a HeapTuple returned by ReorderBufferAllocTupleBuf().
*/ */
void void
ReorderBufferReturnTupleBuf(HeapTuple tuple) ReorderBufferFreeTupleBuf(HeapTuple tuple)
{ {
pfree(tuple); pfree(tuple);
} }
/* /*
* Get an array for relids of truncated relations. * Allocate an array for relids of truncated relations.
* *
* We use the global memory context (for the whole reorder buffer), because * We use the global memory context (for the whole reorder buffer), because
* none of the existing ones seems like a good match (some are SLAB, so we * none of the existing ones seems like a good match (some are SLAB, so we
@ -603,7 +603,7 @@ ReorderBufferReturnTupleBuf(HeapTuple tuple)
* not particularly common operation, so it does not seem worth it. * not particularly common operation, so it does not seem worth it.
*/ */
Oid * Oid *
ReorderBufferGetRelids(ReorderBuffer *rb, int nrelids) ReorderBufferAllocRelids(ReorderBuffer *rb, int nrelids)
{ {
Oid *relids; Oid *relids;
Size alloc_len; Size alloc_len;
@ -619,7 +619,7 @@ ReorderBufferGetRelids(ReorderBuffer *rb, int nrelids)
* Free an array of relids. * Free an array of relids.
*/ */
void void
ReorderBufferReturnRelids(ReorderBuffer *rb, Oid *relids) ReorderBufferFreeRelids(ReorderBuffer *rb, Oid *relids)
{ {
pfree(relids); pfree(relids);
} }
@ -684,7 +684,7 @@ ReorderBufferTXNByXid(ReorderBuffer *rb, TransactionId xid, bool create,
Assert(ent != NULL); Assert(ent != NULL);
Assert(lsn != InvalidXLogRecPtr); Assert(lsn != InvalidXLogRecPtr);
ent->txn = ReorderBufferGetTXN(rb); ent->txn = ReorderBufferAllocTXN(rb);
ent->txn->xid = xid; ent->txn->xid = xid;
txn = ent->txn; txn = ent->txn;
txn->first_lsn = lsn; txn->first_lsn = lsn;
@ -806,7 +806,7 @@ ReorderBufferQueueChange(ReorderBuffer *rb, TransactionId xid, XLogRecPtr lsn,
* We don't need to update memory accounting for this change as we * We don't need to update memory accounting for this change as we
* have not added it to the queue yet. * have not added it to the queue yet.
*/ */
ReorderBufferReturnChange(rb, change, false); ReorderBufferFreeChange(rb, change, false);
return; return;
} }
@ -872,7 +872,7 @@ ReorderBufferQueueMessage(ReorderBuffer *rb, TransactionId xid,
oldcontext = MemoryContextSwitchTo(rb->context); oldcontext = MemoryContextSwitchTo(rb->context);
change = ReorderBufferGetChange(rb); change = ReorderBufferAllocChange(rb);
change->action = REORDER_BUFFER_CHANGE_MESSAGE; change->action = REORDER_BUFFER_CHANGE_MESSAGE;
change->data.msg.prefix = pstrdup(prefix); change->data.msg.prefix = pstrdup(prefix);
change->data.msg.message_size = message_size; change->data.msg.message_size = message_size;
@ -1408,7 +1408,7 @@ ReorderBufferIterTXNNext(ReorderBuffer *rb, ReorderBufferIterTXNState *state)
{ {
change = dlist_container(ReorderBufferChange, node, change = dlist_container(ReorderBufferChange, node,
dlist_pop_head_node(&state->old_change)); dlist_pop_head_node(&state->old_change));
ReorderBufferReturnChange(rb, change, true); ReorderBufferFreeChange(rb, change, true);
Assert(dlist_is_empty(&state->old_change)); Assert(dlist_is_empty(&state->old_change));
} }
@ -1500,7 +1500,7 @@ ReorderBufferIterTXNFinish(ReorderBuffer *rb,
change = dlist_container(ReorderBufferChange, node, change = dlist_container(ReorderBufferChange, node,
dlist_pop_head_node(&state->old_change)); dlist_pop_head_node(&state->old_change));
ReorderBufferReturnChange(rb, change, true); ReorderBufferFreeChange(rb, change, true);
Assert(dlist_is_empty(&state->old_change)); Assert(dlist_is_empty(&state->old_change));
} }
@ -1555,7 +1555,7 @@ ReorderBufferCleanupTXN(ReorderBuffer *rb, ReorderBufferTXN *txn)
*/ */
mem_freed += ReorderBufferChangeSize(change); mem_freed += ReorderBufferChangeSize(change);
ReorderBufferReturnChange(rb, change, false); ReorderBufferFreeChange(rb, change, false);
} }
/* Update the memory counter */ /* Update the memory counter */
@ -1575,7 +1575,7 @@ ReorderBufferCleanupTXN(ReorderBuffer *rb, ReorderBufferTXN *txn)
Assert(change->txn == txn); Assert(change->txn == txn);
Assert(change->action == REORDER_BUFFER_CHANGE_INTERNAL_TUPLECID); Assert(change->action == REORDER_BUFFER_CHANGE_INTERNAL_TUPLECID);
ReorderBufferReturnChange(rb, change, true); ReorderBufferFreeChange(rb, change, true);
} }
/* /*
@ -1618,7 +1618,7 @@ ReorderBufferCleanupTXN(ReorderBuffer *rb, ReorderBufferTXN *txn)
ReorderBufferRestoreCleanup(rb, txn); ReorderBufferRestoreCleanup(rb, txn);
/* deallocate */ /* deallocate */
ReorderBufferReturnTXN(rb, txn); ReorderBufferFreeTXN(rb, txn);
} }
/* /*
@ -1679,7 +1679,7 @@ ReorderBufferTruncateTXN(ReorderBuffer *rb, ReorderBufferTXN *txn, bool txn_prep
*/ */
mem_freed += ReorderBufferChangeSize(change); mem_freed += ReorderBufferChangeSize(change);
ReorderBufferReturnChange(rb, change, false); ReorderBufferFreeChange(rb, change, false);
} }
/* Update the memory counter */ /* Update the memory counter */
@ -1705,7 +1705,7 @@ ReorderBufferTruncateTXN(ReorderBuffer *rb, ReorderBufferTXN *txn, bool txn_prep
/* Remove the change from its containing list. */ /* Remove the change from its containing list. */
dlist_delete(&change->node); dlist_delete(&change->node);
ReorderBufferReturnChange(rb, change, true); ReorderBufferFreeChange(rb, change, true);
} }
} }
@ -2158,7 +2158,7 @@ ReorderBufferResetTXN(ReorderBuffer *rb, ReorderBufferTXN *txn,
/* Return the spec insert change if it is not NULL */ /* Return the spec insert change if it is not NULL */
if (specinsert != NULL) if (specinsert != NULL)
{ {
ReorderBufferReturnChange(rb, specinsert, true); ReorderBufferFreeChange(rb, specinsert, true);
specinsert = NULL; specinsert = NULL;
} }
@ -2399,7 +2399,7 @@ ReorderBufferProcessTXN(ReorderBuffer *rb, ReorderBufferTXN *txn,
*/ */
if (specinsert != NULL) if (specinsert != NULL)
{ {
ReorderBufferReturnChange(rb, specinsert, true); ReorderBufferFreeChange(rb, specinsert, true);
specinsert = NULL; specinsert = NULL;
} }
@ -2428,7 +2428,7 @@ ReorderBufferProcessTXN(ReorderBuffer *rb, ReorderBufferTXN *txn,
/* clear out a pending (and thus failed) speculation */ /* clear out a pending (and thus failed) speculation */
if (specinsert != NULL) if (specinsert != NULL)
{ {
ReorderBufferReturnChange(rb, specinsert, true); ReorderBufferFreeChange(rb, specinsert, true);
specinsert = NULL; specinsert = NULL;
} }
@ -2458,7 +2458,7 @@ ReorderBufferProcessTXN(ReorderBuffer *rb, ReorderBufferTXN *txn,
ReorderBufferToastReset(rb, txn); ReorderBufferToastReset(rb, txn);
/* We don't need this record anymore. */ /* We don't need this record anymore. */
ReorderBufferReturnChange(rb, specinsert, true); ReorderBufferFreeChange(rb, specinsert, true);
specinsert = NULL; specinsert = NULL;
} }
break; break;
@ -3253,7 +3253,7 @@ void
ReorderBufferAddSnapshot(ReorderBuffer *rb, TransactionId xid, ReorderBufferAddSnapshot(ReorderBuffer *rb, TransactionId xid,
XLogRecPtr lsn, Snapshot snap) XLogRecPtr lsn, Snapshot snap)
{ {
ReorderBufferChange *change = ReorderBufferGetChange(rb); ReorderBufferChange *change = ReorderBufferAllocChange(rb);
change->data.snapshot = snap; change->data.snapshot = snap;
change->action = REORDER_BUFFER_CHANGE_INTERNAL_SNAPSHOT; change->action = REORDER_BUFFER_CHANGE_INTERNAL_SNAPSHOT;
@ -3302,7 +3302,7 @@ void
ReorderBufferAddNewCommandId(ReorderBuffer *rb, TransactionId xid, ReorderBufferAddNewCommandId(ReorderBuffer *rb, TransactionId xid,
XLogRecPtr lsn, CommandId cid) XLogRecPtr lsn, CommandId cid)
{ {
ReorderBufferChange *change = ReorderBufferGetChange(rb); ReorderBufferChange *change = ReorderBufferAllocChange(rb);
change->data.command_id = cid; change->data.command_id = cid;
change->action = REORDER_BUFFER_CHANGE_INTERNAL_COMMAND_ID; change->action = REORDER_BUFFER_CHANGE_INTERNAL_COMMAND_ID;
@ -3403,7 +3403,7 @@ ReorderBufferAddNewTupleCids(ReorderBuffer *rb, TransactionId xid,
ItemPointerData tid, CommandId cmin, ItemPointerData tid, CommandId cmin,
CommandId cmax, CommandId combocid) CommandId cmax, CommandId combocid)
{ {
ReorderBufferChange *change = ReorderBufferGetChange(rb); ReorderBufferChange *change = ReorderBufferAllocChange(rb);
ReorderBufferTXN *txn; ReorderBufferTXN *txn;
txn = ReorderBufferTXNByXid(rb, xid, true, NULL, lsn, true); txn = ReorderBufferTXNByXid(rb, xid, true, NULL, lsn, true);
@ -3476,7 +3476,7 @@ ReorderBufferAddInvalidations(ReorderBuffer *rb, TransactionId xid,
txn->ninvalidations += nmsgs; txn->ninvalidations += nmsgs;
} }
change = ReorderBufferGetChange(rb); change = ReorderBufferAllocChange(rb);
change->action = REORDER_BUFFER_CHANGE_INVALIDATION; change->action = REORDER_BUFFER_CHANGE_INVALIDATION;
change->data.inval.ninvalidations = nmsgs; change->data.inval.ninvalidations = nmsgs;
change->data.inval.invalidations = (SharedInvalidationMessage *) change->data.inval.invalidations = (SharedInvalidationMessage *)
@ -3891,7 +3891,7 @@ ReorderBufferSerializeTXN(ReorderBuffer *rb, ReorderBufferTXN *txn)
ReorderBufferSerializeChange(rb, txn, fd, change); ReorderBufferSerializeChange(rb, txn, fd, change);
dlist_delete(&change->node); dlist_delete(&change->node);
ReorderBufferReturnChange(rb, change, false); ReorderBufferFreeChange(rb, change, false);
spilled++; spilled++;
} }
@ -4395,7 +4395,7 @@ ReorderBufferRestoreChanges(ReorderBuffer *rb, ReorderBufferTXN *txn,
dlist_container(ReorderBufferChange, node, cleanup_iter.cur); dlist_container(ReorderBufferChange, node, cleanup_iter.cur);
dlist_delete(&cleanup->node); dlist_delete(&cleanup->node);
ReorderBufferReturnChange(rb, cleanup, true); ReorderBufferFreeChange(rb, cleanup, true);
} }
txn->nentries_mem = 0; txn->nentries_mem = 0;
Assert(dlist_is_empty(&txn->changes)); Assert(dlist_is_empty(&txn->changes));
@ -4528,7 +4528,7 @@ ReorderBufferRestoreChange(ReorderBuffer *rb, ReorderBufferTXN *txn,
ondisk = (ReorderBufferDiskChange *) data; ondisk = (ReorderBufferDiskChange *) data;
change = ReorderBufferGetChange(rb); change = ReorderBufferAllocChange(rb);
/* copy static part */ /* copy static part */
memcpy(change, &ondisk->change, sizeof(ReorderBufferChange)); memcpy(change, &ondisk->change, sizeof(ReorderBufferChange));
@ -4548,7 +4548,7 @@ ReorderBufferRestoreChange(ReorderBuffer *rb, ReorderBufferTXN *txn,
uint32 tuplelen = ((HeapTuple) data)->t_len; uint32 tuplelen = ((HeapTuple) data)->t_len;
change->data.tp.oldtuple = change->data.tp.oldtuple =
ReorderBufferGetTupleBuf(rb, tuplelen - SizeofHeapTupleHeader); ReorderBufferAllocTupleBuf(rb, tuplelen - SizeofHeapTupleHeader);
/* restore ->tuple */ /* restore ->tuple */
memcpy(change->data.tp.oldtuple, data, memcpy(change->data.tp.oldtuple, data,
@ -4573,7 +4573,7 @@ ReorderBufferRestoreChange(ReorderBuffer *rb, ReorderBufferTXN *txn,
sizeof(uint32)); sizeof(uint32));
change->data.tp.newtuple = change->data.tp.newtuple =
ReorderBufferGetTupleBuf(rb, tuplelen - SizeofHeapTupleHeader); ReorderBufferAllocTupleBuf(rb, tuplelen - SizeofHeapTupleHeader);
/* restore ->tuple */ /* restore ->tuple */
memcpy(change->data.tp.newtuple, data, memcpy(change->data.tp.newtuple, data,
@ -4655,8 +4655,7 @@ ReorderBufferRestoreChange(ReorderBuffer *rb, ReorderBufferTXN *txn,
{ {
Oid *relids; Oid *relids;
relids = ReorderBufferGetRelids(rb, relids = ReorderBufferAllocRelids(rb, change->data.truncate.nrelids);
change->data.truncate.nrelids);
memcpy(relids, data, change->data.truncate.nrelids * sizeof(Oid)); memcpy(relids, data, change->data.truncate.nrelids * sizeof(Oid));
change->data.truncate.relids = relids; change->data.truncate.relids = relids;
@ -5126,7 +5125,7 @@ ReorderBufferToastReset(ReorderBuffer *rb, ReorderBufferTXN *txn)
dlist_container(ReorderBufferChange, node, it.cur); dlist_container(ReorderBufferChange, node, it.cur);
dlist_delete(&change->node); dlist_delete(&change->node);
ReorderBufferReturnChange(rb, change, true); ReorderBufferFreeChange(rb, change, true);
} }
} }

15
src/include/replication/reorderbuffer.h
View File

@ -689,16 +689,15 @@ struct ReorderBuffer
extern ReorderBuffer *ReorderBufferAllocate(void); extern ReorderBuffer *ReorderBufferAllocate(void);
extern void ReorderBufferFree(ReorderBuffer *rb); extern void ReorderBufferFree(ReorderBuffer *rb);
extern HeapTuple ReorderBufferGetTupleBuf(ReorderBuffer *rb, extern HeapTuple ReorderBufferAllocTupleBuf(ReorderBuffer *rb, Size tuple_len);
Size tuple_len); extern void ReorderBufferFreeTupleBuf(HeapTuple tuple);
extern void ReorderBufferReturnTupleBuf(HeapTuple tuple);
extern ReorderBufferChange *ReorderBufferGetChange(ReorderBuffer *rb); extern ReorderBufferChange *ReorderBufferAllocChange(ReorderBuffer *rb);
extern void ReorderBufferReturnChange(ReorderBuffer *rb, extern void ReorderBufferFreeChange(ReorderBuffer *rb,
ReorderBufferChange *change, bool upd_mem); ReorderBufferChange *change, bool upd_mem);
extern Oid *ReorderBufferGetRelids(ReorderBuffer *rb, int nrelids); extern Oid *ReorderBufferAllocRelids(ReorderBuffer *rb, int nrelids);
extern void ReorderBufferReturnRelids(ReorderBuffer *rb, Oid *relids); extern void ReorderBufferFreeRelids(ReorderBuffer *rb, Oid *relids);
extern void ReorderBufferQueueChange(ReorderBuffer *rb, TransactionId xid, extern void ReorderBufferQueueChange(ReorderBuffer *rb, TransactionId xid,
XLogRecPtr lsn, ReorderBufferChange *change, XLogRecPtr lsn, ReorderBufferChange *change,