From 1165438a2945d4dfb54e2e3152eac7e34026f75f Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Thu, 28 Aug 2025 12:47:42 +0300
Subject: [PATCH 01/27] Add Compacted in LogFormat

---
 .../src/main/java/org/apache/fluss/metadata/LogFormat.java      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fluss-common/src/main/java/org/apache/fluss/metadata/LogFormat.java b/fluss-common/src/main/java/org/apache/fluss/metadata/LogFormat.java
index b5f460162f..9923b611fa 100644
--- a/fluss-common/src/main/java/org/apache/fluss/metadata/LogFormat.java
+++ b/fluss-common/src/main/java/org/apache/fluss/metadata/LogFormat.java
@@ -73,4 +73,4 @@ public static LogFormat fromString(String format) {
                 throw new IllegalArgumentException("Unsupported log format: " + format);
         }
     }
-}
+}
\ No newline at end of file

From d0698ae86ab8e8c98f0d6cc9b41cc58bd59526f6 Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 09:26:52 +0300
Subject: [PATCH 02/27] Introduce CompactedLogRecord and related functionality

---
 .idea/vcs.xml                                 |  4 +--
 .../fluss/record/CompactedLogRecord.java      | 33 +++++++++++++++++--
 2 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/.idea/vcs.xml b/.idea/vcs.xml
index b0576b2675..32ad229349 100644
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -15,6 +15,6 @@
     </option>
   </component>
   <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="" vcs="Git" />
   </component>
-</project>
+</project>
\ No newline at end of file
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java b/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
index fb7f2f3141..7d6a24b45e 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
@@ -32,10 +32,11 @@
 import java.io.IOException;
 
 import static org.apache.fluss.record.LogRecordBatchFormat.LENGTH_LENGTH;
-
 /**
  * An immutable log record for {@link CompactedRow} which can be directly persisted. The on-wire
  * schema is identical to IndexedLogRecord but the row payload uses the CompactedRow binary format:
+ * An immutable log record for @CompactedRow which can be directly persisted. The on-wire schema is
+ * identical to IndexedLogRecord but the row payload uses the CompactedRow binary format:
  *
  * <ul>
  *   <li>Length => int32 (total number of bytes following this length field)
@@ -49,20 +50,28 @@
  * in a CompactedRow with a {@link CompactedRowDeserializer} and only decode to object values when a
  * field is accessed. - The record header (Length + Attributes) layout and attribute semantics are
  * the same.
+ * Differences vs {@link IndexedLogRecord}:
+ * - Uses CompactedRow encoding which is space-optimized (VLQ for ints/longs, per-row null bitset) and
+ *   trades CPU for smaller storage; random access to fields is not supported without decoding.
+ * - Deserialization is lazy: we wrap the underlying bytes in a CompactedRow with a
+ *   {@link CompactedRowDeserializer} and only decode to object values when a field is accessed.
+ * - The record header (Length + Attributes) layout and attribute semantics are the same.
  *
  * <p>The offset computes the difference relative to the base offset of the batch containing this
  * record.
+ * The offset computes the difference relative to the base offset of the batch containing this
+ * record.
  *
  * @since 0.8
  */
 @PublicEvolving
 public class CompactedLogRecord implements LogRecord {
-
     private static final int ATTRIBUTES_LENGTH = 1;
 
     private final long logOffset;
     private final long timestamp;
     private final DataType[] fieldTypes;
+    private final CompactedRowDeserializer compactedDeserializer;
 
     private MemorySegment segment;
     private int offset;
@@ -72,6 +81,7 @@ public class CompactedLogRecord implements LogRecord {
         this.logOffset = logOffset;
         this.timestamp = timestamp;
         this.fieldTypes = fieldTypes;
+        this.compactedDeserializer = new CompactedRowDeserializer(fieldTypes);
     }
 
     private void pointTo(MemorySegment segment, int offset, int sizeInBytes) {
@@ -163,5 +173,24 @@ private static int calculateSizeInBytes(BinaryRow row) {
         int size = 1; // one byte for attributes
         size += row.getSizeInBytes();
         return size;
+        int rowOffset = LENGTH_LENGTH + ATTRIBUTES_LENGTH;
+        return deserializeCompactedRow(
+                sizeInBytes - rowOffset, segment, offset + rowOffset, fieldTypes, LogFormat.COMPACTED);
+    }
+
+
+    private static InternalRow deserializeCompactedRow(
+            int length,
+            MemorySegment segment,
+            int position,
+            DataType[] fieldTypes,
+            LogFormat logFormat) {
+        if (logFormat == LogFormat.COMPACTED) {
+            CompactedRow compactedRow = new CompactedRow(fieldTypes.length, compactedDeserializer);
+            compactedRow.pointTo(segment, position, length);
+            return compactedRow;
+        } else {
+            throw new IllegalArgumentException("No such compacted row deserializer for: " + logFormat);
+        }
     }
 }

From 8ced8f56df8e23a50dd75c913f0d73f16b105556 Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 09:32:21 +0300
Subject: [PATCH 03/27] Add tests for CompactedLogRecord

---
 .../main/java/org/apache/fluss/record/CompactedLogRecord.java | 2 --
 .../java/org/apache/fluss/record/CompactedLogRecordTest.java  | 4 ++++
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java b/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
index 7d6a24b45e..2e7fee94f9 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
@@ -59,8 +59,6 @@
  *
  * <p>The offset computes the difference relative to the base offset of the batch containing this
  * record.
- * The offset computes the difference relative to the base offset of the batch containing this
- * record.
  *
  * @since 0.8
  */
diff --git a/fluss-common/src/test/java/org/apache/fluss/record/CompactedLogRecordTest.java b/fluss-common/src/test/java/org/apache/fluss/record/CompactedLogRecordTest.java
index cfec405f1c..a3a8ed8899 100644
--- a/fluss-common/src/test/java/org/apache/fluss/record/CompactedLogRecordTest.java
+++ b/fluss-common/src/test/java/org/apache/fluss/record/CompactedLogRecordTest.java
@@ -47,8 +47,10 @@ void testBase() throws IOException {
         CompactedRow row =
                 CompactedRow.from(fieldTypes, bytes, new CompactedRowDeserializer(fieldTypes));
 
+        // write
         CompactedLogRecord.writeTo(outputView, ChangeType.APPEND_ONLY, row);
 
+        // read
         CompactedLogRecord logRecord =
                 CompactedLogRecord.readFrom(
                         MemorySegment.wrap(outputView.getCopyOfBuffer()),
@@ -71,8 +73,10 @@ void testWriteToAndReadFromWithRandomData() throws IOException {
                 TestInternalRowGenerator.createAllRowType().getChildren().toArray(new DataType[0]);
         CompactedRow row = TestInternalRowGenerator.genCompactedRowForAllType();
 
+        // write
         CompactedLogRecord.writeTo(outputView, ChangeType.APPEND_ONLY, row);
 
+        // read
         LogRecord logRecord =
                 CompactedLogRecord.readFrom(
                         MemorySegment.wrap(outputView.getCopyOfBuffer()),

From 88a06f8d44b9fb586ddf9a4c32a7fd6804157508 Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 09:34:18 +0300
Subject: [PATCH 04/27] fix vcs.xml

---
 .idea/vcs.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.idea/vcs.xml b/.idea/vcs.xml
index 32ad229349..8a86108204 100644
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -15,6 +15,6 @@
     </option>
   </component>
   <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
+      <mapping directory="$PROJECT_DIR$" vcs="Git" />
   </component>
 </project>
\ No newline at end of file

From 5396cc7069f76874c7bb208d335e31d3c03e412b Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 09:35:23 +0300
Subject: [PATCH 05/27] apply spotless

---
 .../main/java/org/apache/fluss/metadata/LogFormat.java   | 2 +-
 .../java/org/apache/fluss/record/CompactedLogRecord.java | 9 ++++-----
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/fluss-common/src/main/java/org/apache/fluss/metadata/LogFormat.java b/fluss-common/src/main/java/org/apache/fluss/metadata/LogFormat.java
index 9923b611fa..b5f460162f 100644
--- a/fluss-common/src/main/java/org/apache/fluss/metadata/LogFormat.java
+++ b/fluss-common/src/main/java/org/apache/fluss/metadata/LogFormat.java
@@ -73,4 +73,4 @@ public static LogFormat fromString(String format) {
                 throw new IllegalArgumentException("Unsupported log format: " + format);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java b/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
index 2e7fee94f9..00eb8dd512 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
@@ -33,15 +33,13 @@
 
 import static org.apache.fluss.record.LogRecordBatchFormat.LENGTH_LENGTH;
 /**
- * An immutable log record for {@link CompactedRow} which can be directly persisted. The on-wire
- * schema is identical to IndexedLogRecord but the row payload uses the CompactedRow binary format:
  * An immutable log record for @CompactedRow which can be directly persisted. The on-wire schema is
  * identical to IndexedLogRecord but the row payload uses the CompactedRow binary format:
  *
  * <ul>
- *   <li>Length => int32 (total number of bytes following this length field)
- *   <li>Attributes => int8 (low 4 bits encode {@link ChangeType})
- *   <li>Value => {@link CompactedRow} (bytes in compacted row format)
+ *   <li>Length => int32 (total number of bytes following this length field)</li>
+ *   <li>Attributes => int8 (low 4 bits encode {@link ChangeType})</li>
+ *   <li>Value => {@link CompactedRow} (bytes in compacted row format)</li>
  * </ul>
  *
  * <p>Differences vs {@link IndexedLogRecord}: - Uses CompactedRow encoding which is space-optimized
@@ -64,6 +62,7 @@
  */
 @PublicEvolving
 public class CompactedLogRecord implements LogRecord {
+
     private static final int ATTRIBUTES_LENGTH = 1;
 
     private final long logOffset;

From b362b4b91f96f10e741605ba264ab1e970d27190 Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 10:36:46 +0300
Subject: [PATCH 06/27] revert vcs changes

---
 .idea/vcs.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.idea/vcs.xml b/.idea/vcs.xml
index 8a86108204..ed5900ccbe 100644
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -15,6 +15,6 @@
     </option>
   </component>
   <component name="VcsDirectoryMappings">
-      <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
   </component>
 </project>
\ No newline at end of file

From 6caa7a1dc8f53b031b204888b3e90355d8954375 Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 12:01:20 +0300
Subject: [PATCH 07/27] update AppendWriterImpl to support compactedRow

---
 .../client/table/writer/AppendWriterImpl.java | 26 +++++++++++++++++++
 .../fluss/client/write/WriteFormat.java       |  1 +
 .../fluss/client/write/WriteRecord.java       | 18 +++++++++++++
 3 files changed, 45 insertions(+)

diff --git a/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java b/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java
index d702e9621e..6e2381b7e9 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java
@@ -26,9 +26,12 @@
 import org.apache.fluss.metadata.TablePath;
 import org.apache.fluss.row.InternalRow;
 import org.apache.fluss.row.InternalRow.FieldGetter;
+import org.apache.fluss.row.compacted.CompactedRow;
+import org.apache.fluss.row.encode.CompactedRowEncoder;
 import org.apache.fluss.row.encode.IndexedRowEncoder;
 import org.apache.fluss.row.encode.KeyEncoder;
 import org.apache.fluss.row.indexed.IndexedRow;
+import org.apache.fluss.types.DataType;
 import org.apache.fluss.types.RowType;
 
 import javax.annotation.Nullable;
@@ -44,6 +47,7 @@ class AppendWriterImpl extends AbstractTableWriter implements AppendWriter {
 
     private final LogFormat logFormat;
     private final IndexedRowEncoder indexedRowEncoder;
+    private final CompactedRowEncoder compactedRowEncoder;
     private final FieldGetter[] fieldGetters;
     private final TableInfo tableInfo;
 
@@ -58,8 +62,15 @@ class AppendWriterImpl extends AbstractTableWriter implements AppendWriter {
             this.bucketKeyEncoder = KeyEncoder.of(rowType, bucketKeys, lakeFormat);
         }
 
+        DataType[] fieldDataTypes = tableInfo
+                .getSchema()
+                .getRowType()
+                .getChildren()
+                .toArray(new DataType[0]);
+
         this.logFormat = tableInfo.getTableConfig().getLogFormat();
         this.indexedRowEncoder = new IndexedRowEncoder(tableInfo.getRowType());
+        this.compactedRowEncoder = new CompactedRowEncoder(fieldDataTypes);
         this.fieldGetters = InternalRow.createFieldGetters(tableInfo.getRowType());
         this.tableInfo = tableInfo;
     }
@@ -80,6 +91,9 @@ public CompletableFuture<AppendResult> append(InternalRow row) {
         if (logFormat == LogFormat.INDEXED) {
             IndexedRow indexedRow = encodeIndexedRow(row);
             record = WriteRecord.forIndexedAppend(tableInfo, physicalPath, indexedRow, bucketKey);
+        } else if (logFormat == LogFormat.COMPACTED)  {
+            CompactedRow compactedRow = encodeCompactedRow(row);
+            record = WriteRecord.forCompactedAppend(tableInfo, physicalPath, compactedRow, bucketKey);
         } else {
             // ARROW format supports general internal row
             record = WriteRecord.forArrowAppend(tableInfo, physicalPath, row, bucketKey);
@@ -87,6 +101,18 @@ record = WriteRecord.forArrowAppend(tableInfo, physicalPath, row, bucketKey);
         return send(record).thenApply(ignored -> APPEND_SUCCESS);
     }
 
+    private CompactedRow encodeCompactedRow(InternalRow row) {
+        if (row instanceof CompactedRow) {
+            return (CompactedRow) row;
+        }
+
+        compactedRowEncoder.startNewRow();
+        for (int i = 0; i < fieldCount; i++) {
+            compactedRowEncoder.encodeField(i, fieldGetters[i].getFieldOrNull(row));
+        }
+        return compactedRowEncoder.finishRow();
+    }
+
     private IndexedRow encodeIndexedRow(InternalRow row) {
         if (row instanceof IndexedRow) {
             return (IndexedRow) row;
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteFormat.java b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteFormat.java
index 669c6807eb..7b36b8eacf 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteFormat.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteFormat.java
@@ -24,5 +24,6 @@
 public enum WriteFormat {
     ARROW_LOG,
     INDEXED_LOG,
+    COMPACTED_LOG,
     KV
 }
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
index 68a3fe8a2e..2c0fb1c0fe 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
@@ -23,8 +23,10 @@
 import org.apache.fluss.record.DefaultKvRecord;
 import org.apache.fluss.record.DefaultKvRecordBatch;
 import org.apache.fluss.record.IndexedLogRecord;
+import org.apache.fluss.record.CompactedLogRecord;
 import org.apache.fluss.row.BinaryRow;
 import org.apache.fluss.row.InternalRow;
+import org.apache.fluss.row.compacted.CompactedRow;
 import org.apache.fluss.row.indexed.IndexedRow;
 
 import javax.annotation.Nullable;
@@ -127,6 +129,22 @@ public static WriteRecord forArrowAppend(
                 estimatedSizeInBytes);
     }
 
+    /** Creates a write record for append operation for Compacted format. */
+    public static WriteRecord forCompactedAppend(
+            PhysicalTablePath tablePath, CompactedRow row, @Nullable byte[] bucketKey) {
+        checkNotNull(row);
+        int estimatedSizeInBytes =
+                CompactedLogRecord.sizeOf(row) + DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE;
+        return new WriteRecord(
+                tablePath,
+                null,
+                bucketKey,
+                row,
+                WriteFormat.COMPACTED_LOG,
+                null,
+                estimatedSizeInBytes);
+    }
+
     // ------------------------------------------------------------------------------------------
 
     private final PhysicalTablePath physicalTablePath;

From 8cad33928908b55bab6421173150aa1c2f0f5257 Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 12:06:37 +0300
Subject: [PATCH 08/27] apply spotless

---
 .../fluss/client/table/writer/AppendWriterImpl.java      | 9 +++------
 .../java/org/apache/fluss/client/write/WriteRecord.java  | 2 +-
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java b/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java
index 6e2381b7e9..01aac31330 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java
@@ -62,11 +62,8 @@ class AppendWriterImpl extends AbstractTableWriter implements AppendWriter {
             this.bucketKeyEncoder = KeyEncoder.of(rowType, bucketKeys, lakeFormat);
         }
 
-        DataType[] fieldDataTypes = tableInfo
-                .getSchema()
-                .getRowType()
-                .getChildren()
-                .toArray(new DataType[0]);
+        DataType[] fieldDataTypes =
+                tableInfo.getSchema().getRowType().getChildren().toArray(new DataType[0]);
 
         this.logFormat = tableInfo.getTableConfig().getLogFormat();
         this.indexedRowEncoder = new IndexedRowEncoder(tableInfo.getRowType());
@@ -91,7 +88,7 @@ public CompletableFuture<AppendResult> append(InternalRow row) {
         if (logFormat == LogFormat.INDEXED) {
             IndexedRow indexedRow = encodeIndexedRow(row);
             record = WriteRecord.forIndexedAppend(tableInfo, physicalPath, indexedRow, bucketKey);
-        } else if (logFormat == LogFormat.COMPACTED)  {
+        } else if (logFormat == LogFormat.COMPACTED) {
             CompactedRow compactedRow = encodeCompactedRow(row);
             record = WriteRecord.forCompactedAppend(tableInfo, physicalPath, compactedRow, bucketKey);
         } else {
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
index 2c0fb1c0fe..3b81bac85a 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
@@ -19,11 +19,11 @@
 
 import org.apache.fluss.annotation.Internal;
 import org.apache.fluss.metadata.PhysicalTablePath;
+import org.apache.fluss.record.CompactedLogRecord;
 import org.apache.fluss.metadata.TableInfo;
 import org.apache.fluss.record.DefaultKvRecord;
 import org.apache.fluss.record.DefaultKvRecordBatch;
 import org.apache.fluss.record.IndexedLogRecord;
-import org.apache.fluss.record.CompactedLogRecord;
 import org.apache.fluss.row.BinaryRow;
 import org.apache.fluss.row.InternalRow;
 import org.apache.fluss.row.compacted.CompactedRow;

From 40db54b8f5b728b5ee8b2ed31d5621610d49ed5d Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 16:24:00 +0300
Subject: [PATCH 09/27] CompactedLogWriteBatch and
 MemoryLogRecordsCompactedBuilder with tests

---
 .../client/write/CompactedLogWriteBatch.java  | 141 ++++++++++
 .../fluss/client/write/RecordAccumulator.java |   9 +
 .../write/CompactedLogWriteBatchTest.java     | 244 ++++++++++++++++++
 .../MemoryLogRecordsCompactedBuilder.java     | 220 ++++++++++++++++
 .../MemoryLogRecordsCompactedBuilderTest.java |  64 +++--
 5 files changed, 643 insertions(+), 35 deletions(-)
 create mode 100644 fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
 create mode 100644 fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java

diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
new file mode 100644
index 0000000000..3289afc71d
--- /dev/null
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
@@ -0,0 +1,141 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.fluss.client.write;
+
+import org.apache.fluss.annotation.Internal;
+import org.apache.fluss.exception.FlussRuntimeException;
+import org.apache.fluss.memory.AbstractPagedOutputView;
+import org.apache.fluss.memory.MemorySegment;
+import org.apache.fluss.metadata.PhysicalTablePath;
+import org.apache.fluss.record.ChangeType;
+import org.apache.fluss.record.MemoryLogRecordsCompactedBuilder;
+import org.apache.fluss.record.bytesview.BytesView;
+import org.apache.fluss.row.compacted.CompactedRow;
+import org.apache.fluss.rpc.messages.ProduceLogRequest;
+
+import javax.annotation.concurrent.NotThreadSafe;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.apache.fluss.utils.Preconditions.checkArgument;
+import static org.apache.fluss.utils.Preconditions.checkNotNull;
+
+/**
+ * A batch of log records managed in COMPACTED format that is or will be sent to server by {@link
+ * ProduceLogRequest}.
+ *
+ * <p>This class is not thread safe and external synchronization must be used when modifying it.
+ */
+@NotThreadSafe
+@Internal
+public final class CompactedLogWriteBatch extends WriteBatch {
+    private final AbstractPagedOutputView outputView;
+    private final MemoryLogRecordsCompactedBuilder recordsBuilder;
+
+    public CompactedLogWriteBatch(
+            int bucketId,
+            PhysicalTablePath physicalTablePath,
+            int schemaId,
+            int writeLimit,
+            AbstractPagedOutputView outputView,
+            long createdMs) {
+        super(bucketId, physicalTablePath, createdMs);
+        this.outputView = outputView;
+        this.recordsBuilder =
+                MemoryLogRecordsCompactedBuilder.builder(schemaId, writeLimit, outputView, true);
+    }
+
+    @Override
+    public boolean tryAppend(WriteRecord writeRecord, WriteCallback callback) throws Exception {
+        checkNotNull(callback, "write callback must be not null");
+        checkNotNull(writeRecord.getRow(), "row must not be null for log record");
+        checkArgument(writeRecord.getKey() == null, "key must be null for log record");
+        checkArgument(
+                writeRecord.getTargetColumns() == null,
+                "target columns must be null for log record");
+        checkArgument(
+                writeRecord.getRow() instanceof CompactedRow,
+                "row must be CompactedRow for compacted log table");
+        CompactedRow row = (CompactedRow) writeRecord.getRow();
+        if (!recordsBuilder.hasRoomFor(row) || isClosed()) {
+            return false;
+        } else {
+            recordsBuilder.append(ChangeType.APPEND_ONLY, row);
+            recordCount++;
+            callbacks.add(callback);
+            return true;
+        }
+    }
+
+    @Override
+    public BytesView build() {
+        try {
+            return recordsBuilder.build();
+        } catch (IOException e) {
+            throw new FlussRuntimeException("Failed to build compacted log record batch.", e);
+        }
+    }
+
+    @Override
+    public boolean isClosed() {
+        return recordsBuilder.isClosed();
+    }
+
+    @Override
+    public void close() throws Exception {
+        recordsBuilder.close();
+        reopened = false;
+    }
+
+    @Override
+    public List<MemorySegment> pooledMemorySegments() {
+        return outputView.allocatedPooledSegments();
+    }
+
+    @Override
+    public void setWriterState(long writerId, int batchSequence) {
+        recordsBuilder.setWriterState(writerId, batchSequence);
+    }
+
+    @Override
+    public long writerId() {
+        return recordsBuilder.writerId();
+    }
+
+    @Override
+    public int batchSequence() {
+        return recordsBuilder.batchSequence();
+    }
+
+    @Override
+    public void abortRecordAppends() {
+        recordsBuilder.abort();
+    }
+
+    @Override
+    public void resetWriterState(long writerId, int batchSequence) {
+        super.resetWriterState(writerId, batchSequence);
+        recordsBuilder.resetWriterState(writerId, batchSequence);
+    }
+
+    @Override
+    public int estimatedSizeInBytes() {
+        return recordsBuilder.getSizeInBytes();
+    }
+}
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/RecordAccumulator.java b/fluss-client/src/main/java/org/apache/fluss/client/write/RecordAccumulator.java
index 3a282ba926..16911014b7 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/RecordAccumulator.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/RecordAccumulator.java
@@ -610,6 +610,15 @@ private RecordAppendResult appendNewBatch(
                             arrowWriter,
                             outputView,
                             clock.milliseconds());
+        } else if (writeFormat == WriteFormat.COMPACTED_LOG) {
+            batch =
+                    new CompactedLogWriteBatch(
+                            bucketId,
+                            physicalTablePath,
+                            schemaId,
+                            outputView.getPreAllocatedSize(),
+                            outputView,
+                            clock.milliseconds());
         } else {
             batch =
                     new IndexedLogWriteBatch(
diff --git a/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java b/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
new file mode 100644
index 0000000000..aeb709b254
--- /dev/null
+++ b/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
@@ -0,0 +1,244 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.fluss.client.write;
+
+import org.apache.fluss.memory.MemorySegment;
+import org.apache.fluss.memory.PreAllocatedPagedOutputView;
+import org.apache.fluss.metadata.TableBucket;
+import org.apache.fluss.record.ChangeType;
+import org.apache.fluss.record.CompactedLogRecord;
+import org.apache.fluss.record.DefaultLogRecordBatch;
+import org.apache.fluss.record.LogRecord;
+import org.apache.fluss.record.LogRecordBatch;
+import org.apache.fluss.record.LogRecordReadContext;
+import org.apache.fluss.record.MemoryLogRecords;
+import org.apache.fluss.record.bytesview.BytesView;
+import org.apache.fluss.row.compacted.CompactedRow;
+import org.apache.fluss.utils.CloseableIterator;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import static org.apache.fluss.record.TestData.DATA1_PHYSICAL_TABLE_PATH;
+import static org.apache.fluss.record.TestData.DATA1_ROW_TYPE;
+import static org.apache.fluss.record.TestData.DATA1_TABLE_ID;
+import static org.apache.fluss.record.TestData.DATA1_TABLE_INFO;
+import static org.apache.fluss.testutils.DataTestUtils.compactedRow;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/** Test for {@link CompactedLogWriteBatch}. */
+public class CompactedLogWriteBatchTest {
+    private CompactedRow row;
+    private int estimatedSizeInBytes;
+
+    @BeforeEach
+    void setup() {
+        row = compactedRow(DATA1_ROW_TYPE, new Object[] {1, "a"});
+        estimatedSizeInBytes = CompactedLogRecord.sizeOf(row);
+    }
+
+    @Test
+    void testTryAppendWithWriteLimit() throws Exception {
+        int bucketId = 0;
+        int writeLimit = 100;
+        CompactedLogWriteBatch logProducerBatch =
+                createLogWriteBatch(
+                        new TableBucket(DATA1_TABLE_ID, bucketId),
+                        0L,
+                        writeLimit,
+                        MemorySegment.allocateHeapMemory(writeLimit));
+
+        for (int i = 0;
+                i
+                        < (writeLimit - DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE)
+                                / estimatedSizeInBytes;
+                i++) {
+            boolean appendResult =
+                    logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback());
+            assertThat(appendResult).isTrue();
+        }
+
+        // batch full.
+        boolean appendResult = logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback());
+        assertThat(appendResult).isFalse();
+    }
+
+    @Test
+    void testToBytes() throws Exception {
+        int bucketId = 0;
+        CompactedLogWriteBatch logProducerBatch =
+                createLogWriteBatch(new TableBucket(DATA1_TABLE_ID, bucketId), 0L);
+        boolean appendResult = logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback());
+        assertThat(appendResult).isTrue();
+
+        logProducerBatch.close();
+        BytesView bytesView = logProducerBatch.build();
+        MemoryLogRecords logRecords = MemoryLogRecords.pointToBytesView(bytesView);
+        Iterator<LogRecordBatch> iterator = logRecords.batches().iterator();
+        assertDefaultLogRecordBatchEquals(iterator.next());
+        assertThat(iterator.hasNext()).isFalse();
+    }
+
+    @Test
+    void testCompleteTwice() throws Exception {
+        int bucketId = 0;
+        CompactedLogWriteBatch logWriteBatch =
+                createLogWriteBatch(new TableBucket(DATA1_TABLE_ID, bucketId), 0L);
+        boolean appendResult = logWriteBatch.tryAppend(createWriteRecord(), newWriteCallback());
+        assertThat(appendResult).isTrue();
+
+        assertThat(logWriteBatch.complete()).isTrue();
+        assertThatThrownBy(logWriteBatch::complete)
+                .isInstanceOf(IllegalStateException.class)
+                .hasMessageContaining(
+                        "A SUCCEEDED batch must not attempt another state change to SUCCEEDED");
+    }
+
+    @Test
+    void testFailedTwice() throws Exception {
+        int bucketId = 0;
+        CompactedLogWriteBatch logWriteBatch =
+                createLogWriteBatch(new TableBucket(DATA1_TABLE_ID, bucketId), 0L);
+        boolean appendResult = logWriteBatch.tryAppend(createWriteRecord(), newWriteCallback());
+        assertThat(appendResult).isTrue();
+
+        assertThat(logWriteBatch.completeExceptionally(new IllegalStateException("test failed.")))
+                .isTrue();
+        // FAILED --> FAILED transitions are ignored.
+        assertThat(logWriteBatch.completeExceptionally(new IllegalStateException("test failed.")))
+                .isFalse();
+    }
+
+    @Test
+    void testClose() throws Exception {
+        int bucketId = 0;
+        CompactedLogWriteBatch logProducerBatch =
+                createLogWriteBatch(new TableBucket(DATA1_TABLE_ID, bucketId), 0L);
+        boolean appendResult = logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback());
+        assertThat(appendResult).isTrue();
+
+        logProducerBatch.close();
+        assertThat(logProducerBatch.isClosed()).isTrue();
+
+        appendResult = logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback());
+        assertThat(appendResult).isFalse();
+    }
+
+    @Test
+    void testBatchAborted() throws Exception {
+        int bucketId = 0;
+        int writeLimit = 10240;
+        CompactedLogWriteBatch logProducerBatch =
+                createLogWriteBatch(
+                        new TableBucket(DATA1_TABLE_ID, bucketId),
+                        0L,
+                        writeLimit,
+                        MemorySegment.allocateHeapMemory(writeLimit));
+
+        int recordCount = 5;
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        for (int i = 0; i < recordCount; i++) {
+            CompletableFuture<Void> future = new CompletableFuture<>();
+            logProducerBatch.tryAppend(
+                    createWriteRecord(),
+                    exception -> {
+                        if (exception != null) {
+                            future.completeExceptionally(exception);
+                        } else {
+                            future.complete(null);
+                        }
+                    });
+            futures.add(future);
+        }
+
+        logProducerBatch.abortRecordAppends();
+        logProducerBatch.abort(new RuntimeException("close with record batch abort"));
+
+        // first try to append.
+        assertThatThrownBy(
+                        () -> logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback()))
+                .isInstanceOf(IllegalStateException.class)
+                .hasMessageContaining(
+                        "Tried to append a record, but MemoryLogRecordsCompactedBuilder has already been aborted");
+
+        // try to build.
+        assertThatThrownBy(logProducerBatch::build)
+                .isInstanceOf(IllegalStateException.class)
+                .hasMessageContaining("Attempting to build an aborted record batch");
+
+        // verify record append future is completed with exception.
+        for (CompletableFuture<Void> future : futures) {
+            assertThatThrownBy(future::join)
+                    .rootCause()
+                    .isInstanceOf(RuntimeException.class)
+                    .hasMessageContaining("close with record batch abort");
+        }
+    }
+
+    private WriteRecord createWriteRecord() {
+        return WriteRecord.forCompactedAppend(DATA1_PHYSICAL_TABLE_PATH, row, null);
+    }
+
+    private CompactedLogWriteBatch createLogWriteBatch(TableBucket tb, long baseLogOffset)
+            throws Exception {
+        return createLogWriteBatch(
+                tb, baseLogOffset, Integer.MAX_VALUE, MemorySegment.allocateHeapMemory(1000));
+    }
+
+    private CompactedLogWriteBatch createLogWriteBatch(
+            TableBucket tb, long baseLogOffset, int writeLimit, MemorySegment memorySegment) {
+        return new CompactedLogWriteBatch(
+                tb.getBucket(),
+                DATA1_PHYSICAL_TABLE_PATH,
+                DATA1_TABLE_INFO.getSchemaId(),
+                writeLimit,
+                new PreAllocatedPagedOutputView(Collections.singletonList(memorySegment)),
+                System.currentTimeMillis());
+    }
+
+    private void assertDefaultLogRecordBatchEquals(LogRecordBatch recordBatch) {
+        assertThat(recordBatch.getRecordCount()).isEqualTo(1);
+        assertThat(recordBatch.baseLogOffset()).isEqualTo(0L);
+        assertThat(recordBatch.schemaId()).isEqualTo((short) DATA1_TABLE_INFO.getSchemaId());
+        try (LogRecordReadContext readContext =
+                        LogRecordReadContext.createCompactedRowReadContext(
+                                DATA1_ROW_TYPE, DATA1_TABLE_INFO.getSchemaId());
+                CloseableIterator<LogRecord> iterator = recordBatch.records(readContext)) {
+            assertThat(iterator.hasNext()).isTrue();
+            LogRecord record = iterator.next();
+            assertThat(record.getChangeType()).isEqualTo(ChangeType.APPEND_ONLY);
+            assertThat(record.getRow()).isEqualTo(row);
+            assertThat(iterator.hasNext()).isFalse();
+        }
+    }
+
+    private WriteCallback newWriteCallback() {
+        return exception -> {
+            if (exception != null) {
+                throw new RuntimeException(exception);
+            }
+        };
+    }
+}
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
index e23aa5cc3b..31d3e5ee8c 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
@@ -19,12 +19,33 @@
 
 import org.apache.fluss.annotation.VisibleForTesting;
 import org.apache.fluss.memory.AbstractPagedOutputView;
+import org.apache.fluss.annotation.VisibleForTesting;
+import org.apache.fluss.memory.AbstractPagedOutputView;
+import org.apache.fluss.memory.MemorySegment;
+import org.apache.fluss.memory.MemorySegmentOutputView;
 import org.apache.fluss.metadata.LogFormat;
 import org.apache.fluss.row.compacted.CompactedRow;
 
 import java.io.IOException;
 
 import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
+import org.apache.fluss.record.bytesview.BytesView;
+import org.apache.fluss.record.bytesview.MultiBytesView;
+import org.apache.fluss.row.compacted.CompactedRow;
+import org.apache.fluss.utils.crc.Crc32C;
+
+import java.io.IOException;
+
+import static org.apache.fluss.record.DefaultLogRecordBatch.BASE_OFFSET_LENGTH;
+import static org.apache.fluss.record.DefaultLogRecordBatch.CRC_OFFSET;
+import static org.apache.fluss.record.DefaultLogRecordBatch.LAST_OFFSET_DELTA_OFFSET;
+import static org.apache.fluss.record.DefaultLogRecordBatch.LENGTH_LENGTH;
+import static org.apache.fluss.record.DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE;
+import static org.apache.fluss.record.DefaultLogRecordBatch.SCHEMA_ID_OFFSET;
+import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
+import static org.apache.fluss.record.LogRecordBatch.NO_BATCH_SEQUENCE;
+import static org.apache.fluss.record.LogRecordBatch.NO_WRITER_ID;
+import static org.apache.fluss.utils.Preconditions.checkArgument;
 
 /**
  * Default builder for {@link MemoryLogRecords} of log records in {@link LogFormat#COMPACTED}
@@ -66,6 +87,155 @@ public static MemoryLogRecordsCompactedBuilder builder(
                 baseLogOffset, schemaId, writeLimit, magic, outputView, false);
     }
 
+public class MemoryLogRecordsCompactedBuilder implements AutoCloseable {
+    private static final int BUILDER_DEFAULT_OFFSET = 0;
+
+    private final long baseLogOffset;
+    private final int schemaId;
+    // The max bytes can be appended.
+    private final int writeLimit;
+    private final byte magic;
+    private final AbstractPagedOutputView pagedOutputView;
+    private final MemorySegment firstSegment;
+    private final boolean appendOnly;
+
+    private BytesView builtBuffer = null;
+    private long writerId;
+    private int batchSequence;
+    private int currentRecordNumber;
+    private int sizeInBytes;
+    private volatile boolean isClosed;
+    private boolean aborted = false;
+
+    private MemoryLogRecordsCompactedBuilder(
+            long baseLogOffset,
+            int schemaId,
+            int writeLimit,
+            byte magic,
+            AbstractPagedOutputView pagedOutputView,
+            boolean appendOnly) {
+        this.appendOnly = appendOnly;
+        checkArgument(
+                schemaId <= Short.MAX_VALUE,
+                "schemaId shouldn't be greater than the max value of short: " + Short.MAX_VALUE);
+        this.baseLogOffset = baseLogOffset;
+        this.schemaId = schemaId;
+        this.writeLimit = writeLimit;
+        this.magic = magic;
+        this.pagedOutputView = pagedOutputView;
+        this.firstSegment = pagedOutputView.getCurrentSegment();
+        this.writerId = NO_WRITER_ID;
+        this.batchSequence = NO_BATCH_SEQUENCE;
+        this.currentRecordNumber = 0;
+        this.isClosed = false;
+
+        // We don't need to write header information while the builder creating,
+        // we'll skip it first.
+        this.pagedOutputView.setPosition(RECORD_BATCH_HEADER_SIZE);
+        this.sizeInBytes = RECORD_BATCH_HEADER_SIZE;
+    }
+
+    public static MemoryLogRecordsCompactedBuilder builder(
+            int schemaId, int writeLimit, AbstractPagedOutputView outputView, boolean appendOnly) {
+        return new MemoryLogRecordsCompactedBuilder(
+                BUILDER_DEFAULT_OFFSET,
+                schemaId,
+                writeLimit,
+                CURRENT_LOG_MAGIC_VALUE,
+                outputView,
+                appendOnly);
+    }
+
+    @VisibleForTesting
+    public static MemoryLogRecordsCompactedBuilder builder(
+            long baseLogOffset,
+            int schemaId,
+            int writeLimit,
+            byte magic,
+            AbstractPagedOutputView outputView)
+            throws IOException {
+        return new MemoryLogRecordsCompactedBuilder(
+                baseLogOffset, schemaId, writeLimit, magic, outputView, false);
+    }
+
+    /**
+     * Check if we have room for a new record containing the given row. If no records have been
+     * appended, then this returns true.
+     */
+    public boolean hasRoomFor(CompactedRow row) {
+        return sizeInBytes + CompactedLogRecord.sizeOf(row) <= writeLimit;
+    }
+
+    public void append(ChangeType changeType, CompactedRow row) throws Exception {
+        appendRecord(changeType, row);
+    }
+
+    private void appendRecord(ChangeType changeType, CompactedRow row) throws IOException {
+        if (aborted) {
+            throw new IllegalStateException(
+                    "Tried to append a record, but MemoryLogRecordsCompactedBuilder has already been aborted");
+        }
+
+        if (isClosed) {
+            throw new IllegalStateException(
+                    "Tried to append a record, but MemoryLogRecordsBuilder is closed for record appends");
+        }
+        if (appendOnly && changeType != ChangeType.APPEND_ONLY) {
+            throw new IllegalArgumentException(
+                    "Only append-only change type is allowed for append-only arrow log builder, but got "
+                            + changeType);
+        }
+
+        int recordByteSizes = CompactedLogRecord.writeTo(pagedOutputView, changeType, row);
+        currentRecordNumber++;
+        sizeInBytes += recordByteSizes;
+    }
+
+    public BytesView build() throws IOException {
+        if (aborted) {
+            throw new IllegalStateException("Attempting to build an aborted record batch");
+        }
+
+        if (builtBuffer != null) {
+            return builtBuffer;
+        }
+
+        writeBatchHeader();
+        builtBuffer =
+                MultiBytesView.builder()
+                        .addMemorySegmentByteViewList(pagedOutputView.getWrittenSegments())
+                        .build();
+        return builtBuffer;
+    }
+
+    public void setWriterState(long writerId, int batchBaseSequence) {
+        this.writerId = writerId;
+        this.batchSequence = batchBaseSequence;
+    }
+
+    public void resetWriterState(long writerId, int batchSequence) {
+        // trigger to rewrite batch header
+        this.builtBuffer = null;
+        this.writerId = writerId;
+        this.batchSequence = batchSequence;
+    }
+
+    public long writerId() {
+        return writerId;
+    }
+
+    public int batchSequence() {
+        return batchSequence;
+    }
+
+    public boolean isClosed() {
+        return isClosed;
+    }
+
+    public void abort() {
+        aborted = true;
+    }
+
     @Override
     protected int sizeOf(CompactedRow row) {
         return CompactedLogRecord.sizeOf(row);
@@ -75,4 +245,54 @@ protected int sizeOf(CompactedRow row) {
     protected int writeRecord(ChangeType changeType, CompactedRow row) throws IOException {
         return CompactedLogRecord.writeTo(pagedOutputView, changeType, row);
     }
+    public void close() throws IOException {
+        if (aborted) {
+            throw new IllegalStateException(
+                    "Cannot close MemoryLogRecordsCompactedBuilder as it has already been aborted");
+        }
+
+        isClosed = true;
+    }
+
+    public int getSizeInBytes() {
+        return sizeInBytes;
+    }
+
+    // ----------------------- internal methods -------------------------------
+    private void writeBatchHeader() throws IOException {
+        // pagedOutputView doesn't support seek to previous segment,
+        // so we create a new output view on the first segment
+        MemorySegmentOutputView outputView = new MemorySegmentOutputView(firstSegment);
+        outputView.setPosition(0);
+        // update header.
+        outputView.writeLong(baseLogOffset);
+        outputView.writeInt(sizeInBytes - BASE_OFFSET_LENGTH - LENGTH_LENGTH);
+        outputView.writeByte(magic);
+
+        // write empty timestamp which will be overridden on server side
+        outputView.writeLong(0);
+        // write empty crc first.
+        outputView.writeUnsignedInt(0);
+
+        outputView.writeShort((short) schemaId);
+        // write attributes (currently only appendOnly flag)
+        outputView.writeBoolean(appendOnly);
+        // skip write attribute byte for now.
+        outputView.setPosition(LAST_OFFSET_DELTA_OFFSET);
+        if (currentRecordNumber > 0) {
+            outputView.writeInt(currentRecordNumber - 1);
+        } else {
+            // If there is no record, we write 0 for filed lastOffsetDelta, see the comments about
+            // the field 'lastOffsetDelta' in DefaultLogRecordBatch.
+            outputView.writeInt(0);
+        }
+        outputView.writeLong(writerId);
+        outputView.writeInt(batchSequence);
+        outputView.writeInt(currentRecordNumber);
+
+        // Update crc.
+        long crc = Crc32C.compute(pagedOutputView.getWrittenSegments(), SCHEMA_ID_OFFSET);
+        outputView.setPosition(CRC_OFFSET);
+        outputView.writeUnsignedInt(crc);
+    }
 }
diff --git a/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java b/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java
index 2a8d70c800..95048cd9a6 100644
--- a/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java
+++ b/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java
@@ -39,7 +39,7 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 /** Tests for {@link MemoryLogRecordsCompactedBuilder}. */
-class MemoryLogRecordsCompactedBuilderTest {
+public class MemoryLogRecordsCompactedBuilderTest {
 
     @Test
     void testAppendAndBuild() throws Exception {
@@ -113,43 +113,37 @@ void testAbortSemantics() throws Exception {
     @Test
     void testNoRecordAppendAndBaseOffset() throws Exception {
         // base offset 0
-        try (MemoryLogRecordsCompactedBuilder builder = createBuilder(0, 1, 1024)) {
-            MemoryLogRecords records = MemoryLogRecords.pointToBytesView(builder.build());
-            assertThat(records.sizeInBytes())
-                    .isEqualTo(
-                            LogRecordBatchFormat.recordBatchHeaderSize(
-                                    DEFAULT_MAGIC)); // only batch header
-            LogRecordBatch batch = records.batches().iterator().next();
-            batch.ensureValid();
-            assertThat(batch.getRecordCount()).isEqualTo(0);
-            assertThat(batch.baseLogOffset()).isEqualTo(0);
-            assertThat(batch.lastLogOffset()).isEqualTo(0);
-            assertThat(batch.nextLogOffset()).isEqualTo(1);
-            try (LogRecordReadContext ctx =
-                            LogRecordReadContext.createCompactedRowReadContext(
-                                    DATA1_ROW_TYPE, DEFAULT_SCHEMA_ID);
-                    CloseableIterator<LogRecord> it = batch.records(ctx)) {
-                assertThat(it.hasNext()).isFalse();
-            }
+        MemoryLogRecordsCompactedBuilder builder = createBuilder(0, 1, 1024);
+        MemoryLogRecords records = MemoryLogRecords.pointToBytesView(builder.build());
+        assertThat(records.sizeInBytes()).isEqualTo(48); // only batch header
+        LogRecordBatch batch = records.batches().iterator().next();
+        batch.ensureValid();
+        assertThat(batch.getRecordCount()).isEqualTo(0);
+        assertThat(batch.baseLogOffset()).isEqualTo(0);
+        assertThat(batch.lastLogOffset()).isEqualTo(0);
+        assertThat(batch.nextLogOffset()).isEqualTo(1);
+        try (LogRecordReadContext ctx =
+                        LogRecordReadContext.createCompactedRowReadContext(
+                                DATA1_ROW_TYPE, DEFAULT_SCHEMA_ID);
+                CloseableIterator<LogRecord> it = batch.records(ctx)) {
+            assertThat(it.hasNext()).isFalse();
         }
 
         // base offset 100
-        try (MemoryLogRecordsCompactedBuilder builder = createBuilder(100, 1, 1024)) {
-            MemoryLogRecords records = MemoryLogRecords.pointToBytesView(builder.build());
-            assertThat(records.sizeInBytes())
-                    .isEqualTo(LogRecordBatchFormat.recordBatchHeaderSize(DEFAULT_MAGIC));
-            LogRecordBatch batch = records.batches().iterator().next();
-            batch.ensureValid();
-            assertThat(batch.getRecordCount()).isEqualTo(0);
-            assertThat(batch.baseLogOffset()).isEqualTo(100);
-            assertThat(batch.lastLogOffset()).isEqualTo(100);
-            assertThat(batch.nextLogOffset()).isEqualTo(101);
-            try (LogRecordReadContext ctx =
-                            LogRecordReadContext.createCompactedRowReadContext(
-                                    DATA1_ROW_TYPE, DEFAULT_SCHEMA_ID);
-                    CloseableIterator<LogRecord> it = batch.records(ctx)) {
-                assertThat(it.hasNext()).isFalse();
-            }
+        builder = createBuilder(100, 1, 1024);
+        records = MemoryLogRecords.pointToBytesView(builder.build());
+        assertThat(records.sizeInBytes()).isEqualTo(48);
+        batch = records.batches().iterator().next();
+        batch.ensureValid();
+        assertThat(batch.getRecordCount()).isEqualTo(0);
+        assertThat(batch.baseLogOffset()).isEqualTo(100);
+        assertThat(batch.lastLogOffset()).isEqualTo(100);
+        assertThat(batch.nextLogOffset()).isEqualTo(101);
+        try (LogRecordReadContext ctx =
+                        LogRecordReadContext.createCompactedRowReadContext(
+                                DATA1_ROW_TYPE, DEFAULT_SCHEMA_ID);
+                CloseableIterator<LogRecord> it = batch.records(ctx)) {
+            assertThat(it.hasNext()).isFalse();
         }
     }
 

From e6d456780e11c98f986adb7320da1092ad29938d Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 16:39:51 +0300
Subject: [PATCH 10/27] refactor to minimize duplicate code between indexed and
 compactedrow classes

# Conflicts:
#	fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
---
 .../write/AbstractRowLogWriteBatch.java       | 159 +++++++++++++
 .../client/write/CompactedLogWriteBatch.java  | 146 ++++++------
 .../client/write/IndexedLogWriteBatch.java    | 125 +++++-----
 .../AbstractRowMemoryLogRecordsBuilder.java   |  30 ++-
 .../MemoryLogRecordsCompactedBuilder.java     | 221 +-----------------
 .../MemoryLogRecordsIndexedBuilder.java       |   8 +-
 6 files changed, 325 insertions(+), 364 deletions(-)
 create mode 100644 fluss-client/src/main/java/org/apache/fluss/client/write/AbstractRowLogWriteBatch.java

diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/AbstractRowLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/AbstractRowLogWriteBatch.java
new file mode 100644
index 0000000000..ddb345a63b
--- /dev/null
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/AbstractRowLogWriteBatch.java
@@ -0,0 +1,159 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.fluss.client.write;
+
+import org.apache.fluss.exception.FlussRuntimeException;
+import org.apache.fluss.memory.AbstractPagedOutputView;
+import org.apache.fluss.memory.MemorySegment;
+import org.apache.fluss.metadata.PhysicalTablePath;
+import org.apache.fluss.record.ChangeType;
+import org.apache.fluss.record.bytesview.BytesView;
+import org.apache.fluss.row.InternalRow;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.apache.fluss.utils.Preconditions.checkArgument;
+import static org.apache.fluss.utils.Preconditions.checkNotNull;
+
+/**
+ * Abstract base class to deduplicate logic for row-based log write batches backed by in-memory
+ * builders. Concrete subclasses only need to provide a row-type validator/caster and a
+ * RecordsBuilderAdapter implementation.
+ */
+abstract class AbstractRowLogWriteBatch<R> extends WriteBatch {
+
+    interface RecordsBuilderAdapter<T> {
+        boolean hasRoomFor(T row);
+
+        void append(ChangeType changeType, T row) throws Exception;
+
+        BytesView build() throws IOException;
+
+        boolean isClosed();
+
+        void close() throws Exception;
+
+        void setWriterState(long writerId, int batchSequence);
+
+        long writerId();
+
+        int batchSequence();
+
+        void abort();
+
+        void resetWriterState(long writerId, int batchSequence);
+
+        int getSizeInBytes();
+    }
+
+    private final AbstractPagedOutputView outputView;
+    private final RecordsBuilderAdapter<R> builder;
+    private final String buildErrorMessage;
+
+    protected AbstractRowLogWriteBatch(
+            int bucketId,
+            PhysicalTablePath physicalTablePath,
+            long createdMs,
+            AbstractPagedOutputView outputView,
+            RecordsBuilderAdapter<R> builder,
+            String buildErrorMessage) {
+        super(bucketId, physicalTablePath, createdMs);
+        this.outputView = outputView;
+        this.builder = builder;
+        this.buildErrorMessage = buildErrorMessage;
+    }
+
+    @Override
+    public boolean tryAppend(WriteRecord writeRecord, WriteCallback callback) throws Exception {
+        checkNotNull(callback, "write callback must be not null");
+        InternalRow rowObj = writeRecord.getRow();
+        checkNotNull(rowObj, "row must not be null for log record");
+        checkArgument(writeRecord.getKey() == null, "key must be null for log record");
+        checkArgument(
+                writeRecord.getTargetColumns() == null,
+                "target columns must be null for log record");
+
+        R row = requireAndCastRow(rowObj);
+        if (!builder.hasRoomFor(row) || isClosed()) {
+            return false;
+        }
+        builder.append(ChangeType.APPEND_ONLY, row);
+        recordCount++;
+        callbacks.add(callback);
+        return true;
+    }
+
+    protected abstract R requireAndCastRow(InternalRow row);
+
+    @Override
+    public BytesView build() {
+        try {
+            return builder.build();
+        } catch (IOException e) {
+            throw new FlussRuntimeException(buildErrorMessage, e);
+        }
+    }
+
+    @Override
+    public boolean isClosed() {
+        return builder.isClosed();
+    }
+
+    @Override
+    public void close() throws Exception {
+        builder.close();
+        reopened = false;
+    }
+
+    @Override
+    public List<MemorySegment> pooledMemorySegments() {
+        return outputView.allocatedPooledSegments();
+    }
+
+    @Override
+    public void setWriterState(long writerId, int batchSequence) {
+        builder.setWriterState(writerId, batchSequence);
+    }
+
+    @Override
+    public long writerId() {
+        return builder.writerId();
+    }
+
+    @Override
+    public int batchSequence() {
+        return builder.batchSequence();
+    }
+
+    @Override
+    public void abortRecordAppends() {
+        builder.abort();
+    }
+
+    @Override
+    public void resetWriterState(long writerId, int batchSequence) {
+        super.resetWriterState(writerId, batchSequence);
+        builder.resetWriterState(writerId, batchSequence);
+    }
+
+    @Override
+    public int estimatedSizeInBytes() {
+        return builder.getSizeInBytes();
+    }
+}
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
index 3289afc71d..a1a402e8c8 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
@@ -18,7 +18,6 @@
 package org.apache.fluss.client.write;
 
 import org.apache.fluss.annotation.Internal;
-import org.apache.fluss.exception.FlussRuntimeException;
 import org.apache.fluss.memory.AbstractPagedOutputView;
 import org.apache.fluss.memory.MemorySegment;
 import org.apache.fluss.metadata.PhysicalTablePath;
@@ -34,7 +33,6 @@
 import java.util.List;
 
 import static org.apache.fluss.utils.Preconditions.checkArgument;
-import static org.apache.fluss.utils.Preconditions.checkNotNull;
 
 /**
  * A batch of log records managed in COMPACTED format that is or will be sent to server by {@link
@@ -44,9 +42,8 @@
  */
 @NotThreadSafe
 @Internal
-public final class CompactedLogWriteBatch extends WriteBatch {
+public final class CompactedLogWriteBatch extends AbstractRowLogWriteBatch<CompactedRow> {
     private final AbstractPagedOutputView outputView;
-    private final MemoryLogRecordsCompactedBuilder recordsBuilder;
 
     public CompactedLogWriteBatch(
             int bucketId,
@@ -55,87 +52,84 @@ public CompactedLogWriteBatch(
             int writeLimit,
             AbstractPagedOutputView outputView,
             long createdMs) {
-        super(bucketId, physicalTablePath, createdMs);
+        super(
+                bucketId,
+                physicalTablePath,
+                createdMs,
+                outputView,
+                new RecordsBuilderAdapter<CompactedRow>() {
+                    private final MemoryLogRecordsCompactedBuilder delegate =
+                            MemoryLogRecordsCompactedBuilder.builder(
+                                    schemaId, writeLimit, outputView, true);
+
+                    @Override
+                    public boolean hasRoomFor(CompactedRow row) {
+                        return delegate.hasRoomFor(row);
+                    }
+
+                    @Override
+                    public void append(ChangeType changeType, CompactedRow row) throws Exception {
+                        delegate.append(changeType, row);
+                    }
+
+                    @Override
+                    public BytesView build() throws IOException {
+                        return delegate.build();
+                    }
+
+                    @Override
+                    public boolean isClosed() {
+                        return delegate.isClosed();
+                    }
+
+                    @Override
+                    public void close() throws Exception {
+                        delegate.close();
+                    }
+
+                    @Override
+                    public void setWriterState(long writerId, int batchSequence) {
+                        delegate.setWriterState(writerId, batchSequence);
+                    }
+
+                    @Override
+                    public long writerId() {
+                        return delegate.writerId();
+                    }
+
+                    @Override
+                    public int batchSequence() {
+                        return delegate.batchSequence();
+                    }
+
+                    @Override
+                    public void abort() {
+                        delegate.abort();
+                    }
+
+                    @Override
+                    public void resetWriterState(long writerId, int batchSequence) {
+                        delegate.resetWriterState(writerId, batchSequence);
+                    }
+
+                    @Override
+                    public int getSizeInBytes() {
+                        return delegate.getSizeInBytes();
+                    }
+                },
+                "Failed to build compacted log record batch.");
         this.outputView = outputView;
-        this.recordsBuilder =
-                MemoryLogRecordsCompactedBuilder.builder(schemaId, writeLimit, outputView, true);
     }
 
     @Override
-    public boolean tryAppend(WriteRecord writeRecord, WriteCallback callback) throws Exception {
-        checkNotNull(callback, "write callback must be not null");
-        checkNotNull(writeRecord.getRow(), "row must not be null for log record");
-        checkArgument(writeRecord.getKey() == null, "key must be null for log record");
+    protected CompactedRow requireAndCastRow(org.apache.fluss.row.InternalRow row) {
         checkArgument(
-                writeRecord.getTargetColumns() == null,
-                "target columns must be null for log record");
-        checkArgument(
-                writeRecord.getRow() instanceof CompactedRow,
-                "row must be CompactedRow for compacted log table");
-        CompactedRow row = (CompactedRow) writeRecord.getRow();
-        if (!recordsBuilder.hasRoomFor(row) || isClosed()) {
-            return false;
-        } else {
-            recordsBuilder.append(ChangeType.APPEND_ONLY, row);
-            recordCount++;
-            callbacks.add(callback);
-            return true;
-        }
-    }
-
-    @Override
-    public BytesView build() {
-        try {
-            return recordsBuilder.build();
-        } catch (IOException e) {
-            throw new FlussRuntimeException("Failed to build compacted log record batch.", e);
-        }
-    }
-
-    @Override
-    public boolean isClosed() {
-        return recordsBuilder.isClosed();
-    }
-
-    @Override
-    public void close() throws Exception {
-        recordsBuilder.close();
-        reopened = false;
+                row instanceof CompactedRow, "row must be CompactedRow for compacted log table");
+        return (CompactedRow) row;
     }
 
     @Override
     public List<MemorySegment> pooledMemorySegments() {
         return outputView.allocatedPooledSegments();
     }
-
-    @Override
-    public void setWriterState(long writerId, int batchSequence) {
-        recordsBuilder.setWriterState(writerId, batchSequence);
-    }
-
-    @Override
-    public long writerId() {
-        return recordsBuilder.writerId();
-    }
-
-    @Override
-    public int batchSequence() {
-        return recordsBuilder.batchSequence();
-    }
-
-    @Override
-    public void abortRecordAppends() {
-        recordsBuilder.abort();
-    }
-
-    @Override
-    public void resetWriterState(long writerId, int batchSequence) {
-        super.resetWriterState(writerId, batchSequence);
-        recordsBuilder.resetWriterState(writerId, batchSequence);
-    }
-
-    @Override
-    public int estimatedSizeInBytes() {
-        return recordsBuilder.getSizeInBytes();
-    }
 }
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
index fb96556588..449923affd 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
@@ -18,7 +18,6 @@
 package org.apache.fluss.client.write;
 
 import org.apache.fluss.annotation.Internal;
-import org.apache.fluss.exception.FlussRuntimeException;
 import org.apache.fluss.memory.AbstractPagedOutputView;
 import org.apache.fluss.memory.MemorySegment;
 import org.apache.fluss.metadata.PhysicalTablePath;
@@ -34,7 +33,6 @@
 import java.util.List;
 
 import static org.apache.fluss.utils.Preconditions.checkArgument;
-import static org.apache.fluss.utils.Preconditions.checkNotNull;
 
 /**
  * A batch of log records managed in INDEXED format that is or will be sent to server by {@link
@@ -44,9 +42,8 @@
  */
 @NotThreadSafe
 @Internal
-public final class IndexedLogWriteBatch extends WriteBatch {
+public final class IndexedLogWriteBatch extends AbstractRowLogWriteBatch<IndexedRow> {
     private final AbstractPagedOutputView outputView;
-    private final MemoryLogRecordsIndexedBuilder recordsBuilder;
 
     public IndexedLogWriteBatch(
             int bucketId,
@@ -55,11 +52,15 @@ public IndexedLogWriteBatch(
             int writeLimit,
             AbstractPagedOutputView outputView,
             long createdMs) {
-        super(bucketId, physicalTablePath, createdMs);
-        this.outputView = outputView;
-        this.recordsBuilder =
-                MemoryLogRecordsIndexedBuilder.builder(schemaId, writeLimit, outputView, true);
-    }
+        super(
+                bucketId,
+                physicalTablePath,
+                createdMs,
+                outputView,
+                new RecordsBuilderAdapter<IndexedRow>() {
+                    private final MemoryLogRecordsIndexedBuilder delegate =
+                            MemoryLogRecordsIndexedBuilder.builder(
+                                    schemaId, writeLimit, outputView, true);
 
     @Override
     public boolean isLogBatch() {
@@ -87,59 +88,73 @@ public boolean tryAppend(WriteRecord writeRecord, WriteCallback callback) throws
             return true;
         }
     }
-
-    @Override
-    public BytesView build() {
-        try {
-            return recordsBuilder.build();
-        } catch (IOException e) {
-            throw new FlussRuntimeException("Failed to build indexed log record batch.", e);
-        }
-    }
-
-    @Override
-    public boolean isClosed() {
-        return recordsBuilder.isClosed();
+                    @Override
+                    public boolean hasRoomFor(IndexedRow row) {
+                        return delegate.hasRoomFor(row);
+                    }
+
+                    @Override
+                    public void append(ChangeType changeType, IndexedRow row) throws Exception {
+                        delegate.append(changeType, row);
+                    }
+
+                    @Override
+                    public BytesView build() throws IOException {
+                        return delegate.build();
+                    }
+
+                    @Override
+                    public boolean isClosed() {
+                        return delegate.isClosed();
+                    }
+
+                    @Override
+                    public void close() throws Exception {
+                        delegate.close();
+                    }
+
+                    @Override
+                    public void setWriterState(long writerId, int batchSequence) {
+                        delegate.setWriterState(writerId, batchSequence);
+                    }
+
+                    @Override
+                    public long writerId() {
+                        return delegate.writerId();
+                    }
+
+                    @Override
+                    public int batchSequence() {
+                        return delegate.batchSequence();
+                    }
+
+                    @Override
+                    public void abort() {
+                        delegate.abort();
+                    }
+
+                    @Override
+                    public void resetWriterState(long writerId, int batchSequence) {
+                        delegate.resetWriterState(writerId, batchSequence);
+                    }
+
+                    @Override
+                    public int getSizeInBytes() {
+                        return delegate.getSizeInBytes();
+                    }
+                },
+                "Failed to build indexed log record batch.");
+        this.outputView = outputView;
     }
 
     @Override
-    public void close() throws Exception {
-        recordsBuilder.close();
-        reopened = false;
+    protected IndexedRow requireAndCastRow(org.apache.fluss.row.InternalRow row) {
+        checkArgument(row instanceof IndexedRow, "row must be IndexRow for indexed log table");
+        return (IndexedRow) row;
     }
 
     @Override
     public List<MemorySegment> pooledMemorySegments() {
         return outputView.allocatedPooledSegments();
     }
-
-    @Override
-    public void setWriterState(long writerId, int batchSequence) {
-        recordsBuilder.setWriterState(writerId, batchSequence);
-    }
-
-    @Override
-    public long writerId() {
-        return recordsBuilder.writerId();
-    }
-
-    @Override
-    public int batchSequence() {
-        return recordsBuilder.batchSequence();
-    }
-
-    @Override
-    public void abortRecordAppends() {
-        recordsBuilder.abort();
-    }
-
-    public void resetWriterState(long writerId, int batchSequence) {
-        super.resetWriterState(writerId, batchSequence);
-        recordsBuilder.resetWriterState(writerId, batchSequence);
-    }
-
-    @Override
-    public int estimatedSizeInBytes() {
-        return recordsBuilder.getSizeInBytes();
-    }
 }
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java
index 423b35a3b9..c166156129 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java
@@ -26,16 +26,15 @@
 
 import java.io.IOException;
 
-import static org.apache.fluss.record.LogRecordBatchFormat.BASE_OFFSET_LENGTH;
-import static org.apache.fluss.record.LogRecordBatchFormat.LENGTH_LENGTH;
-import static org.apache.fluss.record.LogRecordBatchFormat.LOG_MAGIC_VALUE_V1;
-import static org.apache.fluss.record.LogRecordBatchFormat.NO_BATCH_SEQUENCE;
-import static org.apache.fluss.record.LogRecordBatchFormat.NO_LEADER_EPOCH;
-import static org.apache.fluss.record.LogRecordBatchFormat.NO_WRITER_ID;
-import static org.apache.fluss.record.LogRecordBatchFormat.crcOffset;
-import static org.apache.fluss.record.LogRecordBatchFormat.lastOffsetDeltaOffset;
-import static org.apache.fluss.record.LogRecordBatchFormat.recordBatchHeaderSize;
-import static org.apache.fluss.record.LogRecordBatchFormat.schemaIdOffset;
+import static org.apache.fluss.record.DefaultLogRecordBatch.BASE_OFFSET_LENGTH;
+import static org.apache.fluss.record.DefaultLogRecordBatch.CRC_OFFSET;
+import static org.apache.fluss.record.DefaultLogRecordBatch.LAST_OFFSET_DELTA_OFFSET;
+import static org.apache.fluss.record.DefaultLogRecordBatch.LENGTH_LENGTH;
+import static org.apache.fluss.record.DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE;
+import static org.apache.fluss.record.DefaultLogRecordBatch.SCHEMA_ID_OFFSET;
+import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
+import static org.apache.fluss.record.LogRecordBatch.NO_BATCH_SEQUENCE;
+import static org.apache.fluss.record.LogRecordBatch.NO_WRITER_ID;
 import static org.apache.fluss.utils.Preconditions.checkArgument;
 
 /** Abstract base builder for row-based MemoryLogRecords builders sharing common logic. */
@@ -87,6 +86,17 @@ protected AbstractRowMemoryLogRecordsBuilder(
         this.sizeInBytes = headerSize;
     }
 
+    protected AbstractRowMemoryLogRecordsBuilder(
+            int schemaId, int writeLimit, AbstractPagedOutputView outputView, boolean appendOnly) {
+        this(
+                BUILDER_DEFAULT_OFFSET,
+                schemaId,
+                writeLimit,
+                CURRENT_LOG_MAGIC_VALUE,
+                outputView,
+                appendOnly);
+    }
+
     /** Implement to return size of the record (including length field). */
     protected abstract int sizeOf(T row);
 
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
index 31d3e5ee8c..1a6924a142 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
@@ -32,24 +32,15 @@
 import org.apache.fluss.record.bytesview.BytesView;
 import org.apache.fluss.record.bytesview.MultiBytesView;
 import org.apache.fluss.row.compacted.CompactedRow;
-import org.apache.fluss.utils.crc.Crc32C;
 
 import java.io.IOException;
 
-import static org.apache.fluss.record.DefaultLogRecordBatch.BASE_OFFSET_LENGTH;
-import static org.apache.fluss.record.DefaultLogRecordBatch.CRC_OFFSET;
-import static org.apache.fluss.record.DefaultLogRecordBatch.LAST_OFFSET_DELTA_OFFSET;
-import static org.apache.fluss.record.DefaultLogRecordBatch.LENGTH_LENGTH;
-import static org.apache.fluss.record.DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE;
-import static org.apache.fluss.record.DefaultLogRecordBatch.SCHEMA_ID_OFFSET;
 import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
-import static org.apache.fluss.record.LogRecordBatch.NO_BATCH_SEQUENCE;
-import static org.apache.fluss.record.LogRecordBatch.NO_WRITER_ID;
-import static org.apache.fluss.utils.Preconditions.checkArgument;
+import static org.apache.fluss.record.LogRecordBatch.LOG_MAGIC_VALUE_V0;
 
 /**
- * Default builder for {@link MemoryLogRecords} of log records in {@link LogFormat#COMPACTED}
- * format.
+ * Default builder for {@link MemoryLogRecords} of log records in {@link
+ * org.apache.fluss.metadata.LogFormat#COMPACTED} format.
  */
 public class MemoryLogRecordsCompactedBuilder
         extends AbstractRowMemoryLogRecordsBuilder<CompactedRow> {
@@ -67,12 +58,7 @@ private MemoryLogRecordsCompactedBuilder(
     public static MemoryLogRecordsCompactedBuilder builder(
             int schemaId, int writeLimit, AbstractPagedOutputView outputView, boolean appendOnly) {
         return new MemoryLogRecordsCompactedBuilder(
-                BUILDER_DEFAULT_OFFSET,
-                schemaId,
-                writeLimit,
-                CURRENT_LOG_MAGIC_VALUE,
-                outputView,
-                appendOnly);
+                LOG_MAGIC_VALUE_V0, schemaId, writeLimit, CURRENT_LOG_MAGIC_VALUE, outputView, appendOnly);
     }
 
     @VisibleForTesting
@@ -87,155 +73,6 @@ public static MemoryLogRecordsCompactedBuilder builder(
                 baseLogOffset, schemaId, writeLimit, magic, outputView, false);
     }
 
-public class MemoryLogRecordsCompactedBuilder implements AutoCloseable {
-    private static final int BUILDER_DEFAULT_OFFSET = 0;
-
-    private final long baseLogOffset;
-    private final int schemaId;
-    // The max bytes can be appended.
-    private final int writeLimit;
-    private final byte magic;
-    private final AbstractPagedOutputView pagedOutputView;
-    private final MemorySegment firstSegment;
-    private final boolean appendOnly;
-
-    private BytesView builtBuffer = null;
-    private long writerId;
-    private int batchSequence;
-    private int currentRecordNumber;
-    private int sizeInBytes;
-    private volatile boolean isClosed;
-    private boolean aborted = false;
-
-    private MemoryLogRecordsCompactedBuilder(
-            long baseLogOffset,
-            int schemaId,
-            int writeLimit,
-            byte magic,
-            AbstractPagedOutputView pagedOutputView,
-            boolean appendOnly) {
-        this.appendOnly = appendOnly;
-        checkArgument(
-                schemaId <= Short.MAX_VALUE,
-                "schemaId shouldn't be greater than the max value of short: " + Short.MAX_VALUE);
-        this.baseLogOffset = baseLogOffset;
-        this.schemaId = schemaId;
-        this.writeLimit = writeLimit;
-        this.magic = magic;
-        this.pagedOutputView = pagedOutputView;
-        this.firstSegment = pagedOutputView.getCurrentSegment();
-        this.writerId = NO_WRITER_ID;
-        this.batchSequence = NO_BATCH_SEQUENCE;
-        this.currentRecordNumber = 0;
-        this.isClosed = false;
-
-        // We don't need to write header information while the builder creating,
-        // we'll skip it first.
-        this.pagedOutputView.setPosition(RECORD_BATCH_HEADER_SIZE);
-        this.sizeInBytes = RECORD_BATCH_HEADER_SIZE;
-    }
-
-    public static MemoryLogRecordsCompactedBuilder builder(
-            int schemaId, int writeLimit, AbstractPagedOutputView outputView, boolean appendOnly) {
-        return new MemoryLogRecordsCompactedBuilder(
-                BUILDER_DEFAULT_OFFSET,
-                schemaId,
-                writeLimit,
-                CURRENT_LOG_MAGIC_VALUE,
-                outputView,
-                appendOnly);
-    }
-
-    @VisibleForTesting
-    public static MemoryLogRecordsCompactedBuilder builder(
-            long baseLogOffset,
-            int schemaId,
-            int writeLimit,
-            byte magic,
-            AbstractPagedOutputView outputView)
-            throws IOException {
-        return new MemoryLogRecordsCompactedBuilder(
-                baseLogOffset, schemaId, writeLimit, magic, outputView, false);
-    }
-
-    /**
-     * Check if we have room for a new record containing the given row. If no records have been
-     * appended, then this returns true.
-     */
-    public boolean hasRoomFor(CompactedRow row) {
-        return sizeInBytes + CompactedLogRecord.sizeOf(row) <= writeLimit;
-    }
-
-    public void append(ChangeType changeType, CompactedRow row) throws Exception {
-        appendRecord(changeType, row);
-    }
-
-    private void appendRecord(ChangeType changeType, CompactedRow row) throws IOException {
-        if (aborted) {
-            throw new IllegalStateException(
-                    "Tried to append a record, but MemoryLogRecordsCompactedBuilder has already been aborted");
-        }
-
-        if (isClosed) {
-            throw new IllegalStateException(
-                    "Tried to append a record, but MemoryLogRecordsBuilder is closed for record appends");
-        }
-        if (appendOnly && changeType != ChangeType.APPEND_ONLY) {
-            throw new IllegalArgumentException(
-                    "Only append-only change type is allowed for append-only arrow log builder, but got "
-                            + changeType);
-        }
-
-        int recordByteSizes = CompactedLogRecord.writeTo(pagedOutputView, changeType, row);
-        currentRecordNumber++;
-        sizeInBytes += recordByteSizes;
-    }
-
-    public BytesView build() throws IOException {
-        if (aborted) {
-            throw new IllegalStateException("Attempting to build an aborted record batch");
-        }
-
-        if (builtBuffer != null) {
-            return builtBuffer;
-        }
-
-        writeBatchHeader();
-        builtBuffer =
-                MultiBytesView.builder()
-                        .addMemorySegmentByteViewList(pagedOutputView.getWrittenSegments())
-                        .build();
-        return builtBuffer;
-    }
-
-    public void setWriterState(long writerId, int batchBaseSequence) {
-        this.writerId = writerId;
-        this.batchSequence = batchBaseSequence;
-    }
-
-    public void resetWriterState(long writerId, int batchSequence) {
-        // trigger to rewrite batch header
-        this.builtBuffer = null;
-        this.writerId = writerId;
-        this.batchSequence = batchSequence;
-    }
-
-    public long writerId() {
-        return writerId;
-    }
-
-    public int batchSequence() {
-        return batchSequence;
-    }
-
-    public boolean isClosed() {
-        return isClosed;
-    }
-
-    public void abort() {
-        aborted = true;
-    }
-
     @Override
     protected int sizeOf(CompactedRow row) {
         return CompactedLogRecord.sizeOf(row);
@@ -245,54 +82,4 @@ protected int sizeOf(CompactedRow row) {
     protected int writeRecord(ChangeType changeType, CompactedRow row) throws IOException {
         return CompactedLogRecord.writeTo(pagedOutputView, changeType, row);
     }
-    public void close() throws IOException {
-        if (aborted) {
-            throw new IllegalStateException(
-                    "Cannot close MemoryLogRecordsCompactedBuilder as it has already been aborted");
-        }
-
-        isClosed = true;
-    }
-
-    public int getSizeInBytes() {
-        return sizeInBytes;
-    }
-
-    // ----------------------- internal methods -------------------------------
-    private void writeBatchHeader() throws IOException {
-        // pagedOutputView doesn't support seek to previous segment,
-        // so we create a new output view on the first segment
-        MemorySegmentOutputView outputView = new MemorySegmentOutputView(firstSegment);
-        outputView.setPosition(0);
-        // update header.
-        outputView.writeLong(baseLogOffset);
-        outputView.writeInt(sizeInBytes - BASE_OFFSET_LENGTH - LENGTH_LENGTH);
-        outputView.writeByte(magic);
-
-        // write empty timestamp which will be overridden on server side
-        outputView.writeLong(0);
-        // write empty crc first.
-        outputView.writeUnsignedInt(0);
-
-        outputView.writeShort((short) schemaId);
-        // write attributes (currently only appendOnly flag)
-        outputView.writeBoolean(appendOnly);
-        // skip write attribute byte for now.
-        outputView.setPosition(LAST_OFFSET_DELTA_OFFSET);
-        if (currentRecordNumber > 0) {
-            outputView.writeInt(currentRecordNumber - 1);
-        } else {
-            // If there is no record, we write 0 for filed lastOffsetDelta, see the comments about
-            // the field 'lastOffsetDelta' in DefaultLogRecordBatch.
-            outputView.writeInt(0);
-        }
-        outputView.writeLong(writerId);
-        outputView.writeInt(batchSequence);
-        outputView.writeInt(currentRecordNumber);
-
-        // Update crc.
-        long crc = Crc32C.compute(pagedOutputView.getWrittenSegments(), SCHEMA_ID_OFFSET);
-        outputView.setPosition(CRC_OFFSET);
-        outputView.writeUnsignedInt(crc);
-    }
 }
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
index a713c34ee2..25556a251d 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
@@ -24,6 +24,7 @@
 import java.io.IOException;
 
 import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
+import static org.apache.fluss.record.LogRecordBatch.LOG_MAGIC_VALUE_V0;
 
 /**
  * Default builder for {@link MemoryLogRecords} of log records in {@link
@@ -44,12 +45,7 @@ private MemoryLogRecordsIndexedBuilder(
     public static MemoryLogRecordsIndexedBuilder builder(
             int schemaId, int writeLimit, AbstractPagedOutputView outputView, boolean appendOnly) {
         return new MemoryLogRecordsIndexedBuilder(
-                BUILDER_DEFAULT_OFFSET,
-                schemaId,
-                writeLimit,
-                CURRENT_LOG_MAGIC_VALUE,
-                outputView,
-                appendOnly);
+                LOG_MAGIC_VALUE_V0, schemaId, writeLimit, CURRENT_LOG_MAGIC_VALUE, outputView, appendOnly);
     }
 
     @VisibleForTesting

From 82860658d0b2d47bc4ff6dfd77141b86b4bdbf31 Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 16:50:02 +0300
Subject: [PATCH 11/27] allow kv to use compacted log format

---
 .../fluss/record/MemoryLogRecordsCompactedBuilder.java     | 7 ++++++-
 .../fluss/record/MemoryLogRecordsIndexedBuilder.java       | 7 ++++++-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
index 1a6924a142..f9095f357f 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
@@ -58,7 +58,12 @@ private MemoryLogRecordsCompactedBuilder(
     public static MemoryLogRecordsCompactedBuilder builder(
             int schemaId, int writeLimit, AbstractPagedOutputView outputView, boolean appendOnly) {
         return new MemoryLogRecordsCompactedBuilder(
-                LOG_MAGIC_VALUE_V0, schemaId, writeLimit, CURRENT_LOG_MAGIC_VALUE, outputView, appendOnly);
+                LOG_MAGIC_VALUE_V0,
+                schemaId,
+                writeLimit,
+                CURRENT_LOG_MAGIC_VALUE,
+                outputView,
+                appendOnly);
     }
 
     @VisibleForTesting
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
index 25556a251d..d3432f04a2 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
@@ -45,7 +45,12 @@ private MemoryLogRecordsIndexedBuilder(
     public static MemoryLogRecordsIndexedBuilder builder(
             int schemaId, int writeLimit, AbstractPagedOutputView outputView, boolean appendOnly) {
         return new MemoryLogRecordsIndexedBuilder(
-                LOG_MAGIC_VALUE_V0, schemaId, writeLimit, CURRENT_LOG_MAGIC_VALUE, outputView, appendOnly);
+                LOG_MAGIC_VALUE_V0,
+                schemaId,
+                writeLimit,
+                CURRENT_LOG_MAGIC_VALUE,
+                outputView,
+                appendOnly);
     }
 
     @VisibleForTesting

From 372818de02e500a29818e4877758eb5119311a10 Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 18:53:18 +0300
Subject: [PATCH 12/27] add end2end functionality for compact log write and
 tests

---
 .../fluss/client/table/FlussTableITCase.java  | 251 +++++++++++++++++-
 1 file changed, 249 insertions(+), 2 deletions(-)

diff --git a/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java b/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
index 0cc2f7f10f..b68cdd7a51 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
@@ -742,7 +742,7 @@ void testAppendWhileTableMaybeNotReady() throws Exception {
     }
 
     @ParameterizedTest
-    @ValueSource(strings = {"INDEXED", "ARROW"})
+    @ValueSource(strings = {"INDEXED", "ARROW", "COMPACTED"})
     void testAppendAndPoll(String format) throws Exception {
         verifyAppendOrPut(true, format, null);
     }
@@ -755,7 +755,10 @@ void testPutAndPoll(String kvFormat) throws Exception {
 
     @Test
     void testPutAndPollCompacted() throws Exception {
-        verifyAppendOrPut(false, "COMPACTED", "COMPACTED");
+        String logFormat = "COMPACTED";
+        String kvFormat = "COMPACTED";
+
+        verifyAppendOrPut(false, logFormat, kvFormat);
     }
 
     void verifyAppendOrPut(boolean append, String logFormat, @Nullable String kvFormat)
@@ -1417,4 +1420,248 @@ void testFileSystemRecognizeConnectionConf() throws Exception {
                             Collections.singletonMap("client.fs.test.key", "fs_test_value"));
         }
     }
+
+    // ---------------------- PK with COMPACTED log tests ----------------------
+    @Test
+    void testPkUpsertAndPollWithCompactedLog() throws Exception {
+        Schema schema =
+                Schema.newBuilder()
+                        .column("a", DataTypes.INT())
+                        .column("b", DataTypes.INT())
+                        .column("c", DataTypes.STRING())
+                        .column("d", DataTypes.BIGINT())
+                        .primaryKey("a")
+                        .build();
+        TableDescriptor tableDescriptor =
+                TableDescriptor.builder()
+                        .schema(schema)
+                        .kvFormat(KvFormat.COMPACTED)
+                        .logFormat(LogFormat.COMPACTED)
+                        .build();
+        TablePath tablePath = TablePath.of("test_db_1", "test_pk_compacted_upsert_poll");
+        createTable(tablePath, tableDescriptor, false);
+
+        int expectedSize = 30;
+        try (Table table = conn.getTable(tablePath)) {
+            UpsertWriter upsertWriter = table.newUpsert().createWriter();
+            for (int i = 0; i < expectedSize; i++) {
+                String value = i % 2 == 0 ? "hello, friend" + i : null;
+                GenericRow r = row(i, 100, value, i * 10L);
+                upsertWriter.upsert(r);
+                if (i % 10 == 0) {
+                    upsertWriter.flush();
+                }
+            }
+            upsertWriter.flush();
+
+            LogScanner logScanner = createLogScanner(table);
+            subscribeFromBeginning(logScanner, table);
+            int count = 0;
+            while (count < expectedSize) {
+                ScanRecords scanRecords = logScanner.poll(Duration.ofSeconds(1));
+                for (ScanRecord scanRecord : scanRecords) {
+                    assertThat(scanRecord.getChangeType()).isEqualTo(ChangeType.INSERT);
+                    InternalRow rr = scanRecord.getRow();
+                    assertThat(rr.getFieldCount()).isEqualTo(4);
+                    assertThat(rr.getInt(0)).isEqualTo(count);
+                    assertThat(rr.getInt(1)).isEqualTo(100);
+                    if (count % 2 == 0) {
+                        assertThat(rr.getString(2).toString()).isEqualTo("hello, friend" + count);
+                    } else {
+                        assertThat(rr.isNullAt(2)).isTrue();
+                    }
+                    assertThat(rr.getLong(3)).isEqualTo(count * 10L);
+                    count++;
+                }
+            }
+            assertThat(count).isEqualTo(expectedSize);
+            logScanner.close();
+        }
+    }
+
+    @Test
+    void testPkUpdateAndDeleteWithCompactedLog() throws Exception {
+        Schema schema =
+                Schema.newBuilder()
+                        .column("a", DataTypes.INT())
+                        .column("b", DataTypes.INT())
+                        .primaryKey("a")
+                        .build();
+        TableDescriptor tableDescriptor =
+                TableDescriptor.builder()
+                        .schema(schema)
+                        .kvFormat(KvFormat.COMPACTED)
+                        .logFormat(LogFormat.COMPACTED)
+                        .build();
+        TablePath tablePath = TablePath.of("test_db_1", "test_pk_compacted_update_delete");
+        createTable(tablePath, tableDescriptor, false);
+
+        try (Table table = conn.getTable(tablePath)) {
+            UpsertWriter upsertWriter = table.newUpsert().createWriter();
+            // initial insert
+            upsertWriter.upsert(row(1, 10));
+            upsertWriter.flush();
+            // update same key
+            upsertWriter.upsert(row(1, 20));
+            upsertWriter.flush();
+            // delete the key
+            upsertWriter.delete(row(1, 20));
+            upsertWriter.flush();
+
+            LogScanner scanner = createLogScanner(table);
+            subscribeFromBeginning(scanner, table);
+            // Expect: +I(1,10), -U(1,10), +U(1,20), -D(1,20)
+            ChangeType[] expected = {
+                ChangeType.INSERT,
+                ChangeType.UPDATE_BEFORE,
+                ChangeType.UPDATE_AFTER,
+                ChangeType.DELETE
+            };
+            int seen = 0;
+            while (seen < expected.length) {
+                ScanRecords recs = scanner.poll(Duration.ofSeconds(1));
+                for (ScanRecord r : recs) {
+                    assertThat(r.getChangeType()).isEqualTo(expected[seen]);
+                    InternalRow row = r.getRow();
+                    assertThat(row.getInt(0)).isEqualTo(1);
+                    if (expected[seen] == ChangeType.INSERT
+                            || expected[seen] == ChangeType.UPDATE_BEFORE
+                            || expected[seen] == ChangeType.UPDATE_AFTER) {
+                        // value field present
+                        if (expected[seen] == ChangeType.UPDATE_AFTER) {
+                            assertThat(row.getInt(1)).isEqualTo(20);
+                        } else {
+                            assertThat(row.getInt(1)).isEqualTo(10);
+                        }
+                    }
+                    seen++;
+                }
+            }
+            assertThat(seen).isEqualTo(expected.length);
+            scanner.close();
+        }
+    }
+
+    @Test
+    void testPkCompactedProject() throws Exception {
+        Schema schema =
+                Schema.newBuilder()
+                        .column("a", DataTypes.INT())
+                        .column("b", DataTypes.INT())
+                        .column("c", DataTypes.STRING())
+                        .primaryKey("a")
+                        .build();
+        TableDescriptor td =
+                TableDescriptor.builder()
+                        .schema(schema)
+                        .kvFormat(KvFormat.COMPACTED)
+                        .logFormat(LogFormat.COMPACTED)
+                        .build();
+        TablePath path = TablePath.of("test_db_1", "test_pk_compacted_project");
+        createTable(path, td, false);
+
+        try (Table table = conn.getTable(path)) {
+            UpsertWriter upsert = table.newUpsert().createWriter();
+            for (int i = 0; i < 10; i++) {
+                String v = i % 2 == 0 ? "v" + i : null;
+                upsert.upsert(row(i, 100 + i, v));
+            }
+            upsert.flush();
+
+            LogScanner scanner = createLogScanner(table, new int[] {0, 2});
+            subscribeFromBeginning(scanner, table);
+            int cnt = 0;
+            while (cnt < 10) {
+                ScanRecords recs = scanner.poll(Duration.ofSeconds(1));
+                for (ScanRecord r : recs) {
+                    assertThat(r.getChangeType()).isEqualTo(ChangeType.INSERT);
+                    InternalRow out = r.getRow();
+                    assertThat(out.getFieldCount()).isEqualTo(2);
+                    assertThat(out.getInt(0)).isEqualTo(cnt);
+                    if (cnt % 2 == 0) {
+                        assertThat(out.getString(1).toString()).isEqualTo("v" + cnt);
+                    } else {
+                        assertThat(out.isNullAt(1)).isTrue();
+                    }
+                    cnt++;
+                }
+            }
+            scanner.close();
+        }
+    }
+
+    @Test
+    void testPkCompactedPollFromLatestNoRecords() throws Exception {
+        Schema schema =
+                Schema.newBuilder()
+                        .column("a", DataTypes.INT())
+                        .column("b", DataTypes.INT())
+                        .primaryKey("a")
+                        .build();
+        TableDescriptor td =
+                TableDescriptor.builder()
+                        .schema(schema)
+                        .kvFormat(KvFormat.COMPACTED)
+                        .logFormat(LogFormat.COMPACTED)
+                        .build();
+        TablePath path = TablePath.of("test_db_1", "test_pk_compacted_latest");
+        createTable(path, td, false);
+
+        try (Table table = conn.getTable(path)) {
+            LogScanner scanner = createLogScanner(table);
+            subscribeFromLatestOffset(path, null, null, table, scanner, admin);
+            // Now write a few rows and ensure only these are seen
+            UpsertWriter upsert = table.newUpsert().createWriter();
+            for (int i = 0; i < 5; i++) {
+                upsert.upsert(row(i, i));
+            }
+            upsert.flush();
+
+            int seen = 0;
+            while (seen < 5) {
+                ScanRecords recs = scanner.poll(Duration.ofSeconds(1));
+                for (ScanRecord r : recs) {
+                    assertThat(r.getChangeType()).isEqualTo(ChangeType.INSERT);
+                    assertThat(r.getRow().getInt(0)).isBetween(0, 4);
+                    seen++;
+                }
+            }
+            scanner.close();
+        }
+    }
+
+    @Test
+    void testPkDeleteNonExistentEmitsNoRecords() throws Exception {
+        Schema schema =
+                Schema.newBuilder()
+                        .column("a", DataTypes.INT())
+                        .column("b", DataTypes.INT())
+                        .primaryKey("a")
+                        .build();
+        TableDescriptor td =
+                TableDescriptor.builder()
+                        .schema(schema)
+                        .kvFormat(KvFormat.COMPACTED)
+                        .logFormat(LogFormat.COMPACTED)
+                        .build();
+        TablePath path = TablePath.of("test_db_1", "test_pk_compacted_delete_missing");
+        createTable(path, td, false);
+
+        try (Table table = conn.getTable(path)) {
+            UpsertWriter upsert = table.newUpsert().createWriter();
+            // delete non-existent key
+            upsert.delete(row(42, 0));
+            upsert.flush();
+
+            LogScanner scanner = createLogScanner(table);
+            subscribeFromBeginning(scanner, table);
+            int total = 0;
+            // poll a few times to ensure no accidental records
+            for (int i = 0; i < 3; i++) {
+                total += scanner.poll(Duration.ofSeconds(1)).count();
+            }
+            assertThat(total).isEqualTo(0);
+            scanner.close();
+        }
+    }
 }

From 7c4ef2862718159cd098dd262537046465851b7a Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sat, 30 Aug 2025 19:10:47 +0300
Subject: [PATCH 13/27] throw exception if projection is used in compacted log
 format

---
 .../fluss/client/table/FlussTableITCase.java  | 23 ++++---------------
 .../fluss/record/LogRecordReadContext.java    |  8 ++++++-
 2 files changed, 11 insertions(+), 20 deletions(-)

diff --git a/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java b/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
index b68cdd7a51..bc81b40296 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
@@ -1568,25 +1568,10 @@ void testPkCompactedProject() throws Exception {
             }
             upsert.flush();
 
-            LogScanner scanner = createLogScanner(table, new int[] {0, 2});
-            subscribeFromBeginning(scanner, table);
-            int cnt = 0;
-            while (cnt < 10) {
-                ScanRecords recs = scanner.poll(Duration.ofSeconds(1));
-                for (ScanRecord r : recs) {
-                    assertThat(r.getChangeType()).isEqualTo(ChangeType.INSERT);
-                    InternalRow out = r.getRow();
-                    assertThat(out.getFieldCount()).isEqualTo(2);
-                    assertThat(out.getInt(0)).isEqualTo(cnt);
-                    if (cnt % 2 == 0) {
-                        assertThat(out.getString(1).toString()).isEqualTo("v" + cnt);
-                    } else {
-                        assertThat(out.isNullAt(1)).isTrue();
-                    }
-                    cnt++;
-                }
-            }
-            scanner.close();
+            // Creating a projected log scanner for COMPACTED should fail
+            assertThatThrownBy(() -> createLogScanner(table, new int[] {0, 2}))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessageContaining("Projection is not supported for COMPACTED log format");
         }
     }
 
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java b/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java
index 6d3ee99af9..5756a4a953 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java
@@ -79,7 +79,13 @@ public static LogRecordReadContext createReadContext(
                     Projection.of(
                             IntStream.range(0, rowType.getFieldCount()).toArray(),
                             tableInfo.getSchema());
-        }
+        } else {
+            // Explicitly forbid any projection for COMPACTED log format
+            if (logFormat == LogFormat.COMPACTED) {
+                throw new IllegalArgumentException(
+                        "Projection is not supported for COMPACTED log format. Please remove projection.");
+            }
+            }
 
         if (logFormat == LogFormat.ARROW) {
             if (readFromRemote) {

From ac1ca45aab17d277f68e2a7862a3739c60e2dddd Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Mon, 1 Sep 2025 08:46:39 +0300
Subject: [PATCH 14/27] small improvements

---
 .../fluss/client/write/CompactedLogWriteBatch.java   | 12 ++----------
 .../fluss/client/write/IndexedLogWriteBatch.java     |  9 ---------
 .../apache/fluss/client/table/FlussTableITCase.java  |  5 +----
 .../client/write/CompactedLogWriteBatchTest.java     |  9 ++++-----
 .../fluss/client/write/IndexedLogWriteBatchTest.java | 12 +++++-------
 .../record/MemoryLogRecordsCompactedBuilder.java     |  3 +--
 .../fluss/record/MemoryLogRecordsIndexedBuilder.java |  3 +--
 .../apache/fluss/record/CompactedLogRecordTest.java  |  4 ----
 8 files changed, 14 insertions(+), 43 deletions(-)

diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
index a1a402e8c8..4c2f6550ae 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
@@ -19,18 +19,17 @@
 
 import org.apache.fluss.annotation.Internal;
 import org.apache.fluss.memory.AbstractPagedOutputView;
-import org.apache.fluss.memory.MemorySegment;
 import org.apache.fluss.metadata.PhysicalTablePath;
 import org.apache.fluss.record.ChangeType;
 import org.apache.fluss.record.MemoryLogRecordsCompactedBuilder;
 import org.apache.fluss.record.bytesview.BytesView;
+import org.apache.fluss.row.InternalRow;
 import org.apache.fluss.row.compacted.CompactedRow;
 import org.apache.fluss.rpc.messages.ProduceLogRequest;
 
 import javax.annotation.concurrent.NotThreadSafe;
 
 import java.io.IOException;
-import java.util.List;
 
 import static org.apache.fluss.utils.Preconditions.checkArgument;
 
@@ -43,7 +42,6 @@
 @NotThreadSafe
 @Internal
 public final class CompactedLogWriteBatch extends AbstractRowLogWriteBatch<CompactedRow> {
-    private final AbstractPagedOutputView outputView;
 
     public CompactedLogWriteBatch(
             int bucketId,
@@ -118,18 +116,12 @@ public int getSizeInBytes() {
                     }
                 },
                 "Failed to build compacted log record batch.");
-        this.outputView = outputView;
     }
 
     @Override
-    protected CompactedRow requireAndCastRow(org.apache.fluss.row.InternalRow row) {
+    protected CompactedRow requireAndCastRow(InternalRow row) {
         checkArgument(
                 row instanceof CompactedRow, "row must be CompactedRow for compacted log table");
         return (CompactedRow) row;
     }
-
-    @Override
-    public List<MemorySegment> pooledMemorySegments() {
-        return outputView.allocatedPooledSegments();
-    }
 }
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
index 449923affd..b1df284455 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
@@ -19,7 +19,6 @@
 
 import org.apache.fluss.annotation.Internal;
 import org.apache.fluss.memory.AbstractPagedOutputView;
-import org.apache.fluss.memory.MemorySegment;
 import org.apache.fluss.metadata.PhysicalTablePath;
 import org.apache.fluss.record.ChangeType;
 import org.apache.fluss.record.MemoryLogRecordsIndexedBuilder;
@@ -30,7 +29,6 @@
 import javax.annotation.concurrent.NotThreadSafe;
 
 import java.io.IOException;
-import java.util.List;
 
 import static org.apache.fluss.utils.Preconditions.checkArgument;
 
@@ -43,7 +41,6 @@
 @NotThreadSafe
 @Internal
 public final class IndexedLogWriteBatch extends AbstractRowLogWriteBatch<IndexedRow> {
-    private final AbstractPagedOutputView outputView;
 
     public IndexedLogWriteBatch(
             int bucketId,
@@ -144,7 +141,6 @@ public int getSizeInBytes() {
                     }
                 },
                 "Failed to build indexed log record batch.");
-        this.outputView = outputView;
     }
 
     @Override
@@ -152,9 +148,4 @@ protected IndexedRow requireAndCastRow(org.apache.fluss.row.InternalRow row) {
         checkArgument(row instanceof IndexedRow, "row must be IndexRow for indexed log table");
         return (IndexedRow) row;
     }
-
-    @Override
-    public List<MemorySegment> pooledMemorySegments() {
-        return outputView.allocatedPooledSegments();
-    }
 }
diff --git a/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java b/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
index bc81b40296..c37f6a1f34 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
@@ -755,10 +755,7 @@ void testPutAndPoll(String kvFormat) throws Exception {
 
     @Test
     void testPutAndPollCompacted() throws Exception {
-        String logFormat = "COMPACTED";
-        String kvFormat = "COMPACTED";
-
-        verifyAppendOrPut(false, logFormat, kvFormat);
+        verifyAppendOrPut(false, "COMPACTED", "COMPACTED");
     }
 
     void verifyAppendOrPut(boolean append, String logFormat, @Nullable String kvFormat)
diff --git a/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java b/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
index aeb709b254..3bd6148d01 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
@@ -70,11 +70,10 @@ void testTryAppendWithWriteLimit() throws Exception {
                         writeLimit,
                         MemorySegment.allocateHeapMemory(writeLimit));
 
-        for (int i = 0;
-                i
-                        < (writeLimit - DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE)
-                                / estimatedSizeInBytes;
-                i++) {
+        int maxRecordsPerBatch =
+                (writeLimit - DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE)
+                        / estimatedSizeInBytes;
+        for (int i = 0; i < maxRecordsPerBatch; i++) {
             boolean appendResult =
                     logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback());
             assertThat(appendResult).isTrue();
diff --git a/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java b/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java
index db39493bd7..2e5e0aae43 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java
@@ -22,6 +22,7 @@
 import org.apache.fluss.metadata.SchemaInfo;
 import org.apache.fluss.metadata.TableBucket;
 import org.apache.fluss.record.ChangeType;
+import org.apache.fluss.record.DefaultLogRecordBatch;
 import org.apache.fluss.record.IndexedLogRecord;
 import org.apache.fluss.record.LogRecord;
 import org.apache.fluss.record.LogRecordBatch;
@@ -41,8 +42,6 @@
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
-import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
-import static org.apache.fluss.record.LogRecordBatchFormat.recordBatchHeaderSize;
 import static org.apache.fluss.record.TestData.DATA1_PHYSICAL_TABLE_PATH;
 import static org.apache.fluss.record.TestData.DATA1_ROW_TYPE;
 import static org.apache.fluss.record.TestData.DATA1_SCHEMA;
@@ -74,11 +73,10 @@ void testTryAppendWithWriteLimit() throws Exception {
                         writeLimit,
                         MemorySegment.allocateHeapMemory(writeLimit));
 
-        for (int i = 0;
-                i
-                        < (writeLimit - recordBatchHeaderSize(CURRENT_LOG_MAGIC_VALUE))
-                                / estimatedSizeInBytes;
-                i++) {
+        int maxRecordsPerBatch =
+                (writeLimit - DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE)
+                        / estimatedSizeInBytes;
+        for (int i = 0; i < maxRecordsPerBatch; i++) {
             boolean appendResult =
                     logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback());
             assertThat(appendResult).isTrue();
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
index f9095f357f..0ee875fca7 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
@@ -36,7 +36,6 @@
 import java.io.IOException;
 
 import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
-import static org.apache.fluss.record.LogRecordBatch.LOG_MAGIC_VALUE_V0;
 
 /**
  * Default builder for {@link MemoryLogRecords} of log records in {@link
@@ -58,7 +57,7 @@ private MemoryLogRecordsCompactedBuilder(
     public static MemoryLogRecordsCompactedBuilder builder(
             int schemaId, int writeLimit, AbstractPagedOutputView outputView, boolean appendOnly) {
         return new MemoryLogRecordsCompactedBuilder(
-                LOG_MAGIC_VALUE_V0,
+                BUILDER_DEFAULT_OFFSET,
                 schemaId,
                 writeLimit,
                 CURRENT_LOG_MAGIC_VALUE,
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
index d3432f04a2..a713c34ee2 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
@@ -24,7 +24,6 @@
 import java.io.IOException;
 
 import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
-import static org.apache.fluss.record.LogRecordBatch.LOG_MAGIC_VALUE_V0;
 
 /**
  * Default builder for {@link MemoryLogRecords} of log records in {@link
@@ -45,7 +44,7 @@ private MemoryLogRecordsIndexedBuilder(
     public static MemoryLogRecordsIndexedBuilder builder(
             int schemaId, int writeLimit, AbstractPagedOutputView outputView, boolean appendOnly) {
         return new MemoryLogRecordsIndexedBuilder(
-                LOG_MAGIC_VALUE_V0,
+                BUILDER_DEFAULT_OFFSET,
                 schemaId,
                 writeLimit,
                 CURRENT_LOG_MAGIC_VALUE,
diff --git a/fluss-common/src/test/java/org/apache/fluss/record/CompactedLogRecordTest.java b/fluss-common/src/test/java/org/apache/fluss/record/CompactedLogRecordTest.java
index a3a8ed8899..cfec405f1c 100644
--- a/fluss-common/src/test/java/org/apache/fluss/record/CompactedLogRecordTest.java
+++ b/fluss-common/src/test/java/org/apache/fluss/record/CompactedLogRecordTest.java
@@ -47,10 +47,8 @@ void testBase() throws IOException {
         CompactedRow row =
                 CompactedRow.from(fieldTypes, bytes, new CompactedRowDeserializer(fieldTypes));
 
-        // write
         CompactedLogRecord.writeTo(outputView, ChangeType.APPEND_ONLY, row);
 
-        // read
         CompactedLogRecord logRecord =
                 CompactedLogRecord.readFrom(
                         MemorySegment.wrap(outputView.getCopyOfBuffer()),
@@ -73,10 +71,8 @@ void testWriteToAndReadFromWithRandomData() throws IOException {
                 TestInternalRowGenerator.createAllRowType().getChildren().toArray(new DataType[0]);
         CompactedRow row = TestInternalRowGenerator.genCompactedRowForAllType();
 
-        // write
         CompactedLogRecord.writeTo(outputView, ChangeType.APPEND_ONLY, row);
 
-        // read
         LogRecord logRecord =
                 CompactedLogRecord.readFrom(
                         MemorySegment.wrap(outputView.getCopyOfBuffer()),

From f1eb7958eb8a99a34b641ab3aa3e976cbb81f86f Mon Sep 17 00:00:00 2001
From: Giannis Polyzos <ipolyzos.se@gmail.com>
Date: Mon, 1 Sep 2025 16:26:49 +0300
Subject: [PATCH 15/27] Update
 fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 .../apache/fluss/record/MemoryLogRecordsCompactedBuilder.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
index 0ee875fca7..67b01137bf 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
@@ -32,14 +32,14 @@
 import org.apache.fluss.record.bytesview.BytesView;
 import org.apache.fluss.record.bytesview.MultiBytesView;
 import org.apache.fluss.row.compacted.CompactedRow;
+import org.apache.fluss.metadata.LogFormat;
 
 import java.io.IOException;
 
 import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
 
 /**
- * Default builder for {@link MemoryLogRecords} of log records in {@link
- * org.apache.fluss.metadata.LogFormat#COMPACTED} format.
+ * Default builder for {@link MemoryLogRecords} of log records in {@link LogFormat#COMPACTED} format.
  */
 public class MemoryLogRecordsCompactedBuilder
         extends AbstractRowMemoryLogRecordsBuilder<CompactedRow> {

From f887182219213ae926ce010dc3a4d6ff0cf7fba2 Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Mon, 1 Sep 2025 16:28:40 +0300
Subject: [PATCH 16/27] fix violations

---
 .../record/MemoryLogRecordsCompactedBuilder.java  | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

diff --git a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
index 67b01137bf..e23aa5cc3b 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
@@ -19,27 +19,16 @@
 
 import org.apache.fluss.annotation.VisibleForTesting;
 import org.apache.fluss.memory.AbstractPagedOutputView;
-import org.apache.fluss.annotation.VisibleForTesting;
-import org.apache.fluss.memory.AbstractPagedOutputView;
-import org.apache.fluss.memory.MemorySegment;
-import org.apache.fluss.memory.MemorySegmentOutputView;
 import org.apache.fluss.metadata.LogFormat;
 import org.apache.fluss.row.compacted.CompactedRow;
 
 import java.io.IOException;
 
-import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
-import org.apache.fluss.record.bytesview.BytesView;
-import org.apache.fluss.record.bytesview.MultiBytesView;
-import org.apache.fluss.row.compacted.CompactedRow;
-import org.apache.fluss.metadata.LogFormat;
-
-import java.io.IOException;
-
 import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
 
 /**
- * Default builder for {@link MemoryLogRecords} of log records in {@link LogFormat#COMPACTED} format.
+ * Default builder for {@link MemoryLogRecords} of log records in {@link LogFormat#COMPACTED}
+ * format.
  */
 public class MemoryLogRecordsCompactedBuilder
         extends AbstractRowMemoryLogRecordsBuilder<CompactedRow> {

From f6fdc5813236650cdd488497b9e04382c0762e0c Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Wed, 10 Sep 2025 13:11:49 +0300
Subject: [PATCH 17/27] fix compilation issues after rebase

---
 .../AbstractRowMemoryLogRecordsBuilder.java    | 18 ++++++++++--------
 .../fluss/record/DefaultLogRecordBatch.java    |  1 +
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java
index c166156129..a0c8524ad7 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java
@@ -26,15 +26,17 @@
 
 import java.io.IOException;
 
-import static org.apache.fluss.record.DefaultLogRecordBatch.BASE_OFFSET_LENGTH;
-import static org.apache.fluss.record.DefaultLogRecordBatch.CRC_OFFSET;
-import static org.apache.fluss.record.DefaultLogRecordBatch.LAST_OFFSET_DELTA_OFFSET;
-import static org.apache.fluss.record.DefaultLogRecordBatch.LENGTH_LENGTH;
-import static org.apache.fluss.record.DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE;
-import static org.apache.fluss.record.DefaultLogRecordBatch.SCHEMA_ID_OFFSET;
+import static org.apache.fluss.record.DefaultValueRecordBatch.RECORD_BATCH_HEADER_SIZE;
 import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
-import static org.apache.fluss.record.LogRecordBatch.NO_BATCH_SEQUENCE;
-import static org.apache.fluss.record.LogRecordBatch.NO_WRITER_ID;
+import static org.apache.fluss.record.LogRecordBatchFormat.BASE_OFFSET_LENGTH;
+import static org.apache.fluss.record.LogRecordBatchFormat.LENGTH_LENGTH;
+import static org.apache.fluss.record.LogRecordBatchFormat.LOG_MAGIC_VALUE_V1;
+import static org.apache.fluss.record.LogRecordBatchFormat.NO_BATCH_SEQUENCE;
+import static org.apache.fluss.record.LogRecordBatchFormat.NO_LEADER_EPOCH;
+import static org.apache.fluss.record.LogRecordBatchFormat.NO_WRITER_ID;
+import static org.apache.fluss.record.LogRecordBatchFormat.crcOffset;
+import static org.apache.fluss.record.LogRecordBatchFormat.lastOffsetDeltaOffset;
+import static org.apache.fluss.record.LogRecordBatchFormat.schemaIdOffset;
 import static org.apache.fluss.utils.Preconditions.checkArgument;
 
 /** Abstract base builder for row-based MemoryLogRecords builders sharing common logic. */
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/DefaultLogRecordBatch.java b/fluss-common/src/main/java/org/apache/fluss/record/DefaultLogRecordBatch.java
index 188a62bbd0..54190fa85a 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/DefaultLogRecordBatch.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/DefaultLogRecordBatch.java
@@ -38,6 +38,7 @@
 import java.nio.ByteBuffer;
 import java.util.NoSuchElementException;
 
+import static org.apache.fluss.record.DefaultValueRecordBatch.RECORD_BATCH_HEADER_SIZE;
 import static org.apache.fluss.record.LogRecordBatchFormat.BASE_OFFSET_OFFSET;
 import static org.apache.fluss.record.LogRecordBatchFormat.COMMIT_TIMESTAMP_OFFSET;
 import static org.apache.fluss.record.LogRecordBatchFormat.LENGTH_OFFSET;

From bbf0511d598e58815dfba4cacf1ec497289dbbaa Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Wed, 10 Sep 2025 14:27:29 +0300
Subject: [PATCH 18/27] fix import issue

---
 .../java/org/apache/fluss/client/write/WriteRecord.java    | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
index 3b81bac85a..0ea52b9cdb 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
@@ -31,6 +31,7 @@
 
 import javax.annotation.Nullable;
 
+import static org.apache.fluss.record.DefaultKvRecordBatch.RECORD_BATCH_HEADER_SIZE;
 import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
 import static org.apache.fluss.record.LogRecordBatchFormat.recordBatchHeaderSize;
 import static org.apache.fluss.utils.Preconditions.checkNotNull;
@@ -54,7 +55,7 @@ public static WriteRecord forUpsert(
         checkNotNull(key, "key must not be null");
         checkNotNull(bucketKey, "bucketKey must not be null");
         int estimatedSizeInBytes =
-                DefaultKvRecord.sizeOf(key, row) + DefaultKvRecordBatch.RECORD_BATCH_HEADER_SIZE;
+                DefaultKvRecord.sizeOf(key, row) + RECORD_BATCH_HEADER_SIZE;
         return new WriteRecord(
                 tableInfo,
                 tablePath,
@@ -76,7 +77,7 @@ public static WriteRecord forDelete(
         checkNotNull(key, "key must not be null");
         checkNotNull(bucketKey, "key must not be null");
         int estimatedSizeInBytes =
-                DefaultKvRecord.sizeOf(key, null) + DefaultKvRecordBatch.RECORD_BATCH_HEADER_SIZE;
+                DefaultKvRecord.sizeOf(key, null) + RECORD_BATCH_HEADER_SIZE;
         return new WriteRecord(
                 tableInfo,
                 tablePath,
@@ -134,7 +135,7 @@ public static WriteRecord forCompactedAppend(
             PhysicalTablePath tablePath, CompactedRow row, @Nullable byte[] bucketKey) {
         checkNotNull(row);
         int estimatedSizeInBytes =
-                CompactedLogRecord.sizeOf(row) + DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE;
+                CompactedLogRecord.sizeOf(row) + RECORD_BATCH_HEADER_SIZE;
         return new WriteRecord(
                 tablePath,
                 null,

From 8843745076720e89823f8dc72cf642a3a82f278b Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Wed, 10 Sep 2025 14:29:04 +0300
Subject: [PATCH 19/27] fix import issue

---
 .../src/main/java/org/apache/fluss/client/write/WriteRecord.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
index 0ea52b9cdb..0184b51f49 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
@@ -22,7 +22,6 @@
 import org.apache.fluss.record.CompactedLogRecord;
 import org.apache.fluss.metadata.TableInfo;
 import org.apache.fluss.record.DefaultKvRecord;
-import org.apache.fluss.record.DefaultKvRecordBatch;
 import org.apache.fluss.record.IndexedLogRecord;
 import org.apache.fluss.row.BinaryRow;
 import org.apache.fluss.row.InternalRow;

From a2ec69f2352da89519ed2999a4e31ec93e3f3f6d Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Wed, 10 Sep 2025 14:32:10 +0300
Subject: [PATCH 20/27] fix checkstyle issue

---
 .../java/org/apache/fluss/client/write/WriteRecord.java     | 6 ++----
 .../java/org/apache/fluss/record/LogRecordReadContext.java  | 2 +-
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
index 0184b51f49..5351cecc18 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
@@ -75,8 +75,7 @@ public static WriteRecord forDelete(
             @Nullable int[] targetColumns) {
         checkNotNull(key, "key must not be null");
         checkNotNull(bucketKey, "key must not be null");
-        int estimatedSizeInBytes =
-                DefaultKvRecord.sizeOf(key, null) + RECORD_BATCH_HEADER_SIZE;
+        int estimatedSizeInBytes = DefaultKvRecord.sizeOf(key, null) + RECORD_BATCH_HEADER_SIZE;
         return new WriteRecord(
                 tableInfo,
                 tablePath,
@@ -133,8 +132,7 @@ public static WriteRecord forArrowAppend(
     public static WriteRecord forCompactedAppend(
             PhysicalTablePath tablePath, CompactedRow row, @Nullable byte[] bucketKey) {
         checkNotNull(row);
-        int estimatedSizeInBytes =
-                CompactedLogRecord.sizeOf(row) + RECORD_BATCH_HEADER_SIZE;
+        int estimatedSizeInBytes = CompactedLogRecord.sizeOf(row) + RECORD_BATCH_HEADER_SIZE;
         return new WriteRecord(
                 tablePath,
                 null,
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java b/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java
index 5756a4a953..d3ee22057c 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java
@@ -85,7 +85,7 @@ public static LogRecordReadContext createReadContext(
                 throw new IllegalArgumentException(
                         "Projection is not supported for COMPACTED log format. Please remove projection.");
             }
-            }
+        }
 
         if (logFormat == LogFormat.ARROW) {
             if (readFromRemote) {

From a79d9ac561eafc57fb84500274b76caab17d263d Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Wed, 10 Sep 2025 14:47:19 +0300
Subject: [PATCH 21/27] fix remaining import issues

---
 .../fluss/client/write/CompactedLogWriteBatchTest.java      | 6 ++----
 .../apache/fluss/client/write/IndexedLogWriteBatchTest.java | 6 ++----
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java b/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
index 3bd6148d01..c4cddc0920 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
@@ -22,7 +22,6 @@
 import org.apache.fluss.metadata.TableBucket;
 import org.apache.fluss.record.ChangeType;
 import org.apache.fluss.record.CompactedLogRecord;
-import org.apache.fluss.record.DefaultLogRecordBatch;
 import org.apache.fluss.record.LogRecord;
 import org.apache.fluss.record.LogRecordBatch;
 import org.apache.fluss.record.LogRecordReadContext;
@@ -40,6 +39,7 @@
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
+import static org.apache.fluss.record.DefaultKvRecordBatch.RECORD_BATCH_HEADER_SIZE;
 import static org.apache.fluss.record.TestData.DATA1_PHYSICAL_TABLE_PATH;
 import static org.apache.fluss.record.TestData.DATA1_ROW_TYPE;
 import static org.apache.fluss.record.TestData.DATA1_TABLE_ID;
@@ -70,9 +70,7 @@ void testTryAppendWithWriteLimit() throws Exception {
                         writeLimit,
                         MemorySegment.allocateHeapMemory(writeLimit));
 
-        int maxRecordsPerBatch =
-                (writeLimit - DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE)
-                        / estimatedSizeInBytes;
+        int maxRecordsPerBatch = (writeLimit - RECORD_BATCH_HEADER_SIZE) / estimatedSizeInBytes;
         for (int i = 0; i < maxRecordsPerBatch; i++) {
             boolean appendResult =
                     logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback());
diff --git a/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java b/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java
index 2e5e0aae43..7160188226 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java
@@ -22,7 +22,6 @@
 import org.apache.fluss.metadata.SchemaInfo;
 import org.apache.fluss.metadata.TableBucket;
 import org.apache.fluss.record.ChangeType;
-import org.apache.fluss.record.DefaultLogRecordBatch;
 import org.apache.fluss.record.IndexedLogRecord;
 import org.apache.fluss.record.LogRecord;
 import org.apache.fluss.record.LogRecordBatch;
@@ -42,6 +41,7 @@
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
+import static org.apache.fluss.record.DefaultKvRecordBatch.RECORD_BATCH_HEADER_SIZE;
 import static org.apache.fluss.record.TestData.DATA1_PHYSICAL_TABLE_PATH;
 import static org.apache.fluss.record.TestData.DATA1_ROW_TYPE;
 import static org.apache.fluss.record.TestData.DATA1_SCHEMA;
@@ -73,9 +73,7 @@ void testTryAppendWithWriteLimit() throws Exception {
                         writeLimit,
                         MemorySegment.allocateHeapMemory(writeLimit));
 
-        int maxRecordsPerBatch =
-                (writeLimit - DefaultLogRecordBatch.RECORD_BATCH_HEADER_SIZE)
-                        / estimatedSizeInBytes;
+        int maxRecordsPerBatch = (writeLimit - RECORD_BATCH_HEADER_SIZE) / estimatedSizeInBytes;
         for (int i = 0; i < maxRecordsPerBatch; i++) {
             boolean appendResult =
                     logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback());

From 5a91d49b4e3153e58bc6f0b66dadee51d5aeb36c Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Wed, 10 Sep 2025 15:13:22 +0300
Subject: [PATCH 22/27] fix tests

---
 .../fluss/record/AbstractRowMemoryLogRecordsBuilder.java  | 2 +-
 .../org/apache/fluss/record/DefaultLogRecordBatch.java    | 1 -
 .../record/MemoryLogRecordsCompactedBuilderTest.java      | 8 ++++++--
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java
index a0c8524ad7..daed34ff88 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java
@@ -26,7 +26,6 @@
 
 import java.io.IOException;
 
-import static org.apache.fluss.record.DefaultValueRecordBatch.RECORD_BATCH_HEADER_SIZE;
 import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
 import static org.apache.fluss.record.LogRecordBatchFormat.BASE_OFFSET_LENGTH;
 import static org.apache.fluss.record.LogRecordBatchFormat.LENGTH_LENGTH;
@@ -36,6 +35,7 @@
 import static org.apache.fluss.record.LogRecordBatchFormat.NO_WRITER_ID;
 import static org.apache.fluss.record.LogRecordBatchFormat.crcOffset;
 import static org.apache.fluss.record.LogRecordBatchFormat.lastOffsetDeltaOffset;
+import static org.apache.fluss.record.LogRecordBatchFormat.recordBatchHeaderSize;
 import static org.apache.fluss.record.LogRecordBatchFormat.schemaIdOffset;
 import static org.apache.fluss.utils.Preconditions.checkArgument;
 
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/DefaultLogRecordBatch.java b/fluss-common/src/main/java/org/apache/fluss/record/DefaultLogRecordBatch.java
index 54190fa85a..188a62bbd0 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/DefaultLogRecordBatch.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/DefaultLogRecordBatch.java
@@ -38,7 +38,6 @@
 import java.nio.ByteBuffer;
 import java.util.NoSuchElementException;
 
-import static org.apache.fluss.record.DefaultValueRecordBatch.RECORD_BATCH_HEADER_SIZE;
 import static org.apache.fluss.record.LogRecordBatchFormat.BASE_OFFSET_OFFSET;
 import static org.apache.fluss.record.LogRecordBatchFormat.COMMIT_TIMESTAMP_OFFSET;
 import static org.apache.fluss.record.LogRecordBatchFormat.LENGTH_OFFSET;
diff --git a/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java b/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java
index 95048cd9a6..e576edb7a4 100644
--- a/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java
+++ b/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java
@@ -115,7 +115,10 @@ void testNoRecordAppendAndBaseOffset() throws Exception {
         // base offset 0
         MemoryLogRecordsCompactedBuilder builder = createBuilder(0, 1, 1024);
         MemoryLogRecords records = MemoryLogRecords.pointToBytesView(builder.build());
-        assertThat(records.sizeInBytes()).isEqualTo(48); // only batch header
+        assertThat(records.sizeInBytes())
+                .isEqualTo(
+                        LogRecordBatchFormat.recordBatchHeaderSize(
+                                DEFAULT_MAGIC)); // only batch header
         LogRecordBatch batch = records.batches().iterator().next();
         batch.ensureValid();
         assertThat(batch.getRecordCount()).isEqualTo(0);
@@ -132,7 +135,8 @@ void testNoRecordAppendAndBaseOffset() throws Exception {
         // base offset 100
         builder = createBuilder(100, 1, 1024);
         records = MemoryLogRecords.pointToBytesView(builder.build());
-        assertThat(records.sizeInBytes()).isEqualTo(48);
+        assertThat(records.sizeInBytes())
+                .isEqualTo(LogRecordBatchFormat.recordBatchHeaderSize(DEFAULT_MAGIC));
         batch = records.batches().iterator().next();
         batch.ensureValid();
         assertThat(batch.getRecordCount()).isEqualTo(0);

From c17103c5473aa4e00087696d2929af34e93bb4fa Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Wed, 10 Sep 2025 16:02:00 +0300
Subject: [PATCH 23/27] fix failing tests

---
 .../fluss/client/write/CompactedLogWriteBatchTest.java     | 7 +++++--
 .../fluss/client/write/IndexedLogWriteBatchTest.java       | 7 +++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java b/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
index c4cddc0920..9323c7bad9 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
@@ -39,7 +39,8 @@
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
-import static org.apache.fluss.record.DefaultKvRecordBatch.RECORD_BATCH_HEADER_SIZE;
+import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
+import static org.apache.fluss.record.LogRecordBatchFormat.recordBatchHeaderSize;
 import static org.apache.fluss.record.TestData.DATA1_PHYSICAL_TABLE_PATH;
 import static org.apache.fluss.record.TestData.DATA1_ROW_TYPE;
 import static org.apache.fluss.record.TestData.DATA1_TABLE_ID;
@@ -70,7 +71,9 @@ void testTryAppendWithWriteLimit() throws Exception {
                         writeLimit,
                         MemorySegment.allocateHeapMemory(writeLimit));
 
-        int maxRecordsPerBatch = (writeLimit - RECORD_BATCH_HEADER_SIZE) / estimatedSizeInBytes;
+        int maxRecordsPerBatch =
+                (writeLimit - recordBatchHeaderSize(CURRENT_LOG_MAGIC_VALUE))
+                        / estimatedSizeInBytes;
         for (int i = 0; i < maxRecordsPerBatch; i++) {
             boolean appendResult =
                     logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback());
diff --git a/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java b/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java
index 7160188226..aca1cde1b5 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/write/IndexedLogWriteBatchTest.java
@@ -41,7 +41,8 @@
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
-import static org.apache.fluss.record.DefaultKvRecordBatch.RECORD_BATCH_HEADER_SIZE;
+import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
+import static org.apache.fluss.record.LogRecordBatchFormat.recordBatchHeaderSize;
 import static org.apache.fluss.record.TestData.DATA1_PHYSICAL_TABLE_PATH;
 import static org.apache.fluss.record.TestData.DATA1_ROW_TYPE;
 import static org.apache.fluss.record.TestData.DATA1_SCHEMA;
@@ -73,7 +74,9 @@ void testTryAppendWithWriteLimit() throws Exception {
                         writeLimit,
                         MemorySegment.allocateHeapMemory(writeLimit));
 
-        int maxRecordsPerBatch = (writeLimit - RECORD_BATCH_HEADER_SIZE) / estimatedSizeInBytes;
+        int maxRecordsPerBatch =
+                (writeLimit - recordBatchHeaderSize(CURRENT_LOG_MAGIC_VALUE))
+                        / estimatedSizeInBytes;
         for (int i = 0; i < maxRecordsPerBatch; i++) {
             boolean appendResult =
                     logProducerBatch.tryAppend(createWriteRecord(), newWriteCallback());

From 9efb9d2ee015cd9d939df63105fe782137af798b Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Thu, 4 Dec 2025 09:06:12 +0200
Subject: [PATCH 24/27] rebase branch

---
 .../client/table/writer/AppendWriterImpl.java |  4 +-
 .../client/write/IndexedLogWriteBatch.java    | 53 ++++++++++---------
 .../fluss/client/write/WriteRecord.java       |  5 +-
 3 files changed, 33 insertions(+), 29 deletions(-)

diff --git a/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java b/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java
index 01aac31330..b3a3f8131b 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/table/writer/AppendWriterImpl.java
@@ -90,7 +90,9 @@ public CompletableFuture<AppendResult> append(InternalRow row) {
             record = WriteRecord.forIndexedAppend(tableInfo, physicalPath, indexedRow, bucketKey);
         } else if (logFormat == LogFormat.COMPACTED) {
             CompactedRow compactedRow = encodeCompactedRow(row);
-            record = WriteRecord.forCompactedAppend(tableInfo, physicalPath, compactedRow, bucketKey);
+            record =
+                    WriteRecord.forCompactedAppend(
+                            tableInfo, physicalPath, compactedRow, bucketKey);
         } else {
             // ARROW format supports general internal row
             record = WriteRecord.forArrowAppend(tableInfo, physicalPath, row, bucketKey);
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
index b1df284455..0f6b3c8597 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
@@ -59,32 +59,35 @@ public IndexedLogWriteBatch(
                             MemoryLogRecordsIndexedBuilder.builder(
                                     schemaId, writeLimit, outputView, true);
 
-    @Override
-    public boolean isLogBatch() {
-        return true;
-    }
+                    @Override
+                    public boolean isLogBatch() {
+                        return true;
+                    }
+
+                    @Override
+                    public boolean tryAppend(WriteRecord writeRecord, WriteCallback callback)
+                            throws Exception {
+                        checkNotNull(callback, "write callback must be not null");
+                        checkNotNull(writeRecord.getRow(), "row must not be null for log record");
+                        checkArgument(
+                                writeRecord.getKey() == null, "key must be null for log record");
+                        checkArgument(
+                                writeRecord.getTargetColumns() == null,
+                                "target columns must be null for log record");
+                        checkArgument(
+                                writeRecord.getRow() instanceof IndexedRow,
+                                "row must not be IndexRow for indexed log table");
+                        IndexedRow row = (IndexedRow) writeRecord.getRow();
+                        if (!recordsBuilder.hasRoomFor(row) || isClosed()) {
+                            return false;
+                        } else {
+                            recordsBuilder.append(ChangeType.APPEND_ONLY, row);
+                            recordCount++;
+                            callbacks.add(callback);
+                            return true;
+                        }
+                    }
 
-    @Override
-    public boolean tryAppend(WriteRecord writeRecord, WriteCallback callback) throws Exception {
-        checkNotNull(callback, "write callback must be not null");
-        checkNotNull(writeRecord.getRow(), "row must not be null for log record");
-        checkArgument(writeRecord.getKey() == null, "key must be null for log record");
-        checkArgument(
-                writeRecord.getTargetColumns() == null,
-                "target columns must be null for log record");
-        checkArgument(
-                writeRecord.getRow() instanceof IndexedRow,
-                "row must not be IndexRow for indexed log table");
-        IndexedRow row = (IndexedRow) writeRecord.getRow();
-        if (!recordsBuilder.hasRoomFor(row) || isClosed()) {
-            return false;
-        } else {
-            recordsBuilder.append(ChangeType.APPEND_ONLY, row);
-            recordCount++;
-            callbacks.add(callback);
-            return true;
-        }
-    }
                     @Override
                     public boolean hasRoomFor(IndexedRow row) {
                         return delegate.hasRoomFor(row);
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
index 5351cecc18..807607b657 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
@@ -19,8 +19,8 @@
 
 import org.apache.fluss.annotation.Internal;
 import org.apache.fluss.metadata.PhysicalTablePath;
-import org.apache.fluss.record.CompactedLogRecord;
 import org.apache.fluss.metadata.TableInfo;
+import org.apache.fluss.record.CompactedLogRecord;
 import org.apache.fluss.record.DefaultKvRecord;
 import org.apache.fluss.record.IndexedLogRecord;
 import org.apache.fluss.row.BinaryRow;
@@ -53,8 +53,7 @@ public static WriteRecord forUpsert(
         checkNotNull(row, "row must not be null");
         checkNotNull(key, "key must not be null");
         checkNotNull(bucketKey, "bucketKey must not be null");
-        int estimatedSizeInBytes =
-                DefaultKvRecord.sizeOf(key, row) + RECORD_BATCH_HEADER_SIZE;
+        int estimatedSizeInBytes = DefaultKvRecord.sizeOf(key, row) + RECORD_BATCH_HEADER_SIZE;
         return new WriteRecord(
                 tableInfo,
                 tablePath,

From d7dd7769803aa75a2b8443c00f7c2a31452ec1e3 Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Thu, 4 Dec 2025 09:32:47 +0200
Subject: [PATCH 25/27] fix rebase compilation issues

---
 .../client/write/CompactedLogWriteBatch.java  |  5 +++
 .../client/write/IndexedLogWriteBatch.java    | 34 +++----------------
 .../fluss/client/write/WriteRecord.java       |  6 +++-
 .../write/CompactedLogWriteBatchTest.java     |  3 +-
 4 files changed, 17 insertions(+), 31 deletions(-)

diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
index 4c2f6550ae..58722e1f20 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
@@ -118,6 +118,11 @@ public int getSizeInBytes() {
                 "Failed to build compacted log record batch.");
     }
 
+    @Override
+    public boolean isLogBatch() {
+        return true;
+    }
+
     @Override
     protected CompactedRow requireAndCastRow(InternalRow row) {
         checkArgument(
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
index 0f6b3c8597..4b5d23768e 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
@@ -59,35 +59,6 @@ public IndexedLogWriteBatch(
                             MemoryLogRecordsIndexedBuilder.builder(
                                     schemaId, writeLimit, outputView, true);
 
-                    @Override
-                    public boolean isLogBatch() {
-                        return true;
-                    }
-
-                    @Override
-                    public boolean tryAppend(WriteRecord writeRecord, WriteCallback callback)
-                            throws Exception {
-                        checkNotNull(callback, "write callback must be not null");
-                        checkNotNull(writeRecord.getRow(), "row must not be null for log record");
-                        checkArgument(
-                                writeRecord.getKey() == null, "key must be null for log record");
-                        checkArgument(
-                                writeRecord.getTargetColumns() == null,
-                                "target columns must be null for log record");
-                        checkArgument(
-                                writeRecord.getRow() instanceof IndexedRow,
-                                "row must not be IndexRow for indexed log table");
-                        IndexedRow row = (IndexedRow) writeRecord.getRow();
-                        if (!recordsBuilder.hasRoomFor(row) || isClosed()) {
-                            return false;
-                        } else {
-                            recordsBuilder.append(ChangeType.APPEND_ONLY, row);
-                            recordCount++;
-                            callbacks.add(callback);
-                            return true;
-                        }
-                    }
-
                     @Override
                     public boolean hasRoomFor(IndexedRow row) {
                         return delegate.hasRoomFor(row);
@@ -146,6 +117,11 @@ public int getSizeInBytes() {
                 "Failed to build indexed log record batch.");
     }
 
+    @Override
+    public boolean isLogBatch() {
+        return true;
+    }
+
     @Override
     protected IndexedRow requireAndCastRow(org.apache.fluss.row.InternalRow row) {
         checkArgument(row instanceof IndexedRow, "row must be IndexRow for indexed log table");
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
index 807607b657..05de608fcb 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
@@ -129,10 +129,14 @@ public static WriteRecord forArrowAppend(
 
     /** Creates a write record for append operation for Compacted format. */
     public static WriteRecord forCompactedAppend(
-            PhysicalTablePath tablePath, CompactedRow row, @Nullable byte[] bucketKey) {
+            TableInfo tableInfo,
+            PhysicalTablePath tablePath,
+            CompactedRow row,
+            @Nullable byte[] bucketKey) {
         checkNotNull(row);
         int estimatedSizeInBytes = CompactedLogRecord.sizeOf(row) + RECORD_BATCH_HEADER_SIZE;
         return new WriteRecord(
+                tableInfo,
                 tablePath,
                 null,
                 bucketKey,
diff --git a/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java b/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
index 9323c7bad9..cbd6680a72 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/write/CompactedLogWriteBatchTest.java
@@ -198,7 +198,8 @@ void testBatchAborted() throws Exception {
     }
 
     private WriteRecord createWriteRecord() {
-        return WriteRecord.forCompactedAppend(DATA1_PHYSICAL_TABLE_PATH, row, null);
+        return WriteRecord.forCompactedAppend(
+                DATA1_TABLE_INFO, DATA1_PHYSICAL_TABLE_PATH, row, null);
     }
 
     private CompactedLogWriteBatch createLogWriteBatch(TableBucket tb, long baseLogOffset)

From c63180c3bd90edb9a4f1642776f48febb2ff2f72 Mon Sep 17 00:00:00 2001
From: ipolyzos <ipolyzos.se@gmail.com>
Date: Sun, 21 Dec 2025 16:57:53 +0200
Subject: [PATCH 26/27] fix rebase issues

---
 .../fluss/client/table/FlussTableITCase.java  | 25 ++++++++++++++---
 .../fluss/record/CompactedLogRecord.java      | 27 +++++++------------
 .../fluss/record/LogRecordReadContext.java    |  6 -----
 3 files changed, 31 insertions(+), 27 deletions(-)

diff --git a/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java b/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
index c37f6a1f34..7b6b9c8227 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
@@ -1565,10 +1565,27 @@ void testPkCompactedProject() throws Exception {
             }
             upsert.flush();
 
-            // Creating a projected log scanner for COMPACTED should fail
-            assertThatThrownBy(() -> createLogScanner(table, new int[] {0, 2}))
-                    .isInstanceOf(IllegalArgumentException.class)
-                    .hasMessageContaining("Projection is not supported for COMPACTED log format");
+            // Creating a projected log scanner for COMPACTED should work
+            try (LogScanner scanner = createLogScanner(table, new int[] {0, 2})) {
+                subscribeFromBeginning(scanner, table);
+                int seen = 0;
+                while (seen < 10) {
+                    ScanRecords records = scanner.poll(Duration.ofSeconds(5));
+                    for (ScanRecord record : records) {
+                        InternalRow row = record.getRow();
+                        assertThat(row.getFieldCount()).isEqualTo(2);
+                        int a = row.getInt(0);
+                        assertThat(a).isEqualTo(seen);
+                        if (a % 2 == 0) {
+                            assertThat(row.getString(1).toString()).isEqualTo("v" + a);
+                        } else {
+                            assertThat(row.isNullAt(1)).isTrue();
+                        }
+                        seen++;
+                    }
+                }
+                assertThat(seen).isEqualTo(10);
+            }
         }
     }
 
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java b/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
index 00eb8dd512..bc472d0e51 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
@@ -32,14 +32,15 @@
 import java.io.IOException;
 
 import static org.apache.fluss.record.LogRecordBatchFormat.LENGTH_LENGTH;
+
 /**
- * An immutable log record for @CompactedRow which can be directly persisted. The on-wire schema is
- * identical to IndexedLogRecord but the row payload uses the CompactedRow binary format:
+ * An immutable log record for {@link CompactedRow} which can be directly persisted. The on-wire
+ * schema is identical to IndexedLogRecord but the row payload uses the CompactedRow binary format:
  *
  * <ul>
- *   <li>Length => int32 (total number of bytes following this length field)</li>
- *   <li>Attributes => int8 (low 4 bits encode {@link ChangeType})</li>
- *   <li>Value => {@link CompactedRow} (bytes in compacted row format)</li>
+ *   <li>Length => int32 (total number of bytes following this length field)
+ *   <li>Attributes => int8 (low 4 bits encode {@link ChangeType})
+ *   <li>Value => {@link CompactedRow} (bytes in compacted row format)
  * </ul>
  *
  * <p>Differences vs {@link IndexedLogRecord}: - Uses CompactedRow encoding which is space-optimized
@@ -48,12 +49,6 @@
  * in a CompactedRow with a {@link CompactedRowDeserializer} and only decode to object values when a
  * field is accessed. - The record header (Length + Attributes) layout and attribute semantics are
  * the same.
- * Differences vs {@link IndexedLogRecord}:
- * - Uses CompactedRow encoding which is space-optimized (VLQ for ints/longs, per-row null bitset) and
- *   trades CPU for smaller storage; random access to fields is not supported without decoding.
- * - Deserialization is lazy: we wrap the underlying bytes in a CompactedRow with a
- *   {@link CompactedRowDeserializer} and only decode to object values when a field is accessed.
- * - The record header (Length + Attributes) layout and attribute semantics are the same.
  *
  * <p>The offset computes the difference relative to the base offset of the batch containing this
  * record.
@@ -170,12 +165,8 @@ private static int calculateSizeInBytes(BinaryRow row) {
         int size = 1; // one byte for attributes
         size += row.getSizeInBytes();
         return size;
-        int rowOffset = LENGTH_LENGTH + ATTRIBUTES_LENGTH;
-        return deserializeCompactedRow(
-                sizeInBytes - rowOffset, segment, offset + rowOffset, fieldTypes, LogFormat.COMPACTED);
     }
 
-
     private static InternalRow deserializeCompactedRow(
             int length,
             MemorySegment segment,
@@ -183,11 +174,13 @@ private static InternalRow deserializeCompactedRow(
             DataType[] fieldTypes,
             LogFormat logFormat) {
         if (logFormat == LogFormat.COMPACTED) {
-            CompactedRow compactedRow = new CompactedRow(fieldTypes.length, compactedDeserializer);
+            CompactedRow compactedRow =
+                    new CompactedRow(fieldTypes.length, new CompactedRowDeserializer(fieldTypes));
             compactedRow.pointTo(segment, position, length);
             return compactedRow;
         } else {
-            throw new IllegalArgumentException("No such compacted row deserializer for: " + logFormat);
+            throw new IllegalArgumentException(
+                    "No such compacted row deserializer for: " + logFormat);
         }
     }
 }
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java b/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java
index d3ee22057c..6d3ee99af9 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/LogRecordReadContext.java
@@ -79,12 +79,6 @@ public static LogRecordReadContext createReadContext(
                     Projection.of(
                             IntStream.range(0, rowType.getFieldCount()).toArray(),
                             tableInfo.getSchema());
-        } else {
-            // Explicitly forbid any projection for COMPACTED log format
-            if (logFormat == LogFormat.COMPACTED) {
-                throw new IllegalArgumentException(
-                        "Projection is not supported for COMPACTED log format. Please remove projection.");
-            }
         }
 
         if (logFormat == LogFormat.ARROW) {

From cf23fc32faa61f3aac99b1f845dea76c7f5d9a01 Mon Sep 17 00:00:00 2001
From: Jark Wu <jark@apache.org>
Date: Thu, 25 Dec 2025 16:19:44 +0800
Subject: [PATCH 27/27] improve some code

---
 .idea/vcs.xml                                 |   2 +-
 .../client/table/writer/UpsertWriterImpl.java |  11 +-
 .../write/AbstractRowLogWriteBatch.java       |  58 +++----
 .../client/write/CompactedLogWriteBatch.java  |  70 +-------
 .../client/write/IndexedLogWriteBatch.java    |  70 +-------
 .../fluss/client/write/RecordAccumulator.java | 118 +++++++------
 .../fluss/client/write/WriteFormat.java       |  48 +++++-
 .../fluss/client/write/WriteRecord.java       |  12 +-
 .../fluss/client/table/FlussTableITCase.java  | 155 ++++++------------
 .../fluss/client/write/KvWriteBatchTest.java  |   1 +
 .../fluss/record/CompactedLogRecord.java      |  19 ---
 .../MemoryLogRecordsCompactedBuilder.java     |   3 +-
 .../MemoryLogRecordsIndexedBuilder.java       |   2 +-
 ...r.java => MemoryLogRecordsRowBuilder.java} |  16 +-
 .../MemoryLogRecordsCompactedBuilderTest.java |  68 ++++----
 15 files changed, 247 insertions(+), 406 deletions(-)
 rename fluss-common/src/main/java/org/apache/fluss/record/{AbstractRowMemoryLogRecordsBuilder.java => MemoryLogRecordsRowBuilder.java} (93%)

diff --git a/.idea/vcs.xml b/.idea/vcs.xml
index ed5900ccbe..b0576b2675 100644
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@@ -17,4 +17,4 @@
   <component name="VcsDirectoryMappings">
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
   </component>
-</project>
\ No newline at end of file
+</project>
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/table/writer/UpsertWriterImpl.java b/fluss-client/src/main/java/org/apache/fluss/client/table/writer/UpsertWriterImpl.java
index 39f65592c1..20e5bcc5e5 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/table/writer/UpsertWriterImpl.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/table/writer/UpsertWriterImpl.java
@@ -17,6 +17,7 @@
 
 package org.apache.fluss.client.table.writer;
 
+import org.apache.fluss.client.write.WriteFormat;
 import org.apache.fluss.client.write.WriteRecord;
 import org.apache.fluss.client.write.WriterClient;
 import org.apache.fluss.metadata.DataLakeFormat;
@@ -50,6 +51,7 @@ class UpsertWriterImpl extends AbstractTableWriter implements UpsertWriter {
     private final KeyEncoder bucketKeyEncoder;
 
     private final KvFormat kvFormat;
+    private final WriteFormat writeFormat;
     private final RowEncoder rowEncoder;
     private final FieldGetter[] fieldGetters;
     private final TableInfo tableInfo;
@@ -78,6 +80,7 @@ class UpsertWriterImpl extends AbstractTableWriter implements UpsertWriter {
                         : KeyEncoder.of(rowType, tableInfo.getBucketKeys(), lakeFormat);
 
         this.kvFormat = tableInfo.getTableConfig().getKvFormat();
+        this.writeFormat = WriteFormat.fromKvFormat(this.kvFormat);
         this.rowEncoder = RowEncoder.create(kvFormat, rowType);
         this.fieldGetters = InternalRow.createFieldGetters(rowType);
         this.tableInfo = tableInfo;
@@ -164,6 +167,7 @@ public CompletableFuture<UpsertResult> upsert(InternalRow row) {
                         encodeRow(row),
                         key,
                         bucketKey,
+                        writeFormat,
                         targetColumns);
         return send(record).thenApply(ignored -> UPSERT_SUCCESS);
     }
@@ -182,7 +186,12 @@ public CompletableFuture<DeleteResult> delete(InternalRow row) {
                 bucketKeyEncoder == primaryKeyEncoder ? key : bucketKeyEncoder.encodeKey(row);
         WriteRecord record =
                 WriteRecord.forDelete(
-                        tableInfo, getPhysicalPath(row), key, bucketKey, targetColumns);
+                        tableInfo,
+                        getPhysicalPath(row),
+                        key,
+                        bucketKey,
+                        writeFormat,
+                        targetColumns);
         return send(record).thenApply(ignored -> DELETE_SUCCESS);
     }
 
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/AbstractRowLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/AbstractRowLogWriteBatch.java
index ddb345a63b..3c61cce82d 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/AbstractRowLogWriteBatch.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/AbstractRowLogWriteBatch.java
@@ -22,6 +22,7 @@
 import org.apache.fluss.memory.MemorySegment;
 import org.apache.fluss.metadata.PhysicalTablePath;
 import org.apache.fluss.record.ChangeType;
+import org.apache.fluss.record.MemoryLogRecordsRowBuilder;
 import org.apache.fluss.record.bytesview.BytesView;
 import org.apache.fluss.row.InternalRow;
 
@@ -38,32 +39,8 @@
  */
 abstract class AbstractRowLogWriteBatch<R> extends WriteBatch {
 
-    interface RecordsBuilderAdapter<T> {
-        boolean hasRoomFor(T row);
-
-        void append(ChangeType changeType, T row) throws Exception;
-
-        BytesView build() throws IOException;
-
-        boolean isClosed();
-
-        void close() throws Exception;
-
-        void setWriterState(long writerId, int batchSequence);
-
-        long writerId();
-
-        int batchSequence();
-
-        void abort();
-
-        void resetWriterState(long writerId, int batchSequence);
-
-        int getSizeInBytes();
-    }
-
     private final AbstractPagedOutputView outputView;
-    private final RecordsBuilderAdapter<R> builder;
+    private final MemoryLogRecordsRowBuilder<R> recordsBuilder;
     private final String buildErrorMessage;
 
     protected AbstractRowLogWriteBatch(
@@ -71,11 +48,11 @@ protected AbstractRowLogWriteBatch(
             PhysicalTablePath physicalTablePath,
             long createdMs,
             AbstractPagedOutputView outputView,
-            RecordsBuilderAdapter<R> builder,
+            MemoryLogRecordsRowBuilder<R> recordsBuilder,
             String buildErrorMessage) {
         super(bucketId, physicalTablePath, createdMs);
         this.outputView = outputView;
-        this.builder = builder;
+        this.recordsBuilder = recordsBuilder;
         this.buildErrorMessage = buildErrorMessage;
     }
 
@@ -90,10 +67,10 @@ public boolean tryAppend(WriteRecord writeRecord, WriteCallback callback) throws
                 "target columns must be null for log record");
 
         R row = requireAndCastRow(rowObj);
-        if (!builder.hasRoomFor(row) || isClosed()) {
+        if (!recordsBuilder.hasRoomFor(row) || isClosed()) {
             return false;
         }
-        builder.append(ChangeType.APPEND_ONLY, row);
+        recordsBuilder.append(ChangeType.APPEND_ONLY, row);
         recordCount++;
         callbacks.add(callback);
         return true;
@@ -101,10 +78,15 @@ public boolean tryAppend(WriteRecord writeRecord, WriteCallback callback) throws
 
     protected abstract R requireAndCastRow(InternalRow row);
 
+    @Override
+    public boolean isLogBatch() {
+        return true;
+    }
+
     @Override
     public BytesView build() {
         try {
-            return builder.build();
+            return recordsBuilder.build();
         } catch (IOException e) {
             throw new FlussRuntimeException(buildErrorMessage, e);
         }
@@ -112,12 +94,12 @@ public BytesView build() {
 
     @Override
     public boolean isClosed() {
-        return builder.isClosed();
+        return recordsBuilder.isClosed();
     }
 
     @Override
     public void close() throws Exception {
-        builder.close();
+        recordsBuilder.close();
         reopened = false;
     }
 
@@ -128,32 +110,32 @@ public List<MemorySegment> pooledMemorySegments() {
 
     @Override
     public void setWriterState(long writerId, int batchSequence) {
-        builder.setWriterState(writerId, batchSequence);
+        recordsBuilder.setWriterState(writerId, batchSequence);
     }
 
     @Override
     public long writerId() {
-        return builder.writerId();
+        return recordsBuilder.writerId();
     }
 
     @Override
     public int batchSequence() {
-        return builder.batchSequence();
+        return recordsBuilder.batchSequence();
     }
 
     @Override
     public void abortRecordAppends() {
-        builder.abort();
+        recordsBuilder.abort();
     }
 
     @Override
     public void resetWriterState(long writerId, int batchSequence) {
         super.resetWriterState(writerId, batchSequence);
-        builder.resetWriterState(writerId, batchSequence);
+        recordsBuilder.resetWriterState(writerId, batchSequence);
     }
 
     @Override
     public int estimatedSizeInBytes() {
-        return builder.getSizeInBytes();
+        return recordsBuilder.getSizeInBytes();
     }
 }
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
index 58722e1f20..19366a4dc7 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/CompactedLogWriteBatch.java
@@ -20,17 +20,13 @@
 import org.apache.fluss.annotation.Internal;
 import org.apache.fluss.memory.AbstractPagedOutputView;
 import org.apache.fluss.metadata.PhysicalTablePath;
-import org.apache.fluss.record.ChangeType;
 import org.apache.fluss.record.MemoryLogRecordsCompactedBuilder;
-import org.apache.fluss.record.bytesview.BytesView;
 import org.apache.fluss.row.InternalRow;
 import org.apache.fluss.row.compacted.CompactedRow;
 import org.apache.fluss.rpc.messages.ProduceLogRequest;
 
 import javax.annotation.concurrent.NotThreadSafe;
 
-import java.io.IOException;
-
 import static org.apache.fluss.utils.Preconditions.checkArgument;
 
 /**
@@ -55,74 +51,10 @@ public CompactedLogWriteBatch(
                 physicalTablePath,
                 createdMs,
                 outputView,
-                new RecordsBuilderAdapter<CompactedRow>() {
-                    private final MemoryLogRecordsCompactedBuilder delegate =
-                            MemoryLogRecordsCompactedBuilder.builder(
-                                    schemaId, writeLimit, outputView, true);
-
-                    @Override
-                    public boolean hasRoomFor(CompactedRow row) {
-                        return delegate.hasRoomFor(row);
-                    }
-
-                    @Override
-                    public void append(ChangeType changeType, CompactedRow row) throws Exception {
-                        delegate.append(changeType, row);
-                    }
-
-                    @Override
-                    public BytesView build() throws IOException {
-                        return delegate.build();
-                    }
-
-                    @Override
-                    public boolean isClosed() {
-                        return delegate.isClosed();
-                    }
-
-                    @Override
-                    public void close() throws Exception {
-                        delegate.close();
-                    }
-
-                    @Override
-                    public void setWriterState(long writerId, int batchSequence) {
-                        delegate.setWriterState(writerId, batchSequence);
-                    }
-
-                    @Override
-                    public long writerId() {
-                        return delegate.writerId();
-                    }
-
-                    @Override
-                    public int batchSequence() {
-                        return delegate.batchSequence();
-                    }
-
-                    @Override
-                    public void abort() {
-                        delegate.abort();
-                    }
-
-                    @Override
-                    public void resetWriterState(long writerId, int batchSequence) {
-                        delegate.resetWriterState(writerId, batchSequence);
-                    }
-
-                    @Override
-                    public int getSizeInBytes() {
-                        return delegate.getSizeInBytes();
-                    }
-                },
+                MemoryLogRecordsCompactedBuilder.builder(schemaId, writeLimit, outputView, true),
                 "Failed to build compacted log record batch.");
     }
 
-    @Override
-    public boolean isLogBatch() {
-        return true;
-    }
-
     @Override
     protected CompactedRow requireAndCastRow(InternalRow row) {
         checkArgument(
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java b/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
index 4b5d23768e..c70dd83a8a 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/IndexedLogWriteBatch.java
@@ -20,16 +20,12 @@
 import org.apache.fluss.annotation.Internal;
 import org.apache.fluss.memory.AbstractPagedOutputView;
 import org.apache.fluss.metadata.PhysicalTablePath;
-import org.apache.fluss.record.ChangeType;
 import org.apache.fluss.record.MemoryLogRecordsIndexedBuilder;
-import org.apache.fluss.record.bytesview.BytesView;
 import org.apache.fluss.row.indexed.IndexedRow;
 import org.apache.fluss.rpc.messages.ProduceLogRequest;
 
 import javax.annotation.concurrent.NotThreadSafe;
 
-import java.io.IOException;
-
 import static org.apache.fluss.utils.Preconditions.checkArgument;
 
 /**
@@ -54,74 +50,10 @@ public IndexedLogWriteBatch(
                 physicalTablePath,
                 createdMs,
                 outputView,
-                new RecordsBuilderAdapter<IndexedRow>() {
-                    private final MemoryLogRecordsIndexedBuilder delegate =
-                            MemoryLogRecordsIndexedBuilder.builder(
-                                    schemaId, writeLimit, outputView, true);
-
-                    @Override
-                    public boolean hasRoomFor(IndexedRow row) {
-                        return delegate.hasRoomFor(row);
-                    }
-
-                    @Override
-                    public void append(ChangeType changeType, IndexedRow row) throws Exception {
-                        delegate.append(changeType, row);
-                    }
-
-                    @Override
-                    public BytesView build() throws IOException {
-                        return delegate.build();
-                    }
-
-                    @Override
-                    public boolean isClosed() {
-                        return delegate.isClosed();
-                    }
-
-                    @Override
-                    public void close() throws Exception {
-                        delegate.close();
-                    }
-
-                    @Override
-                    public void setWriterState(long writerId, int batchSequence) {
-                        delegate.setWriterState(writerId, batchSequence);
-                    }
-
-                    @Override
-                    public long writerId() {
-                        return delegate.writerId();
-                    }
-
-                    @Override
-                    public int batchSequence() {
-                        return delegate.batchSequence();
-                    }
-
-                    @Override
-                    public void abort() {
-                        delegate.abort();
-                    }
-
-                    @Override
-                    public void resetWriterState(long writerId, int batchSequence) {
-                        delegate.resetWriterState(writerId, batchSequence);
-                    }
-
-                    @Override
-                    public int getSizeInBytes() {
-                        return delegate.getSizeInBytes();
-                    }
-                },
+                MemoryLogRecordsIndexedBuilder.builder(schemaId, writeLimit, outputView, true),
                 "Failed to build indexed log record batch.");
     }
 
-    @Override
-    public boolean isLogBatch() {
-        return true;
-    }
-
     @Override
     protected IndexedRow requireAndCastRow(org.apache.fluss.row.InternalRow row) {
         checkArgument(row instanceof IndexedRow, "row must be IndexRow for indexed log table");
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/RecordAccumulator.java b/fluss-client/src/main/java/org/apache/fluss/client/write/RecordAccumulator.java
index 16911014b7..0c834a49f1 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/RecordAccumulator.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/RecordAccumulator.java
@@ -581,54 +581,15 @@ private RecordAppendResult appendNewBatch(
         PreAllocatedPagedOutputView outputView = new PreAllocatedPagedOutputView(segments);
         int schemaId = tableInfo.getSchemaId();
         WriteFormat writeFormat = writeRecord.getWriteFormat();
-        // If the table is kv table we need to create a kv batch, otherwise we create a log batch.
-        final WriteBatch batch;
-        if (writeFormat == WriteFormat.KV) {
-            batch =
-                    new KvWriteBatch(
-                            bucketId,
-                            physicalTablePath,
-                            tableInfo.getSchemaId(),
-                            tableInfo.getTableConfig().getKvFormat(),
-                            outputView.getPreAllocatedSize(),
-                            outputView,
-                            writeRecord.getTargetColumns(),
-                            clock.milliseconds());
-        } else if (writeFormat == WriteFormat.ARROW_LOG) {
-            ArrowWriter arrowWriter =
-                    arrowWriterPool.getOrCreateWriter(
-                            tableInfo.getTableId(),
-                            schemaId,
-                            outputView.getPreAllocatedSize(),
-                            tableInfo.getRowType(),
-                            tableInfo.getTableConfig().getArrowCompressionInfo());
-            batch =
-                    new ArrowLogWriteBatch(
-                            bucketId,
-                            physicalTablePath,
-                            tableInfo.getSchemaId(),
-                            arrowWriter,
-                            outputView,
-                            clock.milliseconds());
-        } else if (writeFormat == WriteFormat.COMPACTED_LOG) {
-            batch =
-                    new CompactedLogWriteBatch(
-                            bucketId,
-                            physicalTablePath,
-                            schemaId,
-                            outputView.getPreAllocatedSize(),
-                            outputView,
-                            clock.milliseconds());
-        } else {
-            batch =
-                    new IndexedLogWriteBatch(
-                            bucketId,
-                            physicalTablePath,
-                            tableInfo.getSchemaId(),
-                            outputView.getPreAllocatedSize(),
-                            outputView,
-                            clock.milliseconds());
-        }
+        final WriteBatch batch =
+                createWriteBatch(
+                        writeRecord,
+                        bucketId,
+                        tableInfo,
+                        writeFormat,
+                        physicalTablePath,
+                        outputView,
+                        schemaId);
 
         batch.tryAppend(writeRecord, callback);
         deque.addLast(batch);
@@ -636,6 +597,67 @@ private RecordAppendResult appendNewBatch(
         return new RecordAppendResult(deque.size() > 1 || batch.isClosed(), true, false);
     }
 
+    private WriteBatch createWriteBatch(
+            WriteRecord writeRecord,
+            int bucketId,
+            TableInfo tableInfo,
+            WriteFormat writeFormat,
+            PhysicalTablePath physicalTablePath,
+            PreAllocatedPagedOutputView outputView,
+            int schemaId) {
+        // If the table is kv table we need to create a kv batch, otherwise we create a log batch.
+        switch (writeFormat) {
+            case COMPACTED_KV:
+            case INDEXED_KV:
+                return new KvWriteBatch(
+                        bucketId,
+                        physicalTablePath,
+                        tableInfo.getSchemaId(),
+                        writeFormat.toKvFormat(),
+                        outputView.getPreAllocatedSize(),
+                        outputView,
+                        writeRecord.getTargetColumns(),
+                        clock.milliseconds());
+
+            case ARROW_LOG:
+                ArrowWriter arrowWriter =
+                        arrowWriterPool.getOrCreateWriter(
+                                tableInfo.getTableId(),
+                                schemaId,
+                                outputView.getPreAllocatedSize(),
+                                tableInfo.getRowType(),
+                                tableInfo.getTableConfig().getArrowCompressionInfo());
+                return new ArrowLogWriteBatch(
+                        bucketId,
+                        physicalTablePath,
+                        tableInfo.getSchemaId(),
+                        arrowWriter,
+                        outputView,
+                        clock.milliseconds());
+
+            case COMPACTED_LOG:
+                return new CompactedLogWriteBatch(
+                        bucketId,
+                        physicalTablePath,
+                        schemaId,
+                        outputView.getPreAllocatedSize(),
+                        outputView,
+                        clock.milliseconds());
+
+            case INDEXED_LOG:
+                return new IndexedLogWriteBatch(
+                        bucketId,
+                        physicalTablePath,
+                        tableInfo.getSchemaId(),
+                        outputView.getPreAllocatedSize(),
+                        outputView,
+                        clock.milliseconds());
+
+            default:
+                throw new UnsupportedOperationException("Unsupported write format: " + writeFormat);
+        }
+    }
+
     private RecordAppendResult tryAppend(
             WriteRecord writeRecord, WriteCallback callback, Deque<WriteBatch> deque)
             throws Exception {
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteFormat.java b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteFormat.java
index 7b36b8eacf..24f07c9ce9 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteFormat.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteFormat.java
@@ -18,12 +18,52 @@
 package org.apache.fluss.client.write;
 
 import org.apache.fluss.annotation.Internal;
+import org.apache.fluss.metadata.KvFormat;
 
 /** The format of the write record. */
 @Internal
 public enum WriteFormat {
-    ARROW_LOG,
-    INDEXED_LOG,
-    COMPACTED_LOG,
-    KV
+    ARROW_LOG(true),
+    INDEXED_LOG(true),
+    COMPACTED_LOG(true),
+    INDEXED_KV(false),
+    COMPACTED_KV(false);
+
+    private final boolean isLog;
+
+    WriteFormat(boolean isLog) {
+        this.isLog = isLog;
+    }
+
+    public boolean isLog() {
+        return isLog;
+    }
+
+    public boolean isKv() {
+        return !isLog;
+    }
+
+    /** Converts this {@link WriteFormat} to a {@link KvFormat}. */
+    public KvFormat toKvFormat() {
+        switch (this) {
+            case INDEXED_KV:
+                return KvFormat.INDEXED;
+            case COMPACTED_KV:
+                return KvFormat.COMPACTED;
+            default:
+                throw new IllegalArgumentException("WriteFormat " + this + " is not a KvFormat");
+        }
+    }
+
+    /** Converts a {@link KvFormat} to a {@link WriteFormat}. */
+    public static WriteFormat fromKvFormat(KvFormat kvFormat) {
+        switch (kvFormat) {
+            case INDEXED:
+                return INDEXED_KV;
+            case COMPACTED:
+                return COMPACTED_KV;
+            default:
+                throw new IllegalArgumentException("Unknown KvFormat: " + kvFormat);
+        }
+    }
 }
diff --git a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
index 05de608fcb..9265c5f779 100644
--- a/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
+++ b/fluss-client/src/main/java/org/apache/fluss/client/write/WriteRecord.java
@@ -33,6 +33,7 @@
 import static org.apache.fluss.record.DefaultKvRecordBatch.RECORD_BATCH_HEADER_SIZE;
 import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
 import static org.apache.fluss.record.LogRecordBatchFormat.recordBatchHeaderSize;
+import static org.apache.fluss.utils.Preconditions.checkArgument;
 import static org.apache.fluss.utils.Preconditions.checkNotNull;
 
 /**
@@ -49,10 +50,12 @@ public static WriteRecord forUpsert(
             BinaryRow row,
             byte[] key,
             byte[] bucketKey,
+            WriteFormat writeFormat,
             @Nullable int[] targetColumns) {
         checkNotNull(row, "row must not be null");
         checkNotNull(key, "key must not be null");
         checkNotNull(bucketKey, "bucketKey must not be null");
+        checkArgument(writeFormat.isKv(), "writeFormat must be a KV format");
         int estimatedSizeInBytes = DefaultKvRecord.sizeOf(key, row) + RECORD_BATCH_HEADER_SIZE;
         return new WriteRecord(
                 tableInfo,
@@ -60,7 +63,7 @@ public static WriteRecord forUpsert(
                 key,
                 bucketKey,
                 row,
-                WriteFormat.KV,
+                writeFormat,
                 targetColumns,
                 estimatedSizeInBytes);
     }
@@ -71,9 +74,11 @@ public static WriteRecord forDelete(
             PhysicalTablePath tablePath,
             byte[] key,
             byte[] bucketKey,
+            WriteFormat writeFormat,
             @Nullable int[] targetColumns) {
         checkNotNull(key, "key must not be null");
         checkNotNull(bucketKey, "key must not be null");
+        checkArgument(writeFormat.isKv(), "writeFormat must be a KV format");
         int estimatedSizeInBytes = DefaultKvRecord.sizeOf(key, null) + RECORD_BATCH_HEADER_SIZE;
         return new WriteRecord(
                 tableInfo,
@@ -81,7 +86,7 @@ public static WriteRecord forDelete(
                 key,
                 bucketKey,
                 null,
-                WriteFormat.KV,
+                writeFormat,
                 targetColumns,
                 estimatedSizeInBytes);
     }
@@ -134,7 +139,8 @@ public static WriteRecord forCompactedAppend(
             CompactedRow row,
             @Nullable byte[] bucketKey) {
         checkNotNull(row);
-        int estimatedSizeInBytes = CompactedLogRecord.sizeOf(row) + RECORD_BATCH_HEADER_SIZE;
+        int estimatedSizeInBytes =
+                CompactedLogRecord.sizeOf(row) + recordBatchHeaderSize(CURRENT_LOG_MAGIC_VALUE);
         return new WriteRecord(
                 tableInfo,
                 tablePath,
diff --git a/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java b/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
index 7b6b9c8227..27b6690a9e 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/table/FlussTableITCase.java
@@ -1451,28 +1451,52 @@ void testPkUpsertAndPollWithCompactedLog() throws Exception {
             }
             upsertWriter.flush();
 
-            LogScanner logScanner = createLogScanner(table);
-            subscribeFromBeginning(logScanner, table);
-            int count = 0;
-            while (count < expectedSize) {
-                ScanRecords scanRecords = logScanner.poll(Duration.ofSeconds(1));
-                for (ScanRecord scanRecord : scanRecords) {
-                    assertThat(scanRecord.getChangeType()).isEqualTo(ChangeType.INSERT);
-                    InternalRow rr = scanRecord.getRow();
-                    assertThat(rr.getFieldCount()).isEqualTo(4);
-                    assertThat(rr.getInt(0)).isEqualTo(count);
-                    assertThat(rr.getInt(1)).isEqualTo(100);
-                    if (count % 2 == 0) {
-                        assertThat(rr.getString(2).toString()).isEqualTo("hello, friend" + count);
-                    } else {
-                        assertThat(rr.isNullAt(2)).isTrue();
+            // normal scan
+            try (LogScanner logScanner = createLogScanner(table)) {
+                subscribeFromBeginning(logScanner, table);
+                int count = 0;
+                while (count < expectedSize) {
+                    ScanRecords scanRecords = logScanner.poll(Duration.ofSeconds(1));
+                    for (ScanRecord scanRecord : scanRecords) {
+                        assertThat(scanRecord.getChangeType()).isEqualTo(ChangeType.INSERT);
+                        InternalRow rr = scanRecord.getRow();
+                        assertThat(rr.getFieldCount()).isEqualTo(4);
+                        assertThat(rr.getInt(0)).isEqualTo(count);
+                        assertThat(rr.getInt(1)).isEqualTo(100);
+                        if (count % 2 == 0) {
+                            assertThat(rr.getString(2).toString())
+                                    .isEqualTo("hello, friend" + count);
+                        } else {
+                            assertThat(rr.isNullAt(2)).isTrue();
+                        }
+                        assertThat(rr.getLong(3)).isEqualTo(count * 10L);
+                        count++;
                     }
-                    assertThat(rr.getLong(3)).isEqualTo(count * 10L);
-                    count++;
                 }
+                assertThat(count).isEqualTo(expectedSize);
+            }
+
+            // Creating a projected log scanner for COMPACTED should work
+            try (LogScanner scanner = createLogScanner(table, new int[] {0, 2})) {
+                subscribeFromBeginning(scanner, table);
+                int count = 0;
+                while (count < expectedSize) {
+                    ScanRecords records = scanner.poll(Duration.ofSeconds(1));
+                    for (ScanRecord record : records) {
+                        InternalRow row = record.getRow();
+                        assertThat(row.getFieldCount()).isEqualTo(2);
+                        assertThat(row.getInt(0)).isEqualTo(count);
+                        if (count % 2 == 0) {
+                            assertThat(row.getString(1).toString())
+                                    .isEqualTo("hello, friend" + count);
+                        } else {
+                            assertThat(row.isNullAt(1)).isTrue();
+                        }
+                        count++;
+                    }
+                }
+                assertThat(count).isEqualTo(expectedSize);
             }
-            assertThat(count).isEqualTo(expectedSize);
-            logScanner.close();
         }
     }
 
@@ -1521,15 +1545,12 @@ void testPkUpdateAndDeleteWithCompactedLog() throws Exception {
                     assertThat(r.getChangeType()).isEqualTo(expected[seen]);
                     InternalRow row = r.getRow();
                     assertThat(row.getInt(0)).isEqualTo(1);
-                    if (expected[seen] == ChangeType.INSERT
-                            || expected[seen] == ChangeType.UPDATE_BEFORE
-                            || expected[seen] == ChangeType.UPDATE_AFTER) {
-                        // value field present
-                        if (expected[seen] == ChangeType.UPDATE_AFTER) {
-                            assertThat(row.getInt(1)).isEqualTo(20);
-                        } else {
-                            assertThat(row.getInt(1)).isEqualTo(10);
-                        }
+                    // value field present
+                    if (expected[seen] == ChangeType.UPDATE_AFTER
+                            || expected[seen] == ChangeType.DELETE) {
+                        assertThat(row.getInt(1)).isEqualTo(20);
+                    } else {
+                        assertThat(row.getInt(1)).isEqualTo(10);
                     }
                     seen++;
                 }
@@ -1539,56 +1560,6 @@ void testPkUpdateAndDeleteWithCompactedLog() throws Exception {
         }
     }
 
-    @Test
-    void testPkCompactedProject() throws Exception {
-        Schema schema =
-                Schema.newBuilder()
-                        .column("a", DataTypes.INT())
-                        .column("b", DataTypes.INT())
-                        .column("c", DataTypes.STRING())
-                        .primaryKey("a")
-                        .build();
-        TableDescriptor td =
-                TableDescriptor.builder()
-                        .schema(schema)
-                        .kvFormat(KvFormat.COMPACTED)
-                        .logFormat(LogFormat.COMPACTED)
-                        .build();
-        TablePath path = TablePath.of("test_db_1", "test_pk_compacted_project");
-        createTable(path, td, false);
-
-        try (Table table = conn.getTable(path)) {
-            UpsertWriter upsert = table.newUpsert().createWriter();
-            for (int i = 0; i < 10; i++) {
-                String v = i % 2 == 0 ? "v" + i : null;
-                upsert.upsert(row(i, 100 + i, v));
-            }
-            upsert.flush();
-
-            // Creating a projected log scanner for COMPACTED should work
-            try (LogScanner scanner = createLogScanner(table, new int[] {0, 2})) {
-                subscribeFromBeginning(scanner, table);
-                int seen = 0;
-                while (seen < 10) {
-                    ScanRecords records = scanner.poll(Duration.ofSeconds(5));
-                    for (ScanRecord record : records) {
-                        InternalRow row = record.getRow();
-                        assertThat(row.getFieldCount()).isEqualTo(2);
-                        int a = row.getInt(0);
-                        assertThat(a).isEqualTo(seen);
-                        if (a % 2 == 0) {
-                            assertThat(row.getString(1).toString()).isEqualTo("v" + a);
-                        } else {
-                            assertThat(row.isNullAt(1)).isTrue();
-                        }
-                        seen++;
-                    }
-                }
-                assertThat(seen).isEqualTo(10);
-            }
-        }
-    }
-
     @Test
     void testPkCompactedPollFromLatestNoRecords() throws Exception {
         Schema schema =
@@ -1625,41 +1596,17 @@ void testPkCompactedPollFromLatestNoRecords() throws Exception {
                     seen++;
                 }
             }
-            scanner.close();
-        }
-    }
 
-    @Test
-    void testPkDeleteNonExistentEmitsNoRecords() throws Exception {
-        Schema schema =
-                Schema.newBuilder()
-                        .column("a", DataTypes.INT())
-                        .column("b", DataTypes.INT())
-                        .primaryKey("a")
-                        .build();
-        TableDescriptor td =
-                TableDescriptor.builder()
-                        .schema(schema)
-                        .kvFormat(KvFormat.COMPACTED)
-                        .logFormat(LogFormat.COMPACTED)
-                        .build();
-        TablePath path = TablePath.of("test_db_1", "test_pk_compacted_delete_missing");
-        createTable(path, td, false);
-
-        try (Table table = conn.getTable(path)) {
-            UpsertWriter upsert = table.newUpsert().createWriter();
             // delete non-existent key
             upsert.delete(row(42, 0));
             upsert.flush();
-
-            LogScanner scanner = createLogScanner(table);
-            subscribeFromBeginning(scanner, table);
-            int total = 0;
             // poll a few times to ensure no accidental records
+            int total = 0;
             for (int i = 0; i < 3; i++) {
                 total += scanner.poll(Duration.ofSeconds(1)).count();
             }
             assertThat(total).isEqualTo(0);
+
             scanner.close();
         }
     }
diff --git a/fluss-client/src/test/java/org/apache/fluss/client/write/KvWriteBatchTest.java b/fluss-client/src/test/java/org/apache/fluss/client/write/KvWriteBatchTest.java
index 82f6ee5906..c62c7b0297 100644
--- a/fluss-client/src/test/java/org/apache/fluss/client/write/KvWriteBatchTest.java
+++ b/fluss-client/src/test/java/org/apache/fluss/client/write/KvWriteBatchTest.java
@@ -207,6 +207,7 @@ protected WriteRecord createWriteRecord() {
                 row,
                 key,
                 key,
+                WriteFormat.COMPACTED_KV,
                 null);
     }
 
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java b/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
index bc472d0e51..fb7f2f3141 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/CompactedLogRecord.java
@@ -63,7 +63,6 @@ public class CompactedLogRecord implements LogRecord {
     private final long logOffset;
     private final long timestamp;
     private final DataType[] fieldTypes;
-    private final CompactedRowDeserializer compactedDeserializer;
 
     private MemorySegment segment;
     private int offset;
@@ -73,7 +72,6 @@ public class CompactedLogRecord implements LogRecord {
         this.logOffset = logOffset;
         this.timestamp = timestamp;
         this.fieldTypes = fieldTypes;
-        this.compactedDeserializer = new CompactedRowDeserializer(fieldTypes);
     }
 
     private void pointTo(MemorySegment segment, int offset, int sizeInBytes) {
@@ -166,21 +164,4 @@ private static int calculateSizeInBytes(BinaryRow row) {
         size += row.getSizeInBytes();
         return size;
     }
-
-    private static InternalRow deserializeCompactedRow(
-            int length,
-            MemorySegment segment,
-            int position,
-            DataType[] fieldTypes,
-            LogFormat logFormat) {
-        if (logFormat == LogFormat.COMPACTED) {
-            CompactedRow compactedRow =
-                    new CompactedRow(fieldTypes.length, new CompactedRowDeserializer(fieldTypes));
-            compactedRow.pointTo(segment, position, length);
-            return compactedRow;
-        } else {
-            throw new IllegalArgumentException(
-                    "No such compacted row deserializer for: " + logFormat);
-        }
-    }
 }
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
index e23aa5cc3b..13cda3325e 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilder.java
@@ -30,8 +30,7 @@
  * Default builder for {@link MemoryLogRecords} of log records in {@link LogFormat#COMPACTED}
  * format.
  */
-public class MemoryLogRecordsCompactedBuilder
-        extends AbstractRowMemoryLogRecordsBuilder<CompactedRow> {
+public class MemoryLogRecordsCompactedBuilder extends MemoryLogRecordsRowBuilder<CompactedRow> {
 
     private MemoryLogRecordsCompactedBuilder(
             long baseLogOffset,
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
index a713c34ee2..34688ef555 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsIndexedBuilder.java
@@ -29,7 +29,7 @@
  * Default builder for {@link MemoryLogRecords} of log records in {@link
  * org.apache.fluss.metadata.LogFormat#INDEXED} format.
  */
-public class MemoryLogRecordsIndexedBuilder extends AbstractRowMemoryLogRecordsBuilder<IndexedRow> {
+public class MemoryLogRecordsIndexedBuilder extends MemoryLogRecordsRowBuilder<IndexedRow> {
 
     private MemoryLogRecordsIndexedBuilder(
             long baseLogOffset,
diff --git a/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsRowBuilder.java
similarity index 93%
rename from fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java
rename to fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsRowBuilder.java
index daed34ff88..127503aa02 100644
--- a/fluss-common/src/main/java/org/apache/fluss/record/AbstractRowMemoryLogRecordsBuilder.java
+++ b/fluss-common/src/main/java/org/apache/fluss/record/MemoryLogRecordsRowBuilder.java
@@ -26,7 +26,6 @@
 
 import java.io.IOException;
 
-import static org.apache.fluss.record.LogRecordBatch.CURRENT_LOG_MAGIC_VALUE;
 import static org.apache.fluss.record.LogRecordBatchFormat.BASE_OFFSET_LENGTH;
 import static org.apache.fluss.record.LogRecordBatchFormat.LENGTH_LENGTH;
 import static org.apache.fluss.record.LogRecordBatchFormat.LOG_MAGIC_VALUE_V1;
@@ -40,7 +39,7 @@
 import static org.apache.fluss.utils.Preconditions.checkArgument;
 
 /** Abstract base builder for row-based MemoryLogRecords builders sharing common logic. */
-abstract class AbstractRowMemoryLogRecordsBuilder<T> implements AutoCloseable {
+public abstract class MemoryLogRecordsRowBuilder<T> implements AutoCloseable {
     protected static final int BUILDER_DEFAULT_OFFSET = 0;
 
     protected final long baseLogOffset;
@@ -60,7 +59,7 @@ abstract class AbstractRowMemoryLogRecordsBuilder<T> implements AutoCloseable {
     private volatile boolean isClosed;
     private boolean aborted = false;
 
-    protected AbstractRowMemoryLogRecordsBuilder(
+    protected MemoryLogRecordsRowBuilder(
             long baseLogOffset,
             int schemaId,
             int writeLimit,
@@ -88,17 +87,6 @@ protected AbstractRowMemoryLogRecordsBuilder(
         this.sizeInBytes = headerSize;
     }
 
-    protected AbstractRowMemoryLogRecordsBuilder(
-            int schemaId, int writeLimit, AbstractPagedOutputView outputView, boolean appendOnly) {
-        this(
-                BUILDER_DEFAULT_OFFSET,
-                schemaId,
-                writeLimit,
-                CURRENT_LOG_MAGIC_VALUE,
-                outputView,
-                appendOnly);
-    }
-
     /** Implement to return size of the record (including length field). */
     protected abstract int sizeOf(T row);
 
diff --git a/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java b/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java
index e576edb7a4..2a8d70c800 100644
--- a/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java
+++ b/fluss-common/src/test/java/org/apache/fluss/record/MemoryLogRecordsCompactedBuilderTest.java
@@ -39,7 +39,7 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 /** Tests for {@link MemoryLogRecordsCompactedBuilder}. */
-public class MemoryLogRecordsCompactedBuilderTest {
+class MemoryLogRecordsCompactedBuilderTest {
 
     @Test
     void testAppendAndBuild() throws Exception {
@@ -113,41 +113,43 @@ void testAbortSemantics() throws Exception {
     @Test
     void testNoRecordAppendAndBaseOffset() throws Exception {
         // base offset 0
-        MemoryLogRecordsCompactedBuilder builder = createBuilder(0, 1, 1024);
-        MemoryLogRecords records = MemoryLogRecords.pointToBytesView(builder.build());
-        assertThat(records.sizeInBytes())
-                .isEqualTo(
-                        LogRecordBatchFormat.recordBatchHeaderSize(
-                                DEFAULT_MAGIC)); // only batch header
-        LogRecordBatch batch = records.batches().iterator().next();
-        batch.ensureValid();
-        assertThat(batch.getRecordCount()).isEqualTo(0);
-        assertThat(batch.baseLogOffset()).isEqualTo(0);
-        assertThat(batch.lastLogOffset()).isEqualTo(0);
-        assertThat(batch.nextLogOffset()).isEqualTo(1);
-        try (LogRecordReadContext ctx =
-                        LogRecordReadContext.createCompactedRowReadContext(
-                                DATA1_ROW_TYPE, DEFAULT_SCHEMA_ID);
-                CloseableIterator<LogRecord> it = batch.records(ctx)) {
-            assertThat(it.hasNext()).isFalse();
+        try (MemoryLogRecordsCompactedBuilder builder = createBuilder(0, 1, 1024)) {
+            MemoryLogRecords records = MemoryLogRecords.pointToBytesView(builder.build());
+            assertThat(records.sizeInBytes())
+                    .isEqualTo(
+                            LogRecordBatchFormat.recordBatchHeaderSize(
+                                    DEFAULT_MAGIC)); // only batch header
+            LogRecordBatch batch = records.batches().iterator().next();
+            batch.ensureValid();
+            assertThat(batch.getRecordCount()).isEqualTo(0);
+            assertThat(batch.baseLogOffset()).isEqualTo(0);
+            assertThat(batch.lastLogOffset()).isEqualTo(0);
+            assertThat(batch.nextLogOffset()).isEqualTo(1);
+            try (LogRecordReadContext ctx =
+                            LogRecordReadContext.createCompactedRowReadContext(
+                                    DATA1_ROW_TYPE, DEFAULT_SCHEMA_ID);
+                    CloseableIterator<LogRecord> it = batch.records(ctx)) {
+                assertThat(it.hasNext()).isFalse();
+            }
         }
 
         // base offset 100
-        builder = createBuilder(100, 1, 1024);
-        records = MemoryLogRecords.pointToBytesView(builder.build());
-        assertThat(records.sizeInBytes())
-                .isEqualTo(LogRecordBatchFormat.recordBatchHeaderSize(DEFAULT_MAGIC));
-        batch = records.batches().iterator().next();
-        batch.ensureValid();
-        assertThat(batch.getRecordCount()).isEqualTo(0);
-        assertThat(batch.baseLogOffset()).isEqualTo(100);
-        assertThat(batch.lastLogOffset()).isEqualTo(100);
-        assertThat(batch.nextLogOffset()).isEqualTo(101);
-        try (LogRecordReadContext ctx =
-                        LogRecordReadContext.createCompactedRowReadContext(
-                                DATA1_ROW_TYPE, DEFAULT_SCHEMA_ID);
-                CloseableIterator<LogRecord> it = batch.records(ctx)) {
-            assertThat(it.hasNext()).isFalse();
+        try (MemoryLogRecordsCompactedBuilder builder = createBuilder(100, 1, 1024)) {
+            MemoryLogRecords records = MemoryLogRecords.pointToBytesView(builder.build());
+            assertThat(records.sizeInBytes())
+                    .isEqualTo(LogRecordBatchFormat.recordBatchHeaderSize(DEFAULT_MAGIC));
+            LogRecordBatch batch = records.batches().iterator().next();
+            batch.ensureValid();
+            assertThat(batch.getRecordCount()).isEqualTo(0);
+            assertThat(batch.baseLogOffset()).isEqualTo(100);
+            assertThat(batch.lastLogOffset()).isEqualTo(100);
+            assertThat(batch.nextLogOffset()).isEqualTo(101);
+            try (LogRecordReadContext ctx =
+                            LogRecordReadContext.createCompactedRowReadContext(
+                                    DATA1_ROW_TYPE, DEFAULT_SCHEMA_ID);
+                    CloseableIterator<LogRecord> it = batch.records(ctx)) {
+                assertThat(it.hasNext()).isFalse();
+            }
         }
     }