Remove ReorderBufferTupleBuf structure.

Since commit a4ccc1cef, the 'node' and 'alloc_tuple_size' fields of
the ReorderBufferTupleBuf structure are no longer used. This leaves
only the 'tuple' field in the structure. Since keeping a single-field
structure makes little sense, the ReorderBufferTupleBuf is removed
entirely. The code is refactored accordingly.

No back-patching since these are ABI changes in an exposed structure
and functions, and there would be some risk of breaking extensions.

Author: Aleksander Alekseev
Reviewed-by: Amit Kapila, Masahiko Sawada, Reid Thompson
Discussion: https://postgr.es/m/CAD21AoCvnuxiXXfRecp7g9+CeC35POQfhuQeJFr7_9u_Q5jc_Q@mail.gmail.com

diff --git a/contrib/test_decoding/test_decoding.c b/contrib/test_decoding/test_decoding.c
index 4f4f51a89c1f8b75c46b5fca9a4395528257845b..7c50d139698412366b21d1c893ca6105df241a79 100644 (file)
--- a/contrib/test_decoding/test_decoding.c
+++ b/contrib/test_decoding/test_decoding.c
@@ -640,7 +640,7 @@ pg_decode_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
                                appendStringInfoString(ctx->out, " (no-tuple-data)");
                        else
                                tuple_to_stringinfo(ctx->out, tupdesc,
-                                                                       &change->data.tp.newtuple->tuple,
+                                                                       change->data.tp.newtuple,
                                                                        false);
                        break;
                case REORDER_BUFFER_CHANGE_UPDATE:
@@ -649,7 +649,7 @@ pg_decode_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
                        {
                                appendStringInfoString(ctx->out, " old-key:");
                                tuple_to_stringinfo(ctx->out, tupdesc,
-                                                                       &change->data.tp.oldtuple->tuple,
+                                                                       change->data.tp.oldtuple,
                                                                        true);
                                appendStringInfoString(ctx->out, " new-tuple:");
                        }
@@ -658,7 +658,7 @@ pg_decode_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
                                appendStringInfoString(ctx->out, " (no-tuple-data)");
                        else
                                tuple_to_stringinfo(ctx->out, tupdesc,
-                                                                       &change->data.tp.newtuple->tuple,
+                                                                       change->data.tp.newtuple,
                                                                        false);
                        break;
                case REORDER_BUFFER_CHANGE_DELETE:
@@ -670,7 +670,7 @@ pg_decode_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
                        /* In DELETE, only the replica identity is present; display that */
                        else
                                tuple_to_stringinfo(ctx->out, tupdesc,
-                                                                       &change->data.tp.oldtuple->tuple,
+                                                                       change->data.tp.oldtuple,
                                                                        true);
                        break;
                default:

diff --git a/src/backend/replication/logical/decode.c b/src/backend/replication/logical/decode.c
index 6a0f22b209b1c0ed1e277755b0d86e3cd641a02c..7b21731287dd1eda036954f851a8c1b5e8ca559c 100644 (file)
--- a/src/backend/replication/logical/decode.c
+++ b/src/backend/replication/logical/decode.c
@@ -62,7 +62,7 @@ static void DecodePrepare(LogicalDecodingContext *ctx, XLogRecordBuffer *buf,
 
 
 /* common function to decode tuples */
-static void DecodeXLogTuple(char *data, Size len, ReorderBufferTupleBuf *tuple);
+static void DecodeXLogTuple(char *data, Size len, HeapTuple tuple);
 
 /* helper functions for decoding transactions */
 static inline bool FilterPrepare(LogicalDecodingContext *ctx,
@@ -1152,7 +1152,7 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
                ReorderBufferChange *change;
                xl_multi_insert_tuple *xlhdr;
                int                     datalen;
-               ReorderBufferTupleBuf *tuple;
+               HeapTuple       tuple;
                HeapTupleHeader header;
 
                change = ReorderBufferGetChange(ctx->reorder);
@@ -1169,21 +1169,21 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
                        ReorderBufferGetTupleBuf(ctx->reorder, datalen);
 
                tuple = change->data.tp.newtuple;
-               header = tuple->tuple.t_data;
+               header = tuple->t_data;
 
                /* not a disk based tuple */
-               ItemPointerSetInvalid(&tuple->tuple.t_self);
+               ItemPointerSetInvalid(&tuple->t_self);
 
                /*
                 * We can only figure this out after reassembling the transactions.
                 */
-               tuple->tuple.t_tableOid = InvalidOid;
+               tuple->t_tableOid = InvalidOid;
 
-               tuple->tuple.t_len = datalen + SizeofHeapTupleHeader;
+               tuple->t_len = datalen + SizeofHeapTupleHeader;
 
                memset(header, 0, SizeofHeapTupleHeader);
 
-               memcpy((char *) tuple->tuple.t_data + SizeofHeapTupleHeader,
+               memcpy((char *) tuple->t_data + SizeofHeapTupleHeader,
                           (char *) data,
                           datalen);
                header->t_infomask = xlhdr->t_infomask;
@@ -1253,7 +1253,7 @@ DecodeSpecConfirm(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
  * computed outside as they are record specific.
  */
 static void
-DecodeXLogTuple(char *data, Size len, ReorderBufferTupleBuf *tuple)
+DecodeXLogTuple(char *data, Size len, HeapTuple tuple)
 {
        xl_heap_header xlhdr;
        int                     datalen = len - SizeOfHeapHeader;
@@ -1261,14 +1261,14 @@ DecodeXLogTuple(char *data, Size len, ReorderBufferTupleBuf *tuple)
 
        Assert(datalen >= 0);
 
-       tuple->tuple.t_len = datalen + SizeofHeapTupleHeader;
-       header = tuple->tuple.t_data;
+       tuple->t_len = datalen + SizeofHeapTupleHeader;
+       header = tuple->t_data;
 
        /* not a disk based tuple */
-       ItemPointerSetInvalid(&tuple->tuple.t_self);
+       ItemPointerSetInvalid(&tuple->t_self);
 
        /* we can only figure this out after reassembling the transactions */
-       tuple->tuple.t_tableOid = InvalidOid;
+       tuple->t_tableOid = InvalidOid;
 
        /* data is not stored aligned, copy to aligned storage */
        memcpy((char *) &xlhdr,
@@ -1277,7 +1277,7 @@ DecodeXLogTuple(char *data, Size len, ReorderBufferTupleBuf *tuple)
 
        memset(header, 0, SizeofHeapTupleHeader);
 
-       memcpy(((char *) tuple->tuple.t_data) + SizeofHeapTupleHeader,
+       memcpy(((char *) tuple->t_data) + SizeofHeapTupleHeader,
                   data + SizeOfHeapHeader,
                   datalen);
 

diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c
index d1334ffb5507da4673a3461635fb894fef1f5da9..bbf0966182f92cfb34c119c83c837b0e99655003 100644 (file)
--- a/src/backend/replication/logical/reorderbuffer.c
+++ b/src/backend/replication/logical/reorderbuffer.c
@@ -498,13 +498,13 @@ ReorderBufferReturnChange(ReorderBuffer *rb, ReorderBufferChange *change,
                case REORDER_BUFFER_CHANGE_INTERNAL_SPEC_INSERT:
                        if (change->data.tp.newtuple)
                        {
-                               ReorderBufferReturnTupleBuf(rb, change->data.tp.newtuple);
+                               ReorderBufferReturnTupleBuf(change->data.tp.newtuple);
                                change->data.tp.newtuple = NULL;
                        }
 
                        if (change->data.tp.oldtuple)
                        {
-                               ReorderBufferReturnTupleBuf(rb, change->data.tp.oldtuple);
+                               ReorderBufferReturnTupleBuf(change->data.tp.oldtuple);
                                change->data.tp.oldtuple = NULL;
                        }
                        break;
@@ -547,32 +547,29 @@ ReorderBufferReturnChange(ReorderBuffer *rb, ReorderBufferChange *change,
 }
 
 /*
- * Get a fresh ReorderBufferTupleBuf fitting at least a tuple of size
- * tuple_len (excluding header overhead).
+ * Get a fresh HeapTuple fitting a tuple of size tuple_len (excluding header
+ * overhead).
  */
-ReorderBufferTupleBuf *
+HeapTuple
 ReorderBufferGetTupleBuf(ReorderBuffer *rb, Size tuple_len)
 {
-       ReorderBufferTupleBuf *tuple;
+       HeapTuple       tuple;
        Size            alloc_len;
 
        alloc_len = tuple_len + SizeofHeapTupleHeader;
 
-       tuple = (ReorderBufferTupleBuf *)
-               MemoryContextAlloc(rb->tup_context,
-                                                  sizeof(ReorderBufferTupleBuf) +
-                                                  MAXIMUM_ALIGNOF + alloc_len);
-       tuple->alloc_tuple_size = alloc_len;
-       tuple->tuple.t_data = ReorderBufferTupleBufData(tuple);
+       tuple = (HeapTuple) MemoryContextAlloc(rb->tup_context,
+                                                                                  HEAPTUPLESIZE + alloc_len);
+       tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
 
        return tuple;
 }
 
 /*
- * Free a ReorderBufferTupleBuf.
+ * Free a HeapTuple returned by ReorderBufferGetTupleBuf().
  */
 void
-ReorderBufferReturnTupleBuf(ReorderBuffer *rb, ReorderBufferTupleBuf *tuple)
+ReorderBufferReturnTupleBuf(HeapTuple tuple)
 {
        pfree(tuple);
 }
@@ -3759,8 +3756,8 @@ ReorderBufferSerializeChange(ReorderBuffer *rb, ReorderBufferTXN *txn,
                case REORDER_BUFFER_CHANGE_INTERNAL_SPEC_INSERT:
                        {
                                char       *data;
-                               ReorderBufferTupleBuf *oldtup,
-                                                  *newtup;
+                               HeapTuple       oldtup,
+                                                       newtup;
                                Size            oldlen = 0;
                                Size            newlen = 0;
 
@@ -3770,14 +3767,14 @@ ReorderBufferSerializeChange(ReorderBuffer *rb, ReorderBufferTXN *txn,
                                if (oldtup)
                                {
                                        sz += sizeof(HeapTupleData);
-                                       oldlen = oldtup->tuple.t_len;
+                                       oldlen = oldtup->t_len;
                                        sz += oldlen;
                                }
 
                                if (newtup)
                                {
                                        sz += sizeof(HeapTupleData);
-                                       newlen = newtup->tuple.t_len;
+                                       newlen = newtup->t_len;
                                        sz += newlen;
                                }
 
@@ -3790,19 +3787,19 @@ ReorderBufferSerializeChange(ReorderBuffer *rb, ReorderBufferTXN *txn,
 
                                if (oldlen)
                                {
-                                       memcpy(data, &oldtup->tuple, sizeof(HeapTupleData));
+                                       memcpy(data, oldtup, sizeof(HeapTupleData));
                                        data += sizeof(HeapTupleData);
 
-                                       memcpy(data, oldtup->tuple.t_data, oldlen);
+                                       memcpy(data, oldtup->t_data, oldlen);
                                        data += oldlen;
                                }
 
                                if (newlen)
                                {
-                                       memcpy(data, &newtup->tuple, sizeof(HeapTupleData));
+                                       memcpy(data, newtup, sizeof(HeapTupleData));
                                        data += sizeof(HeapTupleData);
 
-                                       memcpy(data, newtup->tuple.t_data, newlen);
+                                       memcpy(data, newtup->t_data, newlen);
                                        data += newlen;
                                }
                                break;
@@ -4118,8 +4115,8 @@ ReorderBufferChangeSize(ReorderBufferChange *change)
                case REORDER_BUFFER_CHANGE_DELETE:
                case REORDER_BUFFER_CHANGE_INTERNAL_SPEC_INSERT:
                        {
-                               ReorderBufferTupleBuf *oldtup,
-                                                  *newtup;
+                               HeapTuple       oldtup,
+                                                       newtup;
                                Size            oldlen = 0;
                                Size            newlen = 0;
 
@@ -4129,14 +4126,14 @@ ReorderBufferChangeSize(ReorderBufferChange *change)
                                if (oldtup)
                                {
                                        sz += sizeof(HeapTupleData);
-                                       oldlen = oldtup->tuple.t_len;
+                                       oldlen = oldtup->t_len;
                                        sz += oldlen;
                                }
 
                                if (newtup)
                                {
                                        sz += sizeof(HeapTupleData);
-                                       newlen = newtup->tuple.t_len;
+                                       newlen = newtup->t_len;
                                        sz += newlen;
                                }
 
@@ -4365,16 +4362,16 @@ ReorderBufferRestoreChange(ReorderBuffer *rb, ReorderBufferTXN *txn,
                                        ReorderBufferGetTupleBuf(rb, tuplelen - SizeofHeapTupleHeader);
 
                                /* restore ->tuple */
-                               memcpy(&change->data.tp.oldtuple->tuple, data,
+                               memcpy(change->data.tp.oldtuple, data,
                                           sizeof(HeapTupleData));
                                data += sizeof(HeapTupleData);
 
                                /* reset t_data pointer into the new tuplebuf */
-                               change->data.tp.oldtuple->tuple.t_data =
-                                       ReorderBufferTupleBufData(change->data.tp.oldtuple);
+                               change->data.tp.oldtuple->t_data =
+                                       (HeapTupleHeader) ((char *) change->data.tp.oldtuple + HEAPTUPLESIZE);
 
                                /* restore tuple data itself */
-                               memcpy(change->data.tp.oldtuple->tuple.t_data, data, tuplelen);
+                               memcpy(change->data.tp.oldtuple->t_data, data, tuplelen);
                                data += tuplelen;
                        }
 
@@ -4390,16 +4387,16 @@ ReorderBufferRestoreChange(ReorderBuffer *rb, ReorderBufferTXN *txn,
                                        ReorderBufferGetTupleBuf(rb, tuplelen - SizeofHeapTupleHeader);
 
                                /* restore ->tuple */
-                               memcpy(&change->data.tp.newtuple->tuple, data,
+                               memcpy(change->data.tp.newtuple, data,
                                           sizeof(HeapTupleData));
                                data += sizeof(HeapTupleData);
 
                                /* reset t_data pointer into the new tuplebuf */
-                               change->data.tp.newtuple->tuple.t_data =
-                                       ReorderBufferTupleBufData(change->data.tp.newtuple);
+                               change->data.tp.newtuple->t_data =
+                                       (HeapTupleHeader) ((char *) change->data.tp.newtuple + HEAPTUPLESIZE);
 
                                /* restore tuple data itself */
-                               memcpy(change->data.tp.newtuple->tuple.t_data, data, tuplelen);
+                               memcpy(change->data.tp.newtuple->t_data, data, tuplelen);
                                data += tuplelen;
                        }
 
@@ -4646,7 +4643,7 @@ ReorderBufferToastAppendChunk(ReorderBuffer *rb, ReorderBufferTXN *txn,
                                                          Relation relation, ReorderBufferChange *change)
 {
        ReorderBufferToastEnt *ent;
-       ReorderBufferTupleBuf *newtup;
+       HeapTuple       newtup;
        bool            found;
        int32           chunksize;
        bool            isnull;
@@ -4661,9 +4658,9 @@ ReorderBufferToastAppendChunk(ReorderBuffer *rb, ReorderBufferTXN *txn,
        Assert(IsToastRelation(relation));
 
        newtup = change->data.tp.newtuple;
-       chunk_id = DatumGetObjectId(fastgetattr(&newtup->tuple, 1, desc, &isnull));
+       chunk_id = DatumGetObjectId(fastgetattr(newtup, 1, desc, &isnull));
        Assert(!isnull);
-       chunk_seq = DatumGetInt32(fastgetattr(&newtup->tuple, 2, desc, &isnull));
+       chunk_seq = DatumGetInt32(fastgetattr(newtup, 2, desc, &isnull));
        Assert(!isnull);
 
        ent = (ReorderBufferToastEnt *)
@@ -4686,7 +4683,7 @@ ReorderBufferToastAppendChunk(ReorderBuffer *rb, ReorderBufferTXN *txn,
                elog(ERROR, "got sequence entry %d for toast chunk %u instead of seq %d",
                         chunk_seq, chunk_id, ent->last_chunk_seq + 1);
 
-       chunk = DatumGetPointer(fastgetattr(&newtup->tuple, 3, desc, &isnull));
+       chunk = DatumGetPointer(fastgetattr(newtup, 3, desc, &isnull));
        Assert(!isnull);
 
        /* calculate size so we can allocate the right size at once later */
@@ -4737,7 +4734,7 @@ ReorderBufferToastReplace(ReorderBuffer *rb, ReorderBufferTXN *txn,
        Relation        toast_rel;
        TupleDesc       toast_desc;
        MemoryContext oldcontext;
-       ReorderBufferTupleBuf *newtup;
+       HeapTuple       newtup;
        Size            old_size;
 
        /* no toast tuples changed */
@@ -4777,7 +4774,7 @@ ReorderBufferToastReplace(ReorderBuffer *rb, ReorderBufferTXN *txn,
 
        newtup = change->data.tp.newtuple;
 
-       heap_deform_tuple(&newtup->tuple, desc, attrs, isnull);
+       heap_deform_tuple(newtup, desc, attrs, isnull);
 
        for (natt = 0; natt < desc->natts; natt++)
        {
@@ -4842,12 +4839,12 @@ ReorderBufferToastReplace(ReorderBuffer *rb, ReorderBufferTXN *txn,
                {
                        bool            cisnull;
                        ReorderBufferChange *cchange;
-                       ReorderBufferTupleBuf *ctup;
+                       HeapTuple       ctup;
                        Pointer         chunk;
 
                        cchange = dlist_container(ReorderBufferChange, node, it.cur);
                        ctup = cchange->data.tp.newtuple;
-                       chunk = DatumGetPointer(fastgetattr(&ctup->tuple, 3, toast_desc, &cisnull));
+                       chunk = DatumGetPointer(fastgetattr(ctup, 3, toast_desc, &cisnull));
 
                        Assert(!cisnull);
                        Assert(!VARATT_IS_EXTERNAL(chunk));
@@ -4882,11 +4879,11 @@ ReorderBufferToastReplace(ReorderBuffer *rb, ReorderBufferTXN *txn,
         * the tuplebuf because attrs[] will point back into the current content.
         */
        tmphtup = heap_form_tuple(desc, attrs, isnull);
-       Assert(newtup->tuple.t_len <= MaxHeapTupleSize);
-       Assert(ReorderBufferTupleBufData(newtup) == newtup->tuple.t_data);
+       Assert(newtup->t_len <= MaxHeapTupleSize);
+       Assert(newtup->t_data == (HeapTupleHeader) ((char *) newtup + HEAPTUPLESIZE));
 
-       memcpy(newtup->tuple.t_data, tmphtup->t_data, tmphtup->t_len);
-       newtup->tuple.t_len = tmphtup->t_len;
+       memcpy(newtup->t_data, tmphtup->t_data, tmphtup->t_len);
+       newtup->t_len = tmphtup->t_len;
 
        /*
         * free resources we won't further need, more persistent stuff will be

diff --git a/src/backend/replication/pgoutput/pgoutput.c b/src/backend/replication/pgoutput/pgoutput.c
index 425238187f64b523ee9bf477e78727c53358e5f8..998f92d67128d41ce61616631abd17060c237cd4 100644 (file)
--- a/src/backend/replication/pgoutput/pgoutput.c
+++ b/src/backend/replication/pgoutput/pgoutput.c
@@ -1473,7 +1473,7 @@ pgoutput_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
        if (change->data.tp.oldtuple)
        {
                old_slot = relentry->old_slot;
-               ExecStoreHeapTuple(&change->data.tp.oldtuple->tuple, old_slot, false);
+               ExecStoreHeapTuple(change->data.tp.oldtuple, old_slot, false);
 
                /* Convert tuple if needed. */
                if (relentry->attrmap)
@@ -1488,7 +1488,7 @@ pgoutput_change(LogicalDecodingContext *ctx, ReorderBufferTXN *txn,
        if (change->data.tp.newtuple)
        {
                new_slot = relentry->new_slot;
-               ExecStoreHeapTuple(&change->data.tp.newtuple->tuple, new_slot, false);
+               ExecStoreHeapTuple(change->data.tp.newtuple, new_slot, false);
 
                /* Convert tuple if needed. */
                if (relentry->attrmap)

diff --git a/src/include/replication/reorderbuffer.h b/src/include/replication/reorderbuffer.h
index 3e232c6c27fb61b8286d8bd93d5998bee2d7fabd..0b2c95f7aa09525eafab6264f7acd1ad7bbc40cf 100644 (file)
--- a/src/include/replication/reorderbuffer.h
+++ b/src/include/replication/reorderbuffer.h
@@ -28,25 +28,6 @@ typedef enum
        DEBUG_LOGICAL_REP_STREAMING_IMMEDIATE,
 }                      DebugLogicalRepStreamingMode;
 
-/* an individual tuple, stored in one chunk of memory */
-typedef struct ReorderBufferTupleBuf
-{
-       /* position in preallocated list */
-       slist_node      node;
-
-       /* tuple header, the interesting bit for users of logical decoding */
-       HeapTupleData tuple;
-
-       /* pre-allocated size of tuple buffer, different from tuple size */
-       Size            alloc_tuple_size;
-
-       /* actual tuple data follows */
-} ReorderBufferTupleBuf;
-
-/* pointer to the data stored in a TupleBuf */
-#define ReorderBufferTupleBufData(p) \
-       ((HeapTupleHeader) MAXALIGN(((char *) p) + sizeof(ReorderBufferTupleBuf)))
-
 /*
  * Types of the change passed to a 'change' callback.
  *
@@ -114,9 +95,9 @@ typedef struct ReorderBufferChange
                        bool            clear_toast_afterwards;
 
                        /* valid for DELETE || UPDATE */
-                       ReorderBufferTupleBuf *oldtuple;
+                       HeapTuple       oldtuple;
                        /* valid for INSERT || UPDATE */
-                       ReorderBufferTupleBuf *newtuple;
+                       HeapTuple       newtuple;
                }                       tp;
 
                /*
@@ -678,10 +659,10 @@ struct ReorderBuffer
 extern ReorderBuffer *ReorderBufferAllocate(void);
 extern void ReorderBufferFree(ReorderBuffer *rb);
 
-extern ReorderBufferTupleBuf *ReorderBufferGetTupleBuf(ReorderBuffer *rb,
-                                                                                                          Size tuple_len);
-extern void ReorderBufferReturnTupleBuf(ReorderBuffer *rb,
-                                                                               ReorderBufferTupleBuf *tuple);
+extern HeapTuple ReorderBufferGetTupleBuf(ReorderBuffer *rb,
+                                                                                 Size tuple_len);
+extern void ReorderBufferReturnTupleBuf(HeapTuple tuple);
+
 extern ReorderBufferChange *ReorderBufferGetChange(ReorderBuffer *rb);
 extern void ReorderBufferReturnChange(ReorderBuffer *rb,
                                                                          ReorderBufferChange *change, bool upd_mem);

diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 7e866e3c3d04d81cd25fafc851297761449e00e7..dc3b0ef87107c2129c98fcd5b1033548d2756b70 100644 (file)
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -2351,7 +2351,6 @@ ReorderBufferStreamTruncateCB
 ReorderBufferTXN
 ReorderBufferTXNByIdEnt
 ReorderBufferToastEnt
-ReorderBufferTupleBuf
 ReorderBufferTupleCidEnt
 ReorderBufferTupleCidKey
 ReorderBufferUpdateProgressTxnCB