From 52a3e59bfddb4fbdfd8a472a2c59ce1b64bf67dd Mon Sep 17 00:00:00 2001
From: moke-HU <25567926679@qq.com>
Date: Fri, 14 Aug 2026 11:24:13 +0800
Subject: [PATCH 1/7] feat(paimon): upgrade connector runtime to 2.0.0

---
 .../apache/doris/paimon/PaimonJniScanner.java | 26 ++++++++--
 .../doris/paimon/PaimonJniScannerTest.java    | 37 +++++++-------
 .../fe-connector-paimon-hive-shade/pom.xml    | 18 +++++++
 .../org.apache.paimon.factories.Factory       |  2 +
 fe/fe-connector/fe-connector-paimon/pom.xml   | 16 ++++++
 .../connector/paimon/PaimonReaderOptions.java | 28 ++++++++---
 .../paimon/PaimonScanPlanProvider.java        | 14 +++---
 .../connector/paimon/FakePaimonTable.java     | 37 ++++++++++++++
 .../paimon/PaimonBackendBoundTableTest.java   | 50 +++++++++----------
 .../PaimonConnectorMetadataPartitionTest.java |  8 +--
 ...nnectorMetadataPartitionViewCacheTest.java |  2 +-
 .../PaimonConnectorMetadataReadAuthTest.java  |  3 +-
 .../paimon/PaimonReaderOptionsTest.java       | 40 ++++++++++-----
 .../paimon/PaimonScanMetricsTest.java         |  2 +-
 .../paimon/PaimonScanPlanProviderTest.java    | 14 ++++--
 fe/pom.xml                                    |  2 +-
 16 files changed, 214 insertions(+), 85 deletions(-)
 create mode 100644 fe/fe-connector/fe-connector-paimon-hive-shade/src/main/resources/META-INF/services/org.apache.paimon.factories.Factory

diff --git a/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonJniScanner.java b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonJniScanner.java
index 1dbc045d2e47a3..533be38efcbb4c 100644
--- a/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonJniScanner.java
+++ b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonJniScanner.java
@@ -41,6 +41,8 @@
 import org.apache.paimon.table.system.SystemTableLoader;
 import org.apache.paimon.types.DataType;
 import org.apache.paimon.types.TimestampType;
+import org.apache.paimon.utils.ChainTableUtils;
+import org.apache.paimon.utils.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -703,14 +705,14 @@ private static Table applyManifestParallelismBound(
             FallbackReadFileStoreTable pair = (FallbackReadFileStoreTable) table;
             FileStoreTable main = applyManifestParallelismBound(
                     pair.wrapped(), safeBound, materializeAbsent);
-            FileStoreTable fallback = applyManifestParallelismBound(
-                    pair.fallback(), safeBound, materializeAbsent);
-            if (main == pair.wrapped() && fallback == pair.fallback()) {
+            FileStoreTable other = applyManifestParallelismBound(
+                    pair.other(), safeBound, materializeAbsent);
+            if (main == pair.wrapped() && other == pair.other()) {
                 return table;
             }
             // Each branch owns an independent planner setting; a smaller sibling is not an
             // execution ceiling and must never throttle the other branch.
-            return new FallbackReadFileStoreTable(main, fallback);
+            return new FallbackReadFileStoreTable(main, other, isWrappedFirst(pair));
         }
 
         if (table instanceof DelegatedFileStoreTable) {
@@ -773,6 +775,20 @@ private static FileStoreTable applyManifestParallelismBound(
                 (Table) table, safeBound, materializeAbsent);
     }
 
+    static boolean isWrappedFirst(FallbackReadFileStoreTable table) {
+        Map<String, String> options = table.options();
+        // Match FileStoreTableFactory's construction order. Paimon does not expose wrappedFirst.
+        if (ChainTableUtils.isChainTable(options)) {
+            return true;
+        }
+        if (!StringUtils.isNullOrWhitespaceOnly(
+                options.get(CoreOptions.SCAN_FALLBACK_BRANCH.key()))) {
+            return true;
+        }
+        return StringUtils.isNullOrWhitespaceOnly(
+                options.get(CoreOptions.SCAN_PRIMARY_BRANCH.key()));
+    }
+
     private static FileStoreTable unwrapSystemPlanningSource(FileStoreTable table) {
         FileStoreTable current = table;
         // System wrappers dispatch fallback reads only when the fallback pair is their direct
@@ -801,7 +817,7 @@ private static void validateSerializedReaderOptions(Table table) {
         validateSerializedAsyncThreshold(table.options().get(CoreOptions.FILE_READER_ASYNC_THRESHOLD.key()));
         validateSerializedSplitTargetSize(table.options().get(CoreOptions.SOURCE_SPLIT_TARGET_SIZE.key()));
         if (table instanceof FallbackReadFileStoreTable) {
-            validateSerializedReaderOptions(((FallbackReadFileStoreTable) table).fallback());
+            validateSerializedReaderOptions(((FallbackReadFileStoreTable) table).other());
         }
         if (table instanceof DelegatedFileStoreTable) {
             validateSerializedReaderOptions(((DelegatedFileStoreTable) table).wrapped());
diff --git a/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniScannerTest.java b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniScannerTest.java
index 8fe6523ed74a2d..c72c863d8f3750 100644
--- a/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniScannerTest.java
+++ b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniScannerTest.java
@@ -159,7 +159,7 @@ public void testOldFeSerializedFallbackZeroReadBatchIsRejected() throws Exceptio
                 Collections.singletonMap(CoreOptions.READ_BATCH_SIZE.key(), "0"));
         Map<String, String> params = createBaseParams();
         params.put("serialized_table", Base64.getUrlEncoder().withoutPadding().encodeToString(
-                InstantiationUtil.serializeObject(new FallbackReadFileStoreTable(main, fallback))));
+                InstantiationUtil.serializeObject(new FallbackReadFileStoreTable(main, fallback, true))));
         PaimonJniScanner scanner = new PaimonJniScanner(1024, params);
         Method initTable = PaimonJniScanner.class.getDeclaredMethod("initTable");
         initTable.setAccessible(true);
@@ -181,7 +181,8 @@ public void testOldFeSerializedAsyncThresholdIsRejectedInEveryChild() throws Exc
         FileStoreTable main = serializableFileStoreTable(Collections.emptyMap());
         FileStoreTable fallback = serializableFileStoreTable(Collections.singletonMap(
                 CoreOptions.FILE_READER_ASYNC_THRESHOLD.key(), "2 GB"));
-        for (Table configuredTable : Arrays.asList(visible, new FallbackReadFileStoreTable(main, fallback))) {
+        for (Table configuredTable : Arrays.asList(
+                visible, new FallbackReadFileStoreTable(main, fallback, true))) {
             Map<String, String> params = createBaseParams();
             params.put("serialized_table", Base64.getUrlEncoder().withoutPadding().encodeToString(
                     InstantiationUtil.serializeObject(configuredTable)));
@@ -203,7 +204,7 @@ public void testOldFeSerializedSystemSourceRejectsZeroSplitTarget() throws Excep
         FileStoreTable fallback = serializableFileStoreTable(Collections.singletonMap(
                 CoreOptions.SOURCE_SPLIT_TARGET_SIZE.key(), "0 B"));
         Table filesTable = SystemTableLoader.load(
-                "files", new FallbackReadFileStoreTable(main, fallback));
+                "files", new FallbackReadFileStoreTable(main, fallback, true));
         Map<String, String> params = createBaseParams();
         params.put("serialized_table", Base64.getUrlEncoder().withoutPadding().encodeToString(
                 InstantiationUtil.serializeObject(filesTable)));
@@ -224,7 +225,7 @@ public void testOldFeSerializedSystemSourceRejectsFallbackZeroReadBatch() throws
         FileStoreTable fallback = serializableFileStoreTable(Collections.singletonMap(
                 CoreOptions.READ_BATCH_SIZE.key(), "0"));
         Table readerBackedSystemTable = SystemTableLoader.load(
-                "audit_log", new FallbackReadFileStoreTable(main, fallback));
+                "audit_log", new FallbackReadFileStoreTable(main, fallback, true));
         Map<String, String> params = createBaseParams();
         params.put("serialized_table", Base64.getUrlEncoder().withoutPadding().encodeToString(
                 InstantiationUtil.serializeObject(readerBackedSystemTable)));
@@ -246,10 +247,10 @@ public void testBackendManifestCapReachesHiddenFallbackPlanner() {
                 Collections.singletonMap(CoreOptions.SCAN_MANIFEST_PARALLELISM.key(), "8"));
 
         Table safe = PaimonJniScanner.applyBackendManifestParallelism(
-                new FallbackReadFileStoreTable(main, fallback), "8", 4);
+                new FallbackReadFileStoreTable(main, fallback, true), "8", 4);
 
         Assert.assertTrue(safe instanceof FallbackReadFileStoreTable);
-        Assert.assertEquals("4", ((FallbackReadFileStoreTable) safe).fallback()
+        Assert.assertEquals("4", ((FallbackReadFileStoreTable) safe).other()
                 .options().get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
     }
 
@@ -260,9 +261,9 @@ public void testAdvertisedFeCapStillChecksSerializedChildren() {
                 Collections.singletonMap(CoreOptions.SCAN_MANIFEST_PARALLELISM.key(), "200"));
 
         Table safe = PaimonJniScanner.applyBackendManifestParallelism(
-                new FallbackReadFileStoreTable(main, fallback), "32", 64);
+                new FallbackReadFileStoreTable(main, fallback, true), "32", 64);
 
-        Assert.assertEquals("32", ((FallbackReadFileStoreTable) safe).fallback()
+        Assert.assertEquals("32", ((FallbackReadFileStoreTable) safe).other()
                 .options().get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
     }
 
@@ -277,11 +278,11 @@ public void testOldFeManifestBackstopKeepsStableMaximum() {
         Table safeVisible = PaimonJniScanner.applyBackendManifestParallelism(
                 visible, null, 512);
         Table safeFallback = PaimonJniScanner.applyBackendManifestParallelism(
-                new FallbackReadFileStoreTable(main, fallback), null, 512);
+                new FallbackReadFileStoreTable(main, fallback, true), null, 512);
 
         Assert.assertEquals("256", safeVisible.options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
-        Assert.assertEquals("256", ((FallbackReadFileStoreTable) safeFallback).fallback()
+        Assert.assertEquals("256", ((FallbackReadFileStoreTable) safeFallback).other()
                 .options().get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
     }
 
@@ -301,20 +302,20 @@ public void testFallbackManifestParallelismIsCappedPerBranch() {
                 CoreOptions.SCAN_MANIFEST_PARALLELISM.key(), "1"));
         FileStoreTable fallback = serializableFileStoreTable(Collections.singletonMap(
                 CoreOptions.SCAN_MANIFEST_PARALLELISM.key(), "128"));
-        Table pair = new FallbackReadFileStoreTable(main, fallback);
+        Table pair = new FallbackReadFileStoreTable(main, fallback, true);
 
         FallbackReadFileStoreTable unchanged = (FallbackReadFileStoreTable)
                 PaimonJniScanner.applyBackendManifestParallelism(pair, "128", 128);
         Assert.assertEquals("1", unchanged.wrapped().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
-        Assert.assertEquals("128", unchanged.fallback().options()
+        Assert.assertEquals("128", unchanged.other().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
 
         FallbackReadFileStoreTable capped = (FallbackReadFileStoreTable)
                 PaimonJniScanner.applyBackendManifestParallelism(pair, "128", 64);
         Assert.assertEquals("1", capped.wrapped().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
-        Assert.assertEquals("64", capped.fallback().options()
+        Assert.assertEquals("64", capped.other().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
     }
 
@@ -329,7 +330,7 @@ public void testBackendCapTraversesPrivilegeDelegate() {
                 new Class<?>[] {PrivilegeChecker.class},
                 (proxy, method, args) -> null);
         FileStoreTable privileged = PrivilegedFileStoreTable.wrap(
-                new FallbackReadFileStoreTable(main, fallback), checker,
+                new FallbackReadFileStoreTable(main, fallback, true), checker,
                 Identifier.create("db", "table"));
 
         Table safe = PaimonJniScanner.applyBackendManifestParallelism(
@@ -342,7 +343,7 @@ public void testBackendCapTraversesPrivilegeDelegate() {
         FallbackReadFileStoreTable pair = (FallbackReadFileStoreTable) planningTable;
         Assert.assertEquals("1", pair.wrapped().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
-        Assert.assertEquals("64", pair.fallback().options()
+        Assert.assertEquals("64", pair.other().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
     }
 
@@ -353,7 +354,7 @@ public void testOldFeSystemWrapperPreservesIndependentFallbackLimits() throws Ex
         FileStoreTable fallback = serializableFileStoreTable(Collections.singletonMap(
                 CoreOptions.SCAN_MANIFEST_PARALLELISM.key(), "128"));
         Table wrapper = SystemTableLoader.load(
-                "partitions", new FallbackReadFileStoreTable(main, fallback));
+                "partitions", new FallbackReadFileStoreTable(main, fallback, true));
 
         Table safe = PaimonJniScanner.applyBackendManifestParallelism(
                 wrapper, null, 64);
@@ -363,7 +364,7 @@ public void testOldFeSystemWrapperPreservesIndependentFallbackLimits() throws Ex
 
         Assert.assertEquals("1", pair.wrapped().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
-        Assert.assertEquals("64", pair.fallback().options()
+        Assert.assertEquals("64", pair.other().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
     }
 
@@ -378,7 +379,7 @@ public void testSystemWrapperExposesSafeFallbackBehindPrivilegeDelegate() throws
                 new Class<?>[] {PrivilegeChecker.class},
                 (proxy, method, args) -> null);
         FileStoreTable privileged = PrivilegedFileStoreTable.wrap(
-                new FallbackReadFileStoreTable(main, fallback), checker,
+                new FallbackReadFileStoreTable(main, fallback, true), checker,
                 Identifier.create("db", "table"));
         Table wrapper = SystemTableLoader.load("partitions", privileged);
 
diff --git a/fe/fe-connector/fe-connector-paimon-hive-shade/pom.xml b/fe/fe-connector/fe-connector-paimon-hive-shade/pom.xml
index 21d3da4c901c9a..a8f95dbeda7f37 100644
--- a/fe/fe-connector/fe-connector-paimon-hive-shade/pom.xml
+++ b/fe/fe-connector/fe-connector-paimon-hive-shade/pom.xml
@@ -66,6 +66,14 @@ under the License.
                  the shade jar -> child-first duplicate-class hazard, design Risk #5). -->
             <optional>true</optional>
             <exclusions>
+                <!-- Paimon 2.0 publishes this artifact as a fat jar containing the full Paimon
+                     runtime. The shade filter below keeps only org/apache/paimon/hive/**, so its
+                     Maven transitives must not be added as duplicate inputs. fe-connector-paimon
+                     provides the single paimon-core runtime used by both layers. -->
+                <exclusion>
+                    <groupId>*</groupId>
+                    <artifactId>*</artifactId>
+                </exclusion>
                 <exclusion>
                     <groupId>org.apache.httpcomponents.client5</groupId>
                     <artifactId>httpclient5</artifactId>
@@ -306,6 +314,16 @@ under the License.
                             <createDependencyReducedPom>true</createDependencyReducedPom>
                             <dependencyReducedPomLocation>${project.basedir}/target/dependency-reduced-pom.xml</dependencyReducedPomLocation>
                             <filters>
+                                <filter>
+                                    <artifact>org.apache.paimon:paimon-hive-connector-3.1</artifact>
+                                    <includes>
+                                        <!-- Paimon 2.0's Hive connector is a fat jar. Keep only
+                                             the Hive integration; core, formats, codegen and all
+                                             shaded third-party classes come from the plugin's
+                                             normal Paimon runtime exactly once. -->
+                                        <include>org/apache/paimon/hive/**</include>
+                                    </includes>
+                                </filter>
                                 <filter>
                                     <artifact>*:*</artifact>
                                     <excludes>
diff --git a/fe/fe-connector/fe-connector-paimon-hive-shade/src/main/resources/META-INF/services/org.apache.paimon.factories.Factory b/fe/fe-connector/fe-connector-paimon-hive-shade/src/main/resources/META-INF/services/org.apache.paimon.factories.Factory
new file mode 100644
index 00000000000000..3df3dcc0842588
--- /dev/null
+++ b/fe/fe-connector/fe-connector-paimon-hive-shade/src/main/resources/META-INF/services/org.apache.paimon.factories.Factory
@@ -0,0 +1,2 @@
+org.apache.paimon.hive.HiveCatalogFactory
+org.apache.paimon.hive.HiveCatalogLockFactory
diff --git a/fe/fe-connector/fe-connector-paimon/pom.xml b/fe/fe-connector/fe-connector-paimon/pom.xml
index 9b17c987ba3f1d..c8a1d100bf7772 100644
--- a/fe/fe-connector/fe-connector-paimon/pom.xml
+++ b/fe/fe-connector/fe-connector-paimon/pom.xml
@@ -116,6 +116,22 @@ under the License.
             <groupId>org.apache.paimon</groupId>
             <artifactId>paimon-core</artifactId>
             <version>${paimon.version}</version>
+            <exclusions>
+                <!-- Paimon 2.0's paimon-api jar already embeds these relocated classes. Keeping
+                     the standalone shade artifacts adds 4,086 duplicate classes to the plugin. -->
+                <exclusion>
+                    <groupId>org.apache.paimon</groupId>
+                    <artifactId>paimon-shade-caffeine-2</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.paimon</groupId>
+                    <artifactId>paimon-shade-guava-30</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.apache.paimon</groupId>
+                    <artifactId>paimon-shade-jackson-2</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
 
         <!-- FIX-C (build 968994, Class C): the paimon-hive metastore-client closure
diff --git a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonReaderOptions.java b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonReaderOptions.java
index 54fce689de34b6..6d9c781835a658 100644
--- a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonReaderOptions.java
+++ b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonReaderOptions.java
@@ -28,6 +28,8 @@
 import org.apache.paimon.table.FileStoreTable;
 import org.apache.paimon.table.Table;
 import org.apache.paimon.table.system.SystemTableLoader;
+import org.apache.paimon.utils.ChainTableUtils;
+import org.apache.paimon.utils.StringUtils;
 
 import java.util.Collections;
 import java.util.LinkedHashMap;
@@ -218,10 +220,10 @@ private static Table normalizeManifestParallelism(
             FallbackReadFileStoreTable pair = (FallbackReadFileStoreTable) table;
             FileStoreTable main = normalizeManifestParallelism(
                     pair.wrapped(), safeBound, materializeAbsent);
-            FileStoreTable fallback = normalizeManifestParallelism(
-                    pair.fallback(), safeBound, materializeAbsent);
-            return main == pair.wrapped() && fallback == pair.fallback()
-                    ? table : new FallbackReadFileStoreTable(main, fallback);
+            FileStoreTable other = normalizeManifestParallelism(
+                    pair.other(), safeBound, materializeAbsent);
+            return main == pair.wrapped() && other == pair.other()
+                    ? table : new FallbackReadFileStoreTable(main, other, isWrappedFirst(pair));
         }
 
         if (table instanceof DelegatedFileStoreTable) {
@@ -270,12 +272,26 @@ private static FileStoreTable normalizeManifestParallelism(
                 (Table) table, safeBound, materializeAbsent);
     }
 
+    static boolean isWrappedFirst(FallbackReadFileStoreTable table) {
+        Map<String, String> options = table.options();
+        // Match FileStoreTableFactory's construction order. Paimon does not expose wrappedFirst.
+        if (ChainTableUtils.isChainTable(options)) {
+            return true;
+        }
+        if (!StringUtils.isNullOrWhitespaceOnly(
+                options.get(CoreOptions.SCAN_FALLBACK_BRANCH.key()))) {
+            return true;
+        }
+        return StringUtils.isNullOrWhitespaceOnly(
+                options.get(CoreOptions.SCAN_PRIMARY_BRANCH.key()));
+    }
+
     public static void validateEffectiveTable(Table table) {
         validateEffectiveTableOptions(table.options());
         if (table instanceof FallbackReadFileStoreTable) {
             // The fallback scan plans its private child independently, so the visible main options
             // cannot prove that every manifest executor input is safe.
-            validateEffectiveTable(((FallbackReadFileStoreTable) table).fallback());
+            validateEffectiveTable(((FallbackReadFileStoreTable) table).other());
         }
         if (table instanceof DelegatedFileStoreTable) {
             // Privilege and other supported delegates can hide a fallback planner behind their
@@ -290,7 +306,7 @@ public static void validateEffectivePlanningTable(Table table) {
         validateIfPresentForRuntime(table.options(), CoreOptions.SCAN_MANIFEST_PARALLELISM.key());
         validateIfPresent(table.options(), CoreOptions.SCAN_PLAN_SORT_PARTITION.key());
         if (table instanceof FallbackReadFileStoreTable) {
-            validateEffectivePlanningTable(((FallbackReadFileStoreTable) table).fallback());
+            validateEffectivePlanningTable(((FallbackReadFileStoreTable) table).other());
         }
         if (table instanceof DelegatedFileStoreTable) {
             validateEffectivePlanningTable(((DelegatedFileStoreTable) table).wrapped());
diff --git a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java
index 2b801ebbb7a4e2..265345c7091b22 100644
--- a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java
+++ b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java
@@ -732,7 +732,7 @@ private List<ConnectorScanRange> planScanInternal(
         // Process DataSplits
         for (DataSplit dataSplit : dataSplits) {
             if (isCountPushdownSplit(countPushdown, dataSplit)) {
-                countSum += dataSplit.mergedRowCount();
+                countSum += dataSplit.mergedRowCount().getAsLong();
                 if (countRepresentative == null) {
                     countRepresentative = dataSplit;
                 }
@@ -1174,7 +1174,7 @@ static void authorizeDeferredScan(FileStoreTable dataTable) {
         if (undecorated instanceof FallbackReadFileStoreTable) {
             FallbackReadFileStoreTable fallbackReadTable = (FallbackReadFileStoreTable) undecorated;
             authorizeBranch(fallbackReadTable.wrapped());
-            authorizeBranch(fallbackReadTable.fallback());
+            authorizeBranch(fallbackReadTable.other());
             return;
         }
         authorizeBranch(undecorated);
@@ -1236,7 +1236,8 @@ static FileStoreTable pinCatalogSnapshot(FileStoreTable catalogLessTable, FileSt
             FallbackReadFileStoreTable targetPair = (FallbackReadFileStoreTable) target;
             return new FallbackReadFileStoreTable(
                     pinCatalogSnapshotBranch(targetPair.wrapped(), sourcePair.wrapped()),
-                    pinCatalogSnapshotBranch(targetPair.fallback(), sourcePair.fallback()));
+                    pinCatalogSnapshotBranch(targetPair.other(), sourcePair.other()),
+                    PaimonReaderOptions.isWrappedFirst(targetPair));
         }
         return pinCatalogSnapshotBranch(target, source);
     }
@@ -1279,7 +1280,8 @@ static FileStoreTable dropCatalogLoader(FileStoreTable dataTable) {
             FallbackReadFileStoreTable fallbackReadTable = (FallbackReadFileStoreTable) undecorated;
             return new FallbackReadFileStoreTable(
                     rebuildWithoutCatalogLoader(fallbackReadTable.wrapped()),
-                    rebuildWithoutCatalogLoader(fallbackReadTable.fallback()));
+                    rebuildWithoutCatalogLoader(fallbackReadTable.other()),
+                    PaimonReaderOptions.isWrappedFirst(fallbackReadTable));
         }
         return rebuildWithoutCatalogLoader(undecorated);
     }
@@ -1403,12 +1405,12 @@ private PaimonScanRange buildJniScanRange(Split split, String defaultFileFormat,
      * Whether a {@link DataSplit} contributes a precomputed COUNT(*)-pushdown row count: true iff count
      * pushdown is active for this scan AND the split's merged (post-merge / post-deletion-vector) row
      * count is precomputed by the paimon SDK. Mirrors legacy {@code PaimonScanNode}'s count gate
-     * ({@code applyCountPushdown && dataSplit.mergedRowCountAvailable()}, the FIRST routing arm).
+     * ({@code applyCountPushdown && dataSplit.mergedRowCount().isPresent()}, the FIRST routing arm).
      * Extracted as a pure static so the correctness-critical count routing decision is unit-testable
      * with a real {@link DataSplit}, like {@link #shouldUseNativeReader}.
      */
     static boolean isCountPushdownSplit(boolean countPushdown, DataSplit dataSplit) {
-        return countPushdown && dataSplit.mergedRowCountAvailable();
+        return countPushdown && dataSplit.mergedRowCount().isPresent();
     }
 
     /**
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/FakePaimonTable.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/FakePaimonTable.java
index 382bd1f530ad32..5c33e5ee94763e 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/FakePaimonTable.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/FakePaimonTable.java
@@ -27,7 +27,9 @@
 import org.apache.paimon.table.Table;
 import org.apache.paimon.table.sink.BatchWriteBuilder;
 import org.apache.paimon.table.sink.StreamWriteBuilder;
+import org.apache.paimon.table.source.FullTextSearchBuilder;
 import org.apache.paimon.table.source.ReadBuilder;
+import org.apache.paimon.table.source.VectorSearchBuilder;
 import org.apache.paimon.types.RowType;
 import org.apache.paimon.utils.SimpleFileReader;
 
@@ -207,6 +209,11 @@ public void rollbackTo(String tagName) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
+    public void rollbackSchema(long schemaId) {
+        throw new UnsupportedOperationException();
+    }
+
     @Override
     public void createBranch(String branchName) {
         throw new UnsupportedOperationException();
@@ -217,16 +224,36 @@ public void createBranch(String branchName, String tagName) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
+    public void createBranch(String branchName, boolean forceCreate) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void createBranch(String branchName, String tagName, boolean forceCreate) {
+        throw new UnsupportedOperationException();
+    }
+
     @Override
     public void deleteBranch(String branchName) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
+    public void renameBranch(String branchName, String targetBranchName) {
+        throw new UnsupportedOperationException();
+    }
+
     @Override
     public void fastForward(String branchName) {
         throw new UnsupportedOperationException();
     }
 
+    @Override
+    public void mergeBranch(String branchName, String targetBranchName) {
+        throw new UnsupportedOperationException();
+    }
+
     @Override
     public ExpireSnapshots newExpireSnapshots() {
         throw new UnsupportedOperationException();
@@ -237,6 +264,16 @@ public ExpireSnapshots newExpireChangelog() {
         throw new UnsupportedOperationException();
     }
 
+    @Override
+    public VectorSearchBuilder newVectorSearchBuilder() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public FullTextSearchBuilder newFullTextSearchBuilder() {
+        throw new UnsupportedOperationException();
+    }
+
     @Override
     public ReadBuilder newReadBuilder() {
         throw new UnsupportedOperationException();
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonBackendBoundTableTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonBackendBoundTableTest.java
index 30592f07c0b96a..dfd32f705a050b 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonBackendBoundTableTest.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonBackendBoundTableTest.java
@@ -21,6 +21,7 @@
 import org.apache.paimon.Snapshot;
 import org.apache.paimon.catalog.FileSystemCatalog;
 import org.apache.paimon.catalog.Identifier;
+import org.apache.paimon.catalog.TableQueryAuthResult;
 import org.apache.paimon.data.GenericRow;
 import org.apache.paimon.fs.local.LocalFileIO;
 import org.apache.paimon.options.Options;
@@ -264,12 +265,10 @@ public void sysTableHandleBuildsTheWrapperOverThePeeledFallbackPair(@TempDir Pat
             throws Exception {
         // With file based privileges enabled the meta cache holds Privileged(FallbackRead(..)) - a
         // shape paimon's own catalog never lets a system table see, because CatalogUtils#loadTable
-        // builds one over the raw FileStoreTableFactory result. ReadOptimizedTable#newScan dispatches
-        // on a DIRECT instanceof, so with the privilege wrapper still in between it plans the main
-        // branch alone through the pair's inherited newSnapshotReader() and silently drops every
-        // fallback-only partition.
+        // builds one over the raw FileStoreTableFactory result. Keep the exact fallback pair as the
+        // system-table source so branch ordering and branch-local planning options remain intact.
         FileStoreTable[] branches = fallbackPairWithNewerGenerationOnDisk(warehouse, "fb_sys");
-        FileStoreTable pair = new FallbackReadFileStoreTable(branches[0], branches[1]);
+        FileStoreTable pair = new FallbackReadFileStoreTable(branches[0], branches[1], true);
         FileStoreTable decorated = PrivilegedFileStoreTable.wrap(pair,
                 new AllGrantedPrivilegeChecker(), Identifier.create("db", "tbl"));
         PaimonTableHandle baseHandle = dataHandle();
@@ -283,16 +282,13 @@ public void sysTableHandleBuildsTheWrapperOverThePeeledFallbackPair(@TempDir Pat
         Assertions.assertTrue(((ReadOptimizedTable) sysHandle.getPaimonTable()).newScan()
                         instanceof FallbackReadFileStoreTable.FallbackReadScan,
                 "the FE must plan tbl$ro over BOTH branches");
-        // What that stands for: leaving the decorator on takes newScan down its single-branch path.
-        Assertions.assertFalse(((ReadOptimizedTable) SystemTableLoader.load("ro", decorated)).newScan()
-                        instanceof FallbackReadFileStoreTable.FallbackReadScan);
     }
 
     @Test
     public void runtimeCapKeepsFallbackImmediateUnderReadOptimizedWrapper(@TempDir Path warehouse)
             throws Exception {
         FileStoreTable[] branches = fallbackPairWithNewerGenerationOnDisk(warehouse, "fb_runtime_cap");
-        FileStoreTable pair = new FallbackReadFileStoreTable(branches[0], branches[1]);
+        FileStoreTable pair = new FallbackReadFileStoreTable(branches[0], branches[1], true);
         FileStoreTable decorated = PrivilegedFileStoreTable.wrap(pair,
                 new AllGrantedPrivilegeChecker(), Identifier.create("db", "tbl"));
         FileStoreTable configured = decorated.copyWithoutTimeTravel(Collections.singletonMap(
@@ -377,7 +373,7 @@ public void pinsEachFallbackBranchToItsOwnCatalogVisibleSnapshot(@TempDir Path w
                 onDisk.copyWithoutTimeTravel(mainOptions), catalogEnvironment(mainCatalog));
         FileStoreTable fallback = withCatalogEnvironment(
                 onDisk.copyWithoutTimeTravel(fallbackOptions), catalogEnvironment(fallbackCatalog));
-        FileStoreTable catalogPair = new FallbackReadFileStoreTable(main, fallback);
+        FileStoreTable catalogPair = new FallbackReadFileStoreTable(main, fallback, true);
 
         FileStoreTable pinned = PaimonScanPlanProvider.pinCatalogSnapshot(
                 PaimonScanPlanProvider.dropCatalogLoader(catalogPair), catalogPair);
@@ -385,7 +381,7 @@ public void pinsEachFallbackBranchToItsOwnCatalogVisibleSnapshot(@TempDir Path w
         Assertions.assertTrue(pinned instanceof FallbackReadFileStoreTable);
         FallbackReadFileStoreTable pinnedPair = (FallbackReadFileStoreTable) pinned;
         Assertions.assertEquals("2", pinnedPair.wrapped().options().get("scan.snapshot-id"));
-        Assertions.assertEquals("1", pinnedPair.fallback().options().get("scan.snapshot-id"),
+        Assertions.assertEquals("1", pinnedPair.other().options().get("scan.snapshot-id"),
                 "the fallback branch must use its own catalog pointer, not its newest snapshot file");
         Assertions.assertTrue(mainCatalog.loadSnapshotCalls > 0);
         Assertions.assertTrue(fallbackCatalog.loadSnapshotCalls > 0);
@@ -497,7 +493,7 @@ public void fallbackBranchKeepsTheGenerationTheFeCaptured(@TempDir Path warehous
         FileStoreTable[] captured = fallbackPairWithNewerGenerationOnDisk(warehouse, "fb_generation");
 
         FileStoreTable forBackend = PaimonScanPlanProvider.dropCatalogLoader(
-                new FallbackReadFileStoreTable(captured[0], captured[1]));
+                new FallbackReadFileStoreTable(captured[0], captured[1], true));
 
         assertPairMatchesTheFeGeneration(forBackend, captured[0], captured[1]);
     }
@@ -511,7 +507,7 @@ public void fallbackBranchSurvivesAPaimonTableDecorator(@TempDir Path warehouse)
         // while the FE keeps planning the wrapper and can still emit one.
         FileStoreTable[] captured = fallbackPairWithNewerGenerationOnDisk(warehouse, "fb_decorated");
         FileStoreTable decorated = PrivilegedFileStoreTable.wrap(
-                new FallbackReadFileStoreTable(captured[0], captured[1]),
+                new FallbackReadFileStoreTable(captured[0], captured[1], true),
                 new AllGrantedPrivilegeChecker(), Identifier.create("db", "tbl"));
 
         assertPairMatchesTheFeGeneration(PaimonScanPlanProvider.dropCatalogLoader(decorated),
@@ -532,13 +528,16 @@ public void authorizesBothBranchesOfAFallbackPair(@TempDir Path warehouse) {
         Map<String, String> fallbackOptions = queryAuthEnabled();
         fallbackOptions.put("branch", "fb");
         FileStoreTable main = newTable(warehouse,
-                new CatalogEnvironment(mainIdentifier, null, () -> catalog, null, null, true),
+                new CatalogEnvironment(mainIdentifier, null, () -> catalog, null, null,
+                        null, true, false),
                 queryAuthEnabled(), C1);
         FileStoreTable fallback = newTable(warehouse,
-                new CatalogEnvironment(fallbackIdentifier, null, () -> catalog, null, null, true),
+                new CatalogEnvironment(fallbackIdentifier, null, () -> catalog, null, null,
+                        null, true, false),
                 fallbackOptions, C1);
 
-        PaimonScanPlanProvider.authorizeDeferredScan(new FallbackReadFileStoreTable(main, fallback));
+        PaimonScanPlanProvider.authorizeDeferredScan(
+                new FallbackReadFileStoreTable(main, fallback, true));
 
         Assertions.assertEquals(Arrays.asList(mainIdentifier, fallbackIdentifier), catalog.authCalls,
                 "both branches must be authorized, each against its own identifier");
@@ -582,7 +581,8 @@ public void relationOptionsResolveFallbackSnapshotBeforeDroppingLoaders(@TempDir
                 withCatalogEnvironment(onDisk.copyWithoutTimeTravel(mainOptions),
                         catalogEnvironment(mainCatalog)),
                 withCatalogEnvironment(onDisk.copyWithoutTimeTravel(fallbackOptions),
-                        catalogEnvironment(fallbackCatalog)));
+                        catalogEnvironment(fallbackCatalog)),
+                true);
         Map<String, String> pinned = PaimonScanParams.markAsOptions(
                 Collections.singletonMap("scan.snapshot-id", "2"));
         PaimonTableHandle handle = sysHandle("ro", pair).withScanOptions(pinned);
@@ -595,7 +595,7 @@ public void relationOptionsResolveFallbackSnapshotBeforeDroppingLoaders(@TempDir
         FallbackReadFileStoreTable backendPair =
                 (FallbackReadFileStoreTable) wrapped.get(forBackend);
         Assertions.assertEquals("2", backendPair.wrapped().options().get("scan.snapshot-id"));
-        Assertions.assertEquals("1", backendPair.fallback().options().get("scan.snapshot-id"));
+        Assertions.assertEquals("1", backendPair.other().options().get("scan.snapshot-id"));
         Assertions.assertTrue(fallbackCatalog.loadSnapshotCalls > 0,
                 "fallback translation must consult its catalog before the loader is removed");
     }
@@ -683,7 +683,7 @@ public void incrementalRangeIsNotBoundOnAFallbackBranchPair(@TempDir Path wareho
         Map<String, String> fallbackOptions = new HashMap<>();
         fallbackOptions.put("branch", "fb");
         FileStoreTable fallback = newTable(warehouse, catalogEnvironment(catalog), fallbackOptions, C1);
-        FileStoreTable pair = new FallbackReadFileStoreTable(main, fallback);
+        FileStoreTable pair = new FallbackReadFileStoreTable(main, fallback, true);
 
         Map<String, String> range = new HashMap<>();
         range.put("incremental-between-timestamp",
@@ -743,8 +743,8 @@ private static Map<String, String> queryAuthEnabled() {
     }
 
     private static CatalogEnvironment catalogEnvironment(VersionManagedCatalog catalog) {
-        return new CatalogEnvironment(Identifier.create("db", "tbl"), null, () -> catalog, null, null,
-                catalog.supportsVersionManagement());
+        return new CatalogEnvironment(Identifier.create("db", "tbl"), null, () -> catalog,
+                null, null, null, catalog.supportsVersionManagement(), false);
     }
 
     /** A table object with the given schema; no files are written, so nothing touches the disk. */
@@ -833,11 +833,11 @@ private static void assertPairMatchesTheFeGeneration(FileStoreTable forBackend,
                 "the pair itself must reach the BE, or a fallback split has no reader there");
         FallbackReadFileStoreTable pair = (FallbackReadFileStoreTable) forBackend;
         // The fallback branch must stay on F1 - not the c2 generation sitting on the filesystem.
-        Assertions.assertEquals(fallback.rowType(), pair.fallback().rowType());
+        Assertions.assertEquals(fallback.rowType(), pair.other().rowType());
         Assertions.assertEquals(main.rowType(), pair.wrapped().rowType());
         // And neither branch may carry the loader that drags the metastore stack onto the BE.
         Assertions.assertNull(pair.wrapped().catalogEnvironment().catalogLoader());
-        Assertions.assertNull(pair.fallback().catalogEnvironment().catalogLoader());
+        Assertions.assertNull(pair.other().catalogEnvironment().catalogLoader());
     }
 
     /** Decodes {@code paimon.serialized_table} the way {@code PaimonJniScanner#initTable} does. */
@@ -910,12 +910,12 @@ public Optional<TableSnapshot> loadSnapshot(Identifier identifier) {
         }
 
         @Override
-        public List<String> authTableQuery(Identifier identifier, List<String> select) {
+        public TableQueryAuthResult authTableQuery(Identifier identifier, List<String> select) {
             authCalls.add(identifier);
             if (authDenialMessage != null) {
                 throw new RuntimeException(authDenialMessage);
             }
-            return Collections.emptyList();
+            return new TableQueryAuthResult(Collections.emptyList(), Collections.emptyMap());
         }
 
         @Override
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataPartitionTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataPartitionTest.java
index 56d0456f8747de..5c9450e82505ac 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataPartitionTest.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataPartitionTest.java
@@ -84,11 +84,11 @@ private static PaimonTableHandle dtRegionHandle(FakePaimonTable table) {
         return handle;
     }
 
-    /** Real Paimon Partition fixture via the verified public 6-arg ctor. */
+    /** Real Paimon Partition fixture via the public statistics constructor. */
     private static Partition partition(Map<String, String> spec, long recordCount,
             long fileSizeInBytes, long lastFileCreationTime) {
         return new Partition(spec, recordCount, fileSizeInBytes, /*fileCount*/ 1, lastFileCreationTime,
-                /*done*/ true);
+                /*totalBuckets*/ 1, /*done*/ true);
     }
 
     @Test
@@ -183,10 +183,10 @@ public void listPartitionsCarriesFileCount() {
         spec.put("region", "cn");
         // Every stat is a DISTINCT value so an arg-swap mutation cannot pass by coincidence.
         // Paimon Partition ctor order: (spec, recordCount, fileSizeInBytes, fileCount,
-        // lastFileCreationTime, done).
+        // lastFileCreationTime, totalBuckets, done).
         ops.partitions = Collections.singletonList(new Partition(
                 spec, /*recordCount*/ 42L, /*fileSizeInBytes*/ 1024L, /*fileCount*/ 7L,
-                /*lastFileCreationTime*/ 1700000000000L, /*done*/ true));
+                /*lastFileCreationTime*/ 1700000000000L, /*totalBuckets*/ 3, /*done*/ true));
 
         ConnectorPartitionInfo info = metadataWith(ops)
                 .listPartitions(null, dtRegionHandle(table), Optional.empty()).get(0);
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataPartitionViewCacheTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataPartitionViewCacheTest.java
index 831a5d59601bc1..5433ac82f2382b 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataPartitionViewCacheTest.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataPartitionViewCacheTest.java
@@ -92,7 +92,7 @@ private static FakePaimonTable regionTable() {
     private static Partition partition(String regionValue) {
         Map<String, String> spec = new LinkedHashMap<>();
         spec.put("region", regionValue);
-        return new Partition(spec, 1L, 1L, 1, 1L, true);
+        return new Partition(spec, 1L, 1L, 1, 1L, 1, true);
     }
 
     private static long loadCount(RecordingPaimonCatalogOps ops) {
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataReadAuthTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataReadAuthTest.java
index 8d30fa4364a5f3..b85499d9e99fc6 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataReadAuthTest.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataReadAuthTest.java
@@ -211,7 +211,8 @@ public void listPartitionNamesEntersAuthenticatorForBothResolveAndListPartitions
         Map<String, String> spec = new LinkedHashMap<>();
         spec.put("region", "cn");
         ops.partitions = Collections.singletonList(
-                new Partition(spec, 1L, 1L, /*fileCount*/ 1, 1L, /*done*/ true));
+                new Partition(spec, 1L, 1L, /*fileCount*/ 1, 1L,
+                        /*totalBuckets*/ 1, /*done*/ true));
         RecordingConnectorContext ctx = new RecordingConnectorContext();
 
         PaimonTableHandle handle = new PaimonTableHandle(
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonReaderOptionsTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonReaderOptionsTest.java
index af643eda61a2a6..314b778c0ffb40 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonReaderOptionsTest.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonReaderOptionsTest.java
@@ -124,16 +124,16 @@ void testRuntimeCapNormalizesEveryPlanningLeafIndependently() {
         FileStoreTable safeEmpty = (FileStoreTable) PaimonReaderOptions.runtimeSafeTable(empty, 512);
         FallbackReadFileStoreTable explicitThenEmpty = (FallbackReadFileStoreTable)
                 PaimonReaderOptions.runtimeSafeTable(
-                        new FallbackReadFileStoreTable(explicit, empty), 512);
+                        new FallbackReadFileStoreTable(explicit, empty, true), 512);
         FallbackReadFileStoreTable emptyThenExplicit = (FallbackReadFileStoreTable)
                 PaimonReaderOptions.runtimeSafeTable(
-                        new FallbackReadFileStoreTable(empty, explicit), 512);
+                        new FallbackReadFileStoreTable(empty, explicit, true), 512);
         PrivilegeChecker checker = (PrivilegeChecker) Proxy.newProxyInstance(
                 PrivilegeChecker.class.getClassLoader(),
                 new Class<?>[] {PrivilegeChecker.class},
                 (proxy, method, args) -> null);
         FileStoreTable privileged = PrivilegedFileStoreTable.wrap(
-                new FallbackReadFileStoreTable(explicit, empty), checker,
+                new FallbackReadFileStoreTable(explicit, empty, true), checker,
                 Identifier.create("db", "table"));
         Table normalizedDelegate = PaimonReaderOptions.runtimeSafeTable(privileged, 512);
 
@@ -141,22 +141,22 @@ void testRuntimeCapNormalizesEveryPlanningLeafIndependently() {
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
         Assertions.assertEquals("1", explicitThenEmpty.wrapped().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
-        Assertions.assertEquals("256", explicitThenEmpty.fallback().options()
+        Assertions.assertEquals("256", explicitThenEmpty.other().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
         Assertions.assertEquals("256", emptyThenExplicit.wrapped().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
-        Assertions.assertEquals("1", emptyThenExplicit.fallback().options()
+        Assertions.assertEquals("1", emptyThenExplicit.other().options()
                 .get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
         Assertions.assertInstanceOf(FallbackReadFileStoreTable.class, normalizedDelegate);
         Assertions.assertEquals("256", ((FallbackReadFileStoreTable) normalizedDelegate)
-                .fallback().options().get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
+                .other().options().get(CoreOptions.SCAN_MANIFEST_PARALLELISM.key()));
     }
 
     @Test
     void testSystemSourceKeepsFallbackAsOutermostPlanningDecorator() {
         FileStoreTable main = newFileStoreTable("main", Collections.emptyMap());
         FileStoreTable fallback = newFileStoreTable("fallback", Collections.emptyMap());
-        FallbackReadFileStoreTable pair = new FallbackReadFileStoreTable(main, fallback);
+        FallbackReadFileStoreTable pair = new FallbackReadFileStoreTable(main, fallback, true);
         PrivilegeChecker checker = (PrivilegeChecker) Proxy.newProxyInstance(
                 PrivilegeChecker.class.getClassLoader(),
                 new Class<?>[] {PrivilegeChecker.class},
@@ -168,6 +168,20 @@ void testSystemSourceKeepsFallbackAsOutermostPlanningDecorator() {
         Assertions.assertSame(pair, PaimonTableDecorators.unwrapToFallbackOrBase(privileged));
     }
 
+    @Test
+    void testFallbackWrapperOrderMatchesPaimonFactoryPrecedence() {
+        FileStoreTable other = newFileStoreTable("other", Collections.emptyMap());
+        Assertions.assertTrue(PaimonReaderOptions.isWrappedFirst(new FallbackReadFileStoreTable(
+                newFileStoreTable("fallback", ImmutableMap.of(
+                        CoreOptions.SCAN_FALLBACK_BRANCH.key(), "fallback",
+                        CoreOptions.SCAN_PRIMARY_BRANCH.key(), "primary")), other, true)));
+        Assertions.assertFalse(PaimonReaderOptions.isWrappedFirst(new FallbackReadFileStoreTable(
+                newFileStoreTable("primary", ImmutableMap.of(
+                        CoreOptions.SCAN_PRIMARY_BRANCH.key(), "primary")), other, false)));
+        Assertions.assertTrue(PaimonReaderOptions.isWrappedFirst(new FallbackReadFileStoreTable(
+                newFileStoreTable("default", Collections.emptyMap()), other, true)));
+    }
+
     @Test
     void testUnnormalizedEffectiveTableCannotGrowPaimonGlobalPool() {
         int localCapacity = Runtime.getRuntime().availableProcessors();
@@ -206,7 +220,7 @@ void testRejectUnsafeHiddenFallbackTableAfterCopy() {
         FileStoreTable main = newFileStoreTable("main", Collections.emptyMap());
         FileStoreTable fallback = newFileStoreTable(
                 "fallback", ImmutableMap.of("scan.manifest.parallelism", "0"));
-        Table fallbackReadTable = new FallbackReadFileStoreTable(main, fallback);
+        Table fallbackReadTable = new FallbackReadFileStoreTable(main, fallback, true);
 
         Assertions.assertThrows(IllegalArgumentException.class,
                 () -> PaimonScanParams.applyOptions(fallbackReadTable, Collections.emptyMap()));
@@ -217,7 +231,7 @@ void testSafeRelationOptionOverridesUnsafeHiddenFallbackTable() {
         FileStoreTable main = newFileStoreTable("main", Collections.emptyMap());
         FileStoreTable fallback = newFileStoreTable(
                 "fallback", ImmutableMap.of("scan.manifest.parallelism", "0"));
-        Table fallbackReadTable = new FallbackReadFileStoreTable(main, fallback);
+        Table fallbackReadTable = new FallbackReadFileStoreTable(main, fallback, true);
 
         Assertions.assertDoesNotThrow(() -> PaimonScanParams.applyOptions(
                 fallbackReadTable, ImmutableMap.of("scan.manifest.parallelism", "1")));
@@ -232,12 +246,12 @@ void testRuntimeSafeTableCapsHiddenFallbackPlanner() {
                 ImmutableMap.of("scan.manifest.parallelism", String.valueOf(localCapacity + 1)));
 
         Table safe = PaimonReaderOptions.runtimeSafeTable(
-                new FallbackReadFileStoreTable(main, fallback));
+                new FallbackReadFileStoreTable(main, fallback, true));
 
         Assertions.assertInstanceOf(FallbackReadFileStoreTable.class, safe);
         FallbackReadFileStoreTable pair = (FallbackReadFileStoreTable) safe;
         Assertions.assertEquals(String.valueOf(localCapacity),
-                pair.fallback().options().get("scan.manifest.parallelism"));
+                pair.other().options().get("scan.manifest.parallelism"));
     }
 
     @Test
@@ -251,7 +265,7 @@ void testBackendManifestCapUsesExecutionCeilingNotSmallestBranch() {
                 Math.min(Runtime.getRuntime().availableProcessors(),
                         PaimonReaderOptions.MAX_MANIFEST_PARALLELISM),
                 PaimonReaderOptions.backendManifestParallelismCap(
-                        new FallbackReadFileStoreTable(main, fallback)).getAsInt());
+                        new FallbackReadFileStoreTable(main, fallback, true)).getAsInt());
     }
 
     @Test
@@ -259,7 +273,7 @@ void testRejectUnsafeFallbackHiddenByPrivilegeDelegate() {
         FileStoreTable main = newFileStoreTable("privileged_main", Collections.emptyMap());
         FileStoreTable fallback = newFileStoreTable(
                 "privileged_fallback", ImmutableMap.of("scan.manifest.parallelism", "0"));
-        FileStoreTable fallbackReadTable = new FallbackReadFileStoreTable(main, fallback);
+        FileStoreTable fallbackReadTable = new FallbackReadFileStoreTable(main, fallback, true);
         PrivilegeChecker checker = (PrivilegeChecker) Proxy.newProxyInstance(
                 PrivilegeChecker.class.getClassLoader(),
                 new Class<?>[] {PrivilegeChecker.class},
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanMetricsTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanMetricsTest.java
index 3eec098a2f28f2..4b62f109241cbe 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanMetricsTest.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanMetricsTest.java
@@ -41,7 +41,7 @@ public void harvestRendersRecordedScanMetrics() {
         // the LAST_* gauges. A mutation that drops the harvest returns empty.
         PaimonMetricRegistry registry = new PaimonMetricRegistry();
         ScanMetrics metrics = new ScanMetrics(registry, "mydb.mytbl");
-        metrics.reportScan(new ScanStats(2_000_000L, 5L, 3L, 7L));
+        metrics.reportScan(new ScanStats(2_000_000L, -1L, 5L, 3L, 7L));
 
         Optional<ConnectorScanProfile> profile =
                 PaimonScanMetrics.harvest(registry, "mydb.mytbl", "Table Scan (mydb.mytbl)");
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanPlanProviderTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanPlanProviderTest.java
index ce8c337a65de43..edc51c86139e58 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanPlanProviderTest.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanPlanProviderTest.java
@@ -81,6 +81,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.OptionalLong;
 
 /**
  * Tests for {@link PaimonScanPlanProvider#resolveTable}, pinning the transient-Table reload
@@ -1044,7 +1045,7 @@ public void encodeSplitAlwaysUsesJavaSerializationForDataSplit(@TempDir Path war
                 "precondition: nativeBinaryEncode really is the paimon::Split::Deserialize format");
     }
 
-    /** A non-DataSplit Split (the only abstract method is rowCount(); Split is Serializable). */
+    /** A non-DataSplit Split used to verify the Java serialization route. */
     private static final class NonDataSplitStub implements Split {
         private static final long serialVersionUID = 1L;
 
@@ -1052,6 +1053,11 @@ private static final class NonDataSplitStub implements Split {
         public long rowCount() {
             return 0;
         }
+
+        @Override
+        public OptionalLong mergedRowCount() {
+            return OptionalLong.empty();
+        }
     }
 
     @Test
@@ -1073,13 +1079,13 @@ public void countPushdownSplitDetectedOnlyWhenAggCountAndMergedCountAvailable(
         // (post-merge / post-deletion-vector) row count, so a COUNT(*) over it can be served from
         // metadata instead of materializing rows.
         DataSplit dataSplit = buildRealDataSplit(warehouse);
-        Assertions.assertTrue(dataSplit.mergedRowCountAvailable(),
+        Assertions.assertTrue(dataSplit.mergedRowCount().isPresent(),
                 "precondition: a freshly written PK split has a precomputed merged row count");
-        Assertions.assertEquals(2L, dataSplit.mergedRowCount(), "two rows were written");
+        Assertions.assertEquals(2L, dataSplit.mergedRowCount().getAsLong(), "two rows were written");
 
         // WHY: the count branch must fire ONLY when BOTH the agg is COUNT (countPushdown) AND the SDK
         // precomputed the post-merge count — mirrors legacy `applyCountPushdown &&
-        // dataSplit.mergedRowCountAvailable()`. MUTATION: dropping `countPushdown &&` (or hard-coding
+        // dataSplit.mergedRowCount().isPresent()`. MUTATION: dropping `countPushdown &&` (or hard-coding
         // the helper to false) -> one of these two assertions flips -> red.
         Assertions.assertTrue(PaimonScanPlanProvider.isCountPushdownSplit(true, dataSplit),
                 "a count query over a split with a precomputed merged count must push the count down");
diff --git a/fe/pom.xml b/fe/pom.xml
index fa1ef0a650a524..99f5e26b22341a 100644
--- a/fe/pom.xml
+++ b/fe/pom.xml
@@ -414,7 +414,7 @@ under the License.
              InstantiationUtil and BE deserializes it with the SAME paimon jar; a version mismatch
              silently breaks that FE->BE deserialization at runtime. These three MUST stay equal —
              do NOT override paimon.version per-module. -->
-        <paimon.version>1.3.1</paimon.version>
+        <paimon.version>2.0.0</paimon.version>
         <disruptor.version>3.4.4</disruptor.version>
         <jetbrains-annotations.version>17.0.0</jetbrains-annotations.version>
         <!-- arrow flight sql -->

From 640c77f066e19370aef0d753b09209cbb9c971aa Mon Sep 17 00:00:00 2001
From: moke-HU <25567926679@qq.com>
Date: Fri, 14 Aug 2026 19:28:01 +0800
Subject: [PATCH 2/7] feat(paimon): add transactional table writes

---
 be/src/common/config.cpp                      |   5 +
 be/src/common/config.h                        |   4 +
 .../data_type_variant_v2_serde.cpp            |  50 ++
 be/src/exec/operator/operator.cpp             |   3 +
 .../operator/paimon_table_sink_operator.cpp   |  39 +
 .../operator/paimon_table_sink_operator.h     | 106 +++
 .../pipeline/pipeline_fragment_context.cpp    |  12 +-
 .../paimon/jni_paimon_write_backend.cpp       | 622 ++++++++++++++
 .../writer/paimon/jni_paimon_write_backend.h  | 110 +++
 .../paimon/paimon_jni_memory_manager.cpp      | 304 +++++++
 .../writer/paimon/paimon_jni_memory_manager.h |  81 ++
 .../writer/paimon/paimon_table_writer.cpp     | 193 +++++
 .../sink/writer/paimon/paimon_table_writer.h  | 102 +++
 .../sink/writer/paimon/paimon_write_backend.h |  84 ++
 be/src/format/jni/jni_data_bridge.cpp         |  43 +
 be/src/format/jni/jni_data_bridge.h           |   3 +
 be/src/runtime/runtime_state.cpp              |  42 +-
 be/src/runtime/runtime_state.h                |  13 +-
 ...data_type_variant_v2_serde_output_test.cpp |  30 +
 .../format/table/paimon_jni_reader_test.cpp   |  65 ++
 .../runtime_state_block_budget_test.cpp       |  26 +
 fe/be-java-extensions/paimon-scanner/pom.xml  |   5 +
 .../doris/paimon/DorisMemorySegmentPool.java  |  57 ++
 .../doris/paimon/PaimonArrowConverter.java    | 479 +++++++++++
 .../doris/paimon/PaimonColumnValue.java       |  81 +-
 .../doris/paimon/PaimonCommitCodec.java       | 222 +++++
 .../apache/doris/paimon/PaimonJniWriter.java  | 781 ++++++++++++++++++
 .../doris/paimon/PaimonWriteSchema.java       | 131 +++
 .../paimon/PaimonArrowConverterTest.java      | 334 ++++++++
 .../doris/paimon/PaimonColumnValueTest.java   |  47 ++
 .../doris/paimon/PaimonCommitCodecTest.java   | 149 ++++
 .../doris/paimon/PaimonJniScannerTest.java    |   5 +
 .../doris/paimon/PaimonJniWriterTest.java     | 195 +++++
 .../doris/paimon/PaimonWriteSchemaTest.java   | 200 +++++
 .../connector/paimon/PaimonConnector.java     |  10 +-
 .../paimon/PaimonConnectorMetadata.java       |  23 +
 .../paimon/PaimonConnectorTransaction.java    | 402 +++++++++
 .../paimon/PaimonScanPlanProvider.java        |   2 +-
 .../connector/paimon/PaimonTypeMapping.java   |  15 +-
 .../connector/paimon/PaimonWriteBinding.java  |  98 +++
 .../paimon/PaimonWritePlanProvider.java       | 312 +++++++
 .../PaimonConnectorTransactionTest.java       | 185 +++++
 .../paimon/PaimonSchemaBuilderTest.java       |  29 +
 .../paimon/PaimonTypeMappingReadTest.java     |  22 +
 .../paimon/PaimonWritePlanProviderTest.java   | 310 +++++++
 .../apache/doris/qe/AbstractJobProcessor.java |   5 +-
 .../java/org/apache/doris/qe/Coordinator.java |   8 +-
 .../org/apache/doris/qe/QeProcessorImpl.java  |   3 +-
 .../doris/qe/runtime/LoadProcessor.java       |   9 +-
 .../qe/QeProcessorImplReportAckTest.java      |  22 +-
 .../transaction/CommitDataSerializerTest.java |  39 +
 gensrc/thrift/DataSinks.thrift                |  21 +
 gensrc/thrift/FrontendService.thrift          |   2 +
 .../test_paimon_ctas_atomicity_negative.out   |   9 +
 .../paimon/test_paimon_write_boundary.out     |  18 +-
 ...test_paimon_ctas_atomicity_negative.groovy |  32 +-
 .../paimon/test_paimon_write_boundary.groovy  |  33 +-
 57 files changed, 6168 insertions(+), 64 deletions(-)
 create mode 100644 be/src/exec/operator/paimon_table_sink_operator.cpp
 create mode 100644 be/src/exec/operator/paimon_table_sink_operator.h
 create mode 100644 be/src/exec/sink/writer/paimon/jni_paimon_write_backend.cpp
 create mode 100644 be/src/exec/sink/writer/paimon/jni_paimon_write_backend.h
 create mode 100644 be/src/exec/sink/writer/paimon/paimon_jni_memory_manager.cpp
 create mode 100644 be/src/exec/sink/writer/paimon/paimon_jni_memory_manager.h
 create mode 100644 be/src/exec/sink/writer/paimon/paimon_table_writer.cpp
 create mode 100644 be/src/exec/sink/writer/paimon/paimon_table_writer.h
 create mode 100644 be/src/exec/sink/writer/paimon/paimon_write_backend.h
 create mode 100644 fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/DorisMemorySegmentPool.java
 create mode 100644 fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonArrowConverter.java
 create mode 100644 fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonCommitCodec.java
 create mode 100644 fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonJniWriter.java
 create mode 100644 fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonWriteSchema.java
 create mode 100644 fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonArrowConverterTest.java
 create mode 100644 fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonCommitCodecTest.java
 create mode 100644 fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniWriterTest.java
 create mode 100644 fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonWriteSchemaTest.java
 create mode 100644 fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorTransaction.java
 create mode 100644 fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonWriteBinding.java
 create mode 100644 fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonWritePlanProvider.java
 create mode 100644 fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorTransactionTest.java
 create mode 100644 fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonWritePlanProviderTest.java
 create mode 100644 regression-test/data/external_table_p0/paimon/test_paimon_ctas_atomicity_negative.out

diff --git a/be/src/common/config.cpp b/be/src/common/config.cpp
index d27cf607a36b24..8ca027e6c4ec55 100644
--- a/be/src/common/config.cpp
+++ b/be/src/common/config.cpp
@@ -1608,6 +1608,11 @@ DEFINE_mInt64(hive_sink_max_file_size, "1073741824"); // 1GB
 /** Iceberg sink configurations **/
 DEFINE_mInt64(iceberg_sink_max_file_size, "1073741824"); // 1GB
 
+/** Paimon sink configurations **/
+DEFINE_mInt64(paimon_jni_writer_memory_pool_limit_bytes, "536870912"); // 512MB
+DEFINE_Validator(paimon_jni_writer_memory_pool_limit_bytes,
+                 [](int64_t bytes) -> bool { return bytes > 0; });
+
 // URI scheme to Doris file type mappings used by paimon-cpp DorisFileSystem.
 // Each entry uses the format "<scheme>=<file_type>", and file_type must be one of:
 // local, hdfs, s3, http, broker.
diff --git a/be/src/common/config.h b/be/src/common/config.h
index 470d88819703de..1983712b4b6a56 100644
--- a/be/src/common/config.h
+++ b/be/src/common/config.h
@@ -1701,6 +1701,10 @@ DECLARE_mInt64(hive_sink_max_file_size);
 /** Iceberg sink configurations **/
 DECLARE_mInt64(iceberg_sink_max_file_size);
 
+/** Paimon sink configurations **/
+// Hard upper bound for Doris-managed Paimon write-buffer memory per JNI writer.
+DECLARE_mInt64(paimon_jni_writer_memory_pool_limit_bytes);
+
 /** Paimon file system configurations **/
 DECLARE_Strings(paimon_file_system_scheme_mappings);
 
diff --git a/be/src/core/data_type_serde/data_type_variant_v2_serde.cpp b/be/src/core/data_type_serde/data_type_variant_v2_serde.cpp
index 4a1d8e70b7bc4c..3ef8142b2afb43 100644
--- a/be/src/core/data_type_serde/data_type_variant_v2_serde.cpp
+++ b/be/src/core/data_type_serde/data_type_variant_v2_serde.cpp
@@ -18,6 +18,7 @@
 #include "core/data_type_serde/data_type_variant_v2_serde.h"
 
 #include <arrow/array/builder_binary.h>
+#include <arrow/array/builder_nested.h>
 
 #include <algorithm>
 #include <cstring>
@@ -491,6 +492,50 @@ Status write_arrow(const IColumn& column, const NullMap* null_map, Builder& buil
     return status;
 }
 
+Status write_arrow_variant(const IColumn& column, const NullMap* null_map,
+                           arrow::StructBuilder& builder, size_t start, size_t end) {
+    const auto struct_type = std::dynamic_pointer_cast<arrow::StructType>(builder.type());
+    if (struct_type == nullptr || builder.num_fields() != 2 ||
+        struct_type->field(0)->name() != "value" || struct_type->field(1)->name() != "metadata") {
+        return Status::InvalidArgument(
+                "Variant Arrow output requires struct<value: binary, metadata: binary>");
+    }
+    auto* value_builder = dynamic_cast<arrow::BinaryBuilder*>(builder.field_builder(0));
+    auto* metadata_builder = dynamic_cast<arrow::BinaryBuilder*>(builder.field_builder(1));
+    if (value_builder == nullptr || metadata_builder == nullptr) {
+        return Status::InvalidArgument(
+                "Variant Arrow output requires binary value and metadata children");
+    }
+
+    Status status = Status::OK();
+    visit_variant_v2_values(
+            column, start, end, forced_nulls(null_map),
+            [&](size_t) {
+                if (status.ok()) {
+                    status = checkArrowStatus(builder.AppendNull(), column, builder);
+                }
+            },
+            [&](size_t, VariantRef value) {
+                if (!status.ok()) {
+                    return;
+                }
+                status = checkArrowStatus(builder.Append(), column, builder);
+                if (status.ok()) {
+                    status = checkArrowStatus(
+                            value_builder->Append(value.value.data,
+                                                  cast_set<int32_t>(value.value.size)),
+                            column, *value_builder);
+                }
+                if (status.ok()) {
+                    status = checkArrowStatus(
+                            metadata_builder->Append(value.metadata.data,
+                                                     cast_set<int32_t>(value.metadata.size)),
+                            column, *metadata_builder);
+                }
+            });
+    return status;
+}
+
 } // namespace
 
 void DataTypeVariantV2SerDe::to_string(const IColumn& column, size_t row_num, BufferWritable& bw,
@@ -553,6 +598,11 @@ Status DataTypeVariantV2SerDe::write_column_to_arrow(const IColumn& column, cons
                                assert_cast<arrow::LargeStringBuilder&>(*array_builder), first, last,
                                options);
         }
+        if (array_builder->type()->id() == arrow::Type::STRUCT) {
+            return write_arrow_variant(column, null_map,
+                                       assert_cast<arrow::StructBuilder&>(*array_builder), first,
+                                       last);
+        }
         return Status::InvalidArgument("Unsupported arrow type for variant column: {}",
                                        array_builder->type()->name());
     });
diff --git a/be/src/exec/operator/operator.cpp b/be/src/exec/operator/operator.cpp
index cfc9d6645119c8..9a12adaca8e07f 100644
--- a/be/src/exec/operator/operator.cpp
+++ b/be/src/exec/operator/operator.cpp
@@ -64,6 +64,7 @@
 #include "exec/operator/olap_scan_operator.h"
 #include "exec/operator/olap_table_sink_operator.h"
 #include "exec/operator/olap_table_sink_v2_operator.h"
+#include "exec/operator/paimon_table_sink_operator.h"
 #include "exec/operator/partition_sort_sink_operator.h"
 #include "exec/operator/partition_sort_source_operator.h"
 #include "exec/operator/partitioned_aggregation_sink_operator.h"
@@ -830,6 +831,7 @@ DECLARE_OPERATOR(OlapTableSinkV2LocalState)
 DECLARE_OPERATOR(HiveTableSinkLocalState)
 DECLARE_OPERATOR(TVFTableSinkLocalState)
 DECLARE_OPERATOR(IcebergTableSinkLocalState)
+DECLARE_OPERATOR(PaimonTableSinkLocalState)
 DECLARE_OPERATOR(SpillIcebergTableSinkLocalState)
 DECLARE_OPERATOR(IcebergDeleteSinkLocalState)
 DECLARE_OPERATOR(IcebergMergeSinkLocalState)
@@ -955,6 +957,7 @@ template class AsyncWriterSink<doris::VTabletWriter, OlapTableSinkOperatorX>;
 template class AsyncWriterSink<doris::VTabletWriterV2, OlapTableSinkV2OperatorX>;
 template class AsyncWriterSink<doris::VHiveTableWriter, HiveTableSinkOperatorX>;
 template class AsyncWriterSink<doris::VIcebergTableWriter, IcebergTableSinkOperatorX>;
+template class AsyncWriterSink<doris::PaimonTableWriter, PaimonTableSinkOperatorX>;
 template class AsyncWriterSink<doris::VIcebergTableWriter, SpillIcebergTableSinkOperatorX>;
 template class AsyncWriterSink<doris::VIcebergDeleteSink, IcebergDeleteSinkOperatorX>;
 template class AsyncWriterSink<doris::VIcebergMergeSink, IcebergMergeSinkOperatorX>;
diff --git a/be/src/exec/operator/paimon_table_sink_operator.cpp b/be/src/exec/operator/paimon_table_sink_operator.cpp
new file mode 100644
index 00000000000000..c1386be558ec62
--- /dev/null
+++ b/be/src/exec/operator/paimon_table_sink_operator.cpp
@@ -0,0 +1,39 @@
+// 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.
+
+#include "exec/operator/paimon_table_sink_operator.h"
+
+#include "common/logging.h"
+
+namespace doris {
+
+Status PaimonTableSinkLocalState::init(RuntimeState* state, LocalSinkStateInfo& info) {
+    return Base::init(state, info);
+}
+
+Status PaimonTableSinkOperatorX::sink_impl(RuntimeState* state, Block* in_block, bool eos) {
+    auto& local_state = get_local_state(state);
+    SCOPED_TIMER(local_state.exec_time_counter());
+    COUNTER_UPDATE(local_state.rows_input_counter(), static_cast<int64_t>(in_block->rows()));
+
+    // Delegate to AsyncWriterSink → PaimonTableWriter for this pipeline instance.
+    // Each pipeline instance has its own writer session; partition and bucket
+    // routing is handled internally by the Paimon SDK inside IPaimonWriter::write().
+    return local_state.sink(state, in_block, eos);
+}
+
+} // namespace doris
diff --git a/be/src/exec/operator/paimon_table_sink_operator.h b/be/src/exec/operator/paimon_table_sink_operator.h
new file mode 100644
index 00000000000000..3a2f885720348c
--- /dev/null
+++ b/be/src/exec/operator/paimon_table_sink_operator.h
@@ -0,0 +1,106 @@
+// 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.
+
+#pragma once
+
+#include <gen_cpp/DataSinks_types.h>
+
+#include <memory>
+#include <string>
+
+#include "common/status.h"
+#include "core/block/block.h"
+#include "exec/operator/operator.h"
+#include "exec/sink/writer/paimon/paimon_table_writer.h"
+#include "runtime/runtime_state.h"
+
+namespace doris {
+
+/// Paimon table sink operator — simple pass-through to AsyncWriterSink.
+///
+/// Each pipeline instance (LocalState) owns one PaimonTableWriter, which in
+/// turn owns one IPaimonWriteBackend + IPaimonWriter. Pipeline parallelism
+/// determines the number of concurrent Paimon writer sessions per table. FE's
+/// Paimon write provider currently requires GATHER so bucket assignment sees
+/// one ordered input stream.
+///
+/// Partition and bucket routing is performed internally by the Paimon Java SDK
+/// through JNI. Doris does not compute partition values or bucket ids; it
+/// passes complete Blocks through the backend to the SDK,
+/// where each row is routed via getPartition(row) + getBucket(row).
+///
+/// This mirrors Iceberg's approach: IcebergTableSinkOperatorX delegates to
+/// AsyncWriterSink<VIcebergTableWriter>, with partition routing inside
+/// VIcebergTableWriter::write().
+class PaimonTableSinkOperatorX;
+
+class PaimonTableSinkLocalState final
+        : public AsyncWriterSink<PaimonTableWriter, PaimonTableSinkOperatorX> {
+public:
+    using Base = AsyncWriterSink<PaimonTableWriter, PaimonTableSinkOperatorX>;
+    using Parent = PaimonTableSinkOperatorX;
+    ENABLE_FACTORY_CREATOR(PaimonTableSinkLocalState);
+    PaimonTableSinkLocalState(DataSinkOperatorXBase* parent, RuntimeState* state)
+            : Base(parent, state) {}
+    Status init(RuntimeState* state, LocalSinkStateInfo& info) override;
+    Status open(RuntimeState* state) override {
+        SCOPED_TIMER(exec_time_counter());
+        SCOPED_TIMER(_open_timer);
+        return Base::open(state);
+    }
+
+    friend class PaimonTableSinkOperatorX;
+};
+
+class PaimonTableSinkOperatorX final : public DataSinkOperatorX<PaimonTableSinkLocalState> {
+public:
+    using Base = DataSinkOperatorX<PaimonTableSinkLocalState>;
+    PaimonTableSinkOperatorX(ObjectPool* pool, int operator_id, const RowDescriptor& row_desc,
+                             const std::vector<TExpr>& t_output_expr)
+            : Base(operator_id, 0, 0),
+              _row_desc(row_desc),
+              _t_output_expr(t_output_expr),
+              _pool(pool) {}
+
+    Status init(const TDataSink& thrift_sink) override {
+        RETURN_IF_ERROR(Base::init(thrift_sink));
+        DCHECK(thrift_sink.__isset.paimon_table_sink);
+        RETURN_IF_ERROR(VExpr::create_expr_trees(_t_output_expr, _output_vexpr_ctxs));
+        return Status::OK();
+    }
+
+    Status prepare(RuntimeState* state) override {
+        RETURN_IF_ERROR(Base::prepare(state));
+        RETURN_IF_ERROR(VExpr::prepare(_output_vexpr_ctxs, state, _row_desc));
+        return VExpr::open(_output_vexpr_ctxs, state);
+    }
+
+    Status sink_impl(RuntimeState* state, Block* in_block, bool eos) override;
+
+private:
+    friend class PaimonTableSinkLocalState;
+    template <typename Writer, typename Parent>
+        requires(std::is_base_of_v<AsyncResultWriter, Writer>)
+    friend class AsyncWriterSink;
+
+    const RowDescriptor& _row_desc;
+    VExprContextSPtrs _output_vexpr_ctxs;
+    const std::vector<TExpr>& _t_output_expr;
+    ObjectPool* _pool = nullptr;
+};
+
+} // namespace doris
diff --git a/be/src/exec/pipeline/pipeline_fragment_context.cpp b/be/src/exec/pipeline/pipeline_fragment_context.cpp
index 2fa064c8a68e09..abf8db9c6fa102 100644
--- a/be/src/exec/pipeline/pipeline_fragment_context.cpp
+++ b/be/src/exec/pipeline/pipeline_fragment_context.cpp
@@ -88,6 +88,7 @@
 #include "exec/operator/olap_scan_operator.h"
 #include "exec/operator/olap_table_sink_operator.h"
 #include "exec/operator/olap_table_sink_v2_operator.h"
+#include "exec/operator/paimon_table_sink_operator.h"
 #include "exec/operator/partition_sort_sink_operator.h"
 #include "exec/operator/partition_sort_source_operator.h"
 #include "exec/operator/partitioned_aggregation_sink_operator.h"
@@ -1352,6 +1353,14 @@ Status PipelineFragmentContext::_create_data_sink(ObjectPool* pool, const TDataS
         }
         break;
     }
+    case TDataSinkType::PAIMON_TABLE_SINK: {
+        if (!thrift_sink.__isset.paimon_table_sink) {
+            return Status::InternalError("Missing paimon table sink.");
+        }
+        _sink = std::make_shared<PaimonTableSinkOperatorX>(pool, next_sink_operator_id(), row_desc,
+                                                           output_exprs);
+        break;
+    }
     case TDataSinkType::ICEBERG_DELETE_SINK: {
         if (!thrift_sink.__isset.iceberg_delete_sink) {
             return Status::InternalError("Missing iceberg delete sink.");
@@ -2585,7 +2594,8 @@ void PipelineFragmentContext::_coordinator_callback(const ReportStatusRequest& r
                                            PrintThriftNetworkAddress(req.coord_addr), e.what());
     }
 
-    const bool requires_external_file_ack = params.__isset.iceberg_commit_datas;
+    const bool requires_external_file_ack =
+            params.__isset.iceberg_commit_datas || params.__isset.paimon_commit_messages;
     if (rpc_status.ok() && requires_external_file_ack &&
         (!res.__isset.external_file_commit_data_accepted ||
          !res.external_file_commit_data_accepted)) {
diff --git a/be/src/exec/sink/writer/paimon/jni_paimon_write_backend.cpp b/be/src/exec/sink/writer/paimon/jni_paimon_write_backend.cpp
new file mode 100644
index 00000000000000..149835b68c9210
--- /dev/null
+++ b/be/src/exec/sink/writer/paimon/jni_paimon_write_backend.cpp
@@ -0,0 +1,622 @@
+// 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.
+
+#include "exec/sink/writer/paimon/jni_paimon_write_backend.h"
+
+#include <arrow/buffer.h>
+#include <arrow/io/memory.h>
+#include <arrow/ipc/writer.h>
+#include <arrow/record_batch.h>
+#include <arrow/type.h>
+
+#include <algorithm>
+#include <atomic>
+#include <map>
+#include <mutex>
+#include <string_view>
+#include <vector>
+
+#include "common/check.h"
+#include "common/logging.h"
+#include "core/data_type/data_type_agg_state.h"
+#include "core/data_type/data_type_array.h"
+#include "core/data_type/data_type_map.h"
+#include "core/data_type/data_type_struct.h"
+#include "exec/sink/writer/paimon/paimon_jni_memory_manager.h"
+#include "format/arrow/arrow_block_convertor.h"
+#include "format/arrow/arrow_row_batch.h"
+#include "runtime/exec_env.h"
+#include "runtime/runtime_state.h"
+#include "storage/options.h"
+#include "util/jni-util.h"
+#include "util/pretty_printer.h"
+#include "util/string_util.h"
+
+namespace doris {
+
+namespace {
+constexpr std::string_view PAIMON_JNI_WRITER_IO_TMP_DIR = "paimon_jni_writer_io_tmp";
+
+std::atomic<bool>& paimon_jni_close_failed() {
+    static auto* failed = new std::atomic<bool>(false);
+    return *failed;
+}
+
+std::mutex& retained_memory_managers_mutex() {
+    static auto* mutex = new std::mutex();
+    return *mutex;
+}
+
+std::vector<std::unique_ptr<PaimonJniMemoryManager>>& retained_memory_managers() {
+    static auto* managers = new std::vector<std::unique_ptr<PaimonJniMemoryManager>>();
+    return *managers;
+}
+
+void retain_memory_after_failed_close(std::unique_ptr<PaimonJniMemoryManager> manager) {
+    paimon_jni_close_failed().store(true, std::memory_order_release);
+    if (manager == nullptr) {
+        return;
+    }
+    std::lock_guard<std::mutex> lock(retained_memory_managers_mutex());
+    retained_memory_managers().emplace_back(std::move(manager));
+}
+
+Status convert_to_paimon_arrow_type(const DataTypePtr& origin_type,
+                                    std::shared_ptr<arrow::DataType>* result,
+                                    const std::string& timezone) {
+    const DataTypePtr type = get_serialized_type(origin_type);
+    switch (type->get_primitive_type()) {
+    case TYPE_VARIANT:
+        // Paimon consumes the lossless Variant V2 representation. Keeping both children non-null
+        // distinguishes a SQL NULL struct from a non-null Variant value.
+        *result = arrow::struct_({arrow::field("value", arrow::binary(), false),
+                                  arrow::field("metadata", arrow::binary(), false)});
+        return Status::OK();
+    case TYPE_ARRAY: {
+        const auto& array_type = assert_cast<const DataTypeArray&>(*remove_nullable(type));
+        std::shared_ptr<arrow::DataType> element_type;
+        RETURN_IF_ERROR(convert_to_paimon_arrow_type(array_type.get_nested_type(), &element_type,
+                                                     timezone));
+        *result = std::make_shared<arrow::ListType>(element_type);
+        return Status::OK();
+    }
+    case TYPE_MAP: {
+        const auto& map_type = assert_cast<const DataTypeMap&>(*remove_nullable(type));
+        std::shared_ptr<arrow::DataType> key_type;
+        std::shared_ptr<arrow::DataType> value_type;
+        RETURN_IF_ERROR(convert_to_paimon_arrow_type(map_type.get_key_type(), &key_type, timezone));
+        RETURN_IF_ERROR(
+                convert_to_paimon_arrow_type(map_type.get_value_type(), &value_type, timezone));
+        *result = std::make_shared<arrow::MapType>(key_type, value_type);
+        return Status::OK();
+    }
+    case TYPE_STRUCT: {
+        const auto& struct_type = assert_cast<const DataTypeStruct&>(*remove_nullable(type));
+        std::vector<std::shared_ptr<arrow::Field>> fields;
+        fields.reserve(struct_type.get_elements().size());
+        for (size_t i = 0; i < struct_type.get_elements().size(); ++i) {
+            const DataTypePtr& element = struct_type.get_element(i);
+            std::shared_ptr<arrow::DataType> field_type;
+            RETURN_IF_ERROR(convert_to_paimon_arrow_type(element, &field_type, timezone));
+            fields.push_back(arrow::field(struct_type.get_element_name(i), field_type,
+                                          element->is_nullable()));
+        }
+        *result = arrow::struct_(std::move(fields));
+        return Status::OK();
+    }
+    default:
+        return convert_to_arrow_type(origin_type, result, timezone);
+    }
+}
+
+Status get_paimon_arrow_schema_from_block(const Block& block,
+                                          std::shared_ptr<arrow::Schema>* result) {
+    std::vector<std::shared_ptr<arrow::Field>> fields;
+    fields.reserve(block.columns());
+    for (const auto& type_and_name : block) {
+        std::shared_ptr<arrow::DataType> arrow_type;
+        RETURN_IF_ERROR(convert_to_paimon_arrow_type(type_and_name.type, &arrow_type, ""));
+        fields.push_back(create_arrow_field_with_metadata(
+                type_and_name.name, arrow_type, type_and_name.type->is_nullable(),
+                type_and_name.type->get_primitive_type()));
+    }
+    *result = arrow::schema(std::move(fields));
+    return Status::OK();
+}
+} // namespace
+
+// ────────────────────────────────────────────────────────────
+// JNI helpers — JVM attachment and class loading
+// ────────────────────────────────────────────────────────────
+
+static constexpr const char* PAIMON_JNI_WRITER_CLASS = "org/apache/doris/paimon/PaimonJniWriter";
+static constexpr const char* SCANNER_LOADER_CLASS =
+        "org/apache/doris/common/classloader/ScannerLoader";
+
+/// Attach the current native thread to the JVM if not already attached,
+/// and return a valid JNIEnv pointer.
+static Status _get_jni_env(JNIEnv** env) {
+    JavaVM* jvm = nullptr;
+    jsize n_vms = 0;
+    jint result = JNI_GetCreatedJavaVMs(&jvm, 1, &n_vms);
+    if (result != JNI_OK || n_vms == 0) {
+        return Status::InternalError("Failed to get created JavaVM");
+    }
+    result = jvm->GetEnv(reinterpret_cast<void**>(env), JNI_VERSION_1_8);
+    if (result == JNI_EDETACHED) {
+        result = jvm->AttachCurrentThread(reinterpret_cast<void**>(env), nullptr);
+        if (result != JNI_OK) {
+            return Status::InternalError("Failed to attach current thread to JVM");
+        }
+    } else if (result != JNI_OK) {
+        return Status::InternalError("Failed to get JNIEnv");
+    }
+    return Status::OK();
+}
+
+JniPaimonWriteBackend::~JniPaimonWriteBackend() {
+    Status st = close();
+    if (!st.ok()) {
+        LOG(WARNING) << "Failed to close Paimon JNI backend during destruction: " << st.to_string();
+    }
+}
+
+Status JniPaimonWriteBackend::close() {
+    if (_jni_writer_obj == nullptr && _jni_writer_cls == nullptr) {
+        _memory_manager.reset();
+        _opened = false;
+        return Status::OK();
+    }
+
+    JNIEnv* env = nullptr;
+    Status env_status = _get_jni_env(&env);
+    if (!env_status.ok()) {
+        bool java_users_may_exist = _jni_writer_obj != nullptr;
+        // JNI global references cannot be released without an environment.
+        // Deliberately abandon the handles so the Java writer remains alive.
+        _jni_writer_obj = nullptr;
+        _jni_writer_cls = nullptr;
+        if (java_users_may_exist) {
+            retain_memory_after_failed_close(std::move(_memory_manager));
+        } else {
+            _memory_manager.reset();
+        }
+        _opened = false;
+        return env_status;
+    }
+
+    Status close_status = Status::OK();
+    if (_jni_writer_obj != nullptr) {
+        _refresh_memory_profile();
+        if (_close_id == nullptr) {
+            close_status = Status::InternalError("PaimonJniWriter.close method is unavailable");
+        } else {
+            env->CallVoidMethod(_jni_writer_obj, _close_id);
+            close_status = _check_jni_exception(env, "close PaimonJniWriter");
+        }
+        env->DeleteGlobalRef(_jni_writer_obj);
+        _jni_writer_obj = nullptr;
+    }
+    if (_jni_writer_cls != nullptr) {
+        env->DeleteGlobalRef(_jni_writer_cls);
+        _jni_writer_cls = nullptr;
+    }
+
+    if (close_status.ok()) {
+        _memory_manager.reset();
+    } else {
+        if (_memory_manager != nullptr) {
+            LOG(WARNING)
+                    << "Retaining Paimon JNI native memory after an unconfirmed Java close: limit="
+                    << PrettyPrinter::print_bytes(_memory_manager->memory_limit()) << ", peak="
+                    << PrettyPrinter::print_bytes(_memory_manager->native_peak_allocated_bytes());
+        }
+        // Paimon may still have asynchronous flush or compaction tasks using
+        // MemorySegments backed by these pages. Retain ownership until process
+        // exit and reject new writers below. Retention is therefore limited to
+        // writers which were already open when the first close failure occurred.
+        retain_memory_after_failed_close(std::move(_memory_manager));
+    }
+    _opened = false;
+    return close_status;
+}
+
+Status JniPaimonWriteBackend::_check_jni_exception(JNIEnv* env, const std::string& method_name) {
+    if (env->ExceptionCheck()) {
+        Status st =
+                Jni::Env::GetJniExceptionMsg(env, true, "JNI exception in " + method_name + ": ");
+        LOG(WARNING) << st.to_string();
+        return st;
+    }
+    return Status::OK();
+}
+
+Status JniPaimonWriteBackend::_load_writer_class(JNIEnv* env, jclass* writer_class) {
+    jclass loader_class = env->FindClass(SCANNER_LOADER_CLASS);
+    RETURN_IF_ERROR(_check_jni_exception(env, "find ScannerLoader"));
+
+    jmethodID loader_constructor = env->GetMethodID(loader_class, "<init>", "()V");
+    jmethodID get_loaded_class = env->GetMethodID(loader_class, "getLoadedClass",
+                                                  "(Ljava/lang/String;)Ljava/lang/Class;");
+    RETURN_IF_ERROR(_check_jni_exception(env, "resolve ScannerLoader methods"));
+
+    jobject loader = env->NewObject(loader_class, loader_constructor);
+    jstring class_name = env->NewStringUTF(PAIMON_JNI_WRITER_CLASS);
+    auto* loaded_class =
+            static_cast<jclass>(env->CallObjectMethod(loader, get_loaded_class, class_name));
+    RETURN_IF_ERROR(_check_jni_exception(env, "load PaimonJniWriter"));
+
+    *writer_class = loaded_class;
+    env->DeleteLocalRef(class_name);
+    env->DeleteLocalRef(loader);
+    env->DeleteLocalRef(loader_class);
+    return Status::OK();
+}
+
+static jobject _to_java_options(JNIEnv* env, const std::map<std::string, std::string>& options) {
+    jclass map_cls = env->FindClass("java/util/HashMap");
+    jmethodID map_ctor = env->GetMethodID(map_cls, "<init>", "()V");
+    jmethodID put_method = env->GetMethodID(
+            map_cls, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+
+    jobject map_obj = env->NewObject(map_cls, map_ctor);
+    for (const auto& kv : options) {
+        jstring key = env->NewStringUTF(kv.first.c_str());
+        jstring val = env->NewStringUTF(kv.second.c_str());
+        env->CallObjectMethod(map_obj, put_method, key, val);
+        env->DeleteLocalRef(key);
+        env->DeleteLocalRef(val);
+    }
+    env->DeleteLocalRef(map_cls);
+    return map_obj;
+}
+
+Status JniPaimonWriteBackend::abort_prepared_commit(
+        const TPaimonTableSink& sink, const std::vector<TPaimonCommitMessage>& commit_messages) {
+    if (commit_messages.empty()) {
+        return Status::OK();
+    }
+
+    JNIEnv* env = nullptr;
+    RETURN_IF_ERROR(_get_jni_env(&env));
+
+    jclass writer_class = nullptr;
+    RETURN_IF_ERROR(_load_writer_class(env, &writer_class));
+    jmethodID abort_id =
+            env->GetStaticMethodID(writer_class, "abortPreparedCommit",
+                                   "(Ljava/lang/String;Ljava/util/Map;Ljava/lang/String;[[B)V");
+    Status method_status = _check_jni_exception(env, "resolve abortPreparedCommit");
+    if (!method_status.ok()) {
+        env->DeleteLocalRef(writer_class);
+        return method_status;
+    }
+
+    const std::map<std::string, std::string> empty_config;
+    jstring serialized_table = env->NewStringUTF(sink.serialized_table.c_str());
+    jobject hadoop_config =
+            _to_java_options(env, sink.__isset.hadoop_config ? sink.hadoop_config : empty_config);
+    jstring commit_user = env->NewStringUTF(sink.commit_user.c_str());
+    jclass byte_array_class = env->FindClass("[B");
+    auto payloads = env->NewObjectArray(static_cast<jsize>(commit_messages.size()),
+                                        byte_array_class, nullptr);
+    Status allocation_status = _check_jni_exception(env, "allocate abortPreparedCommit arguments");
+    if (allocation_status.ok()) {
+        for (size_t i = 0; i < commit_messages.size(); ++i) {
+            const auto& message = commit_messages[i];
+            DORIS_CHECK(message.__isset.payload);
+            auto payload = env->NewByteArray(static_cast<jsize>(message.payload.size()));
+            env->SetByteArrayRegion(payload, 0, static_cast<jsize>(message.payload.size()),
+                                    reinterpret_cast<const jbyte*>(message.payload.data()));
+            env->SetObjectArrayElement(payloads, static_cast<jsize>(i), payload);
+            env->DeleteLocalRef(payload);
+        }
+        allocation_status = _check_jni_exception(env, "populate abortPreparedCommit payloads");
+    }
+
+    Status abort_status = allocation_status;
+    if (abort_status.ok()) {
+        env->CallStaticVoidMethod(writer_class, abort_id, serialized_table, hadoop_config,
+                                  commit_user, payloads);
+        abort_status = _check_jni_exception(env, "abort prepared Paimon commit");
+    }
+
+    if (payloads != nullptr) {
+        env->DeleteLocalRef(payloads);
+    }
+    if (byte_array_class != nullptr) {
+        env->DeleteLocalRef(byte_array_class);
+    }
+    if (commit_user != nullptr) {
+        env->DeleteLocalRef(commit_user);
+    }
+    if (hadoop_config != nullptr) {
+        env->DeleteLocalRef(hadoop_config);
+    }
+    if (serialized_table != nullptr) {
+        env->DeleteLocalRef(serialized_table);
+    }
+    env->DeleteLocalRef(writer_class);
+    return abort_status;
+}
+
+Status JniPaimonWriteBackend::open(const TPaimonTableSink& sink, RuntimeState* state,
+                                   RuntimeProfile* profile) {
+    if (paimon_jni_close_failed().load(std::memory_order_acquire)) {
+        return Status::InternalError(
+                "Paimon JNI writes are disabled on this BE because a previous Java writer close "
+                "failed; restart the BE to reclaim retained native memory safely");
+    }
+    _sink = sink;
+    DORIS_CHECK(sink.__isset.column_names);
+    DORIS_CHECK(sink.__isset.write_mode);
+    DORIS_CHECK(sink.__isset.serialized_table);
+    DORIS_CHECK(!sink.serialized_table.empty());
+    DORIS_CHECK(sink.__isset.transaction_id);
+    DORIS_CHECK(sink.transaction_id > 0);
+    DORIS_CHECK(sink.__isset.commit_user);
+    DORIS_CHECK(!sink.commit_user.empty());
+    DORIS_CHECK(profile != nullptr);
+
+    RETURN_IF_ERROR(PaimonJniMemoryManager::create(state, &_memory_manager));
+    RuntimeProfile* jni_profile = profile->create_child("JniPaimonWriteBackend", true, true);
+    _native_page_memory_limit = ADD_COUNTER(jni_profile, "NativePageMemoryLimit", TUnit::BYTES);
+    _native_page_memory_peak = ADD_COUNTER(jni_profile, "NativePageMemoryPeak", TUnit::BYTES);
+
+    JNIEnv* env = nullptr;
+    RETURN_IF_ERROR(_get_jni_env(&env));
+
+    // Step 1: Load PaimonJniWriter class through ScannerLoader (Paimon jars are
+    // not on the default application classpath, so FindClass won't work).
+    jclass local_cls = nullptr;
+    RETURN_IF_ERROR(_load_writer_class(env, &local_cls));
+    _jni_writer_cls = static_cast<jclass>(env->NewGlobalRef(local_cls));
+    env->DeleteLocalRef(local_cls);
+    RETURN_IF_ERROR(PaimonJniMemoryManager::register_natives(env, _jni_writer_cls));
+
+    // Step 2: Cache JNI method IDs for write, prepareCommit, abort, close.
+    jmethodID open_id = env->GetMethodID(
+            _jni_writer_cls, "open",
+            "(Ljava/lang/String;Ljava/util/Map;[Ljava/lang/String;JLjava/lang/String;ZLjava/lang/"
+            "String;Ljava/lang/String;JJ)V");
+    _write_id = env->GetMethodID(_jni_writer_cls, "write", "(Ljava/nio/ByteBuffer;)V");
+    _prepare_commit_id = env->GetMethodID(_jni_writer_cls, "prepareCommit", "()[[B");
+    _abort_id = env->GetMethodID(_jni_writer_cls, "abort", "()V");
+    _close_id = env->GetMethodID(_jni_writer_cls, "close", "()V");
+    RETURN_IF_ERROR(_check_jni_exception(env, "GetMethodID"));
+
+    // Step 3: Create the Java PaimonJniWriter instance.
+    jmethodID ctor_id = env->GetMethodID(_jni_writer_cls, "<init>", "()V");
+    jobject local_obj = env->NewObject(_jni_writer_cls, ctor_id);
+    RETURN_IF_ERROR(_check_jni_exception(env, "NewObject"));
+    _jni_writer_obj = env->NewGlobalRef(local_obj);
+    env->DeleteLocalRef(local_obj);
+
+    // Step 4: Build Java arguments and call PaimonJniWriter.open().
+    const std::map<std::string, std::string> empty_config;
+    jstring j_serialized_table = env->NewStringUTF(sink.serialized_table.c_str());
+    jobject j_hadoop_config =
+            _to_java_options(env, sink.__isset.hadoop_config ? sink.hadoop_config : empty_config);
+    jstring j_commit_user = env->NewStringUTF(sink.commit_user.c_str());
+    jstring j_time_zone = env->NewStringUTF(state->timezone().c_str());
+    std::vector<std::string> spill_directories;
+    for (const auto& store_path : state->exec_env()->store_paths()) {
+        spill_directories.push_back(store_path.path + "/" +
+                                    std::string(PAIMON_JNI_WRITER_IO_TMP_DIR));
+    }
+    DORIS_CHECK(!spill_directories.empty());
+    jstring j_spill_directories = env->NewStringUTF(join(spill_directories, ":").c_str());
+
+    jclass string_cls = env->FindClass("java/lang/String");
+    jobjectArray j_cols =
+            env->NewObjectArray(static_cast<jsize>(sink.column_names.size()), string_cls, nullptr);
+    for (size_t i = 0; i < sink.column_names.size(); ++i) {
+        jstring str = env->NewStringUTF(sink.column_names[i].c_str());
+        env->SetObjectArrayElement(j_cols, static_cast<jsize>(i), str);
+        env->DeleteLocalRef(str);
+    }
+
+    env->CallVoidMethod(_jni_writer_obj, open_id, j_serialized_table, j_hadoop_config, j_cols,
+                        static_cast<jlong>(sink.transaction_id), j_commit_user,
+                        static_cast<jboolean>(sink.write_mode == TPaimonWriteMode::OVERWRITE),
+                        j_time_zone, j_spill_directories,
+                        static_cast<jlong>(_memory_manager->memory_limit()),
+                        reinterpret_cast<jlong>(_memory_manager.get()));
+    Status st = _check_jni_exception(env, "open");
+
+    env->DeleteLocalRef(j_serialized_table);
+    env->DeleteLocalRef(j_hadoop_config);
+    env->DeleteLocalRef(j_commit_user);
+    env->DeleteLocalRef(j_time_zone);
+    env->DeleteLocalRef(j_spill_directories);
+    env->DeleteLocalRef(j_cols);
+    env->DeleteLocalRef(string_cls);
+
+    if (st.ok()) {
+        _opened = true;
+        _refresh_memory_profile();
+        LOG(INFO) << "Paimon JNI writer memory limit: "
+                  << PrettyPrinter::print_bytes(_memory_manager->memory_limit())
+                  << ", local_sink_count=" << std::max(1, state->num_local_sink());
+    }
+    return st;
+}
+
+Status JniPaimonWriteBackend::create_writer( // NOLINT(readability-make-member-function-const)
+        std::unique_ptr<IPaimonWriter>* writer) {
+    DORIS_CHECK(_opened);
+    *writer = std::make_unique<JniPaimonWriter>(_jni_writer_obj, _write_id, _prepare_commit_id,
+                                                _abort_id, std::make_unique<ArrowMemoryPool<>>(),
+                                                _sink);
+    return Status::OK();
+}
+
+JniPaimonWriter::JniPaimonWriter(jobject jni_writer_obj, jmethodID write_id,
+                                 jmethodID prepare_commit_id, jmethodID abort_id,
+                                 std::unique_ptr<ArrowMemoryPool<>> arrow_pool,
+                                 TPaimonTableSink sink)
+        : _jni_writer_obj(jni_writer_obj),
+          _write_id(write_id),
+          _prepare_commit_id(prepare_commit_id),
+          _abort_id(abort_id),
+          _arrow_pool(std::move(arrow_pool)),
+          _sink(std::move(sink)) {}
+
+Status JniPaimonWriter::_write_projected_block(RuntimeState* state, Block& block) {
+    if (block.rows() == 0) {
+        return Status::OK();
+    }
+
+    // Use Thrift column_names as the authoritative schema source for both
+    // Arrow schema construction and Java-side write type derivation.
+    DORIS_CHECK(_sink.__isset.column_names);
+    DORIS_CHECK_EQ(_sink.column_names.size(), block.columns());
+    for (size_t i = 0; i < _sink.column_names.size(); ++i) {
+        block.get_by_position(i).name = _sink.column_names[i];
+    }
+
+    // Pipeline: Doris Block → Arrow Schema → Arrow RecordBatch → IPC Stream → JNI direct buffer
+    //
+    // Step 1: Build Arrow schema from the projected Block.
+    // Paimon write timestamps are transported as civil-time fields. The Java writer uses the
+    // pinned Paimon target type to preserve NTZ values or convert LTZ values with the session zone.
+    // Variant V2 is transported losslessly as its value/metadata pair, including nested Variant.
+    std::shared_ptr<arrow::Schema> arrow_schema;
+    RETURN_IF_ERROR(get_paimon_arrow_schema_from_block(block, &arrow_schema));
+
+    // Step 2: Convert Doris Block columns to an Arrow RecordBatch.
+    std::shared_ptr<arrow::RecordBatch> record_batch;
+    RETURN_IF_ERROR(convert_to_arrow_batch(block, arrow_schema, _arrow_pool.get(), &record_batch,
+                                           state->timezone_obj()));
+
+    // Step 3: Serialize the RecordBatch to Arrow IPC Stream format in memory.
+    auto out_stream_res = arrow::io::BufferOutputStream::Create(4096, _arrow_pool.get());
+    if (!out_stream_res.ok()) {
+        return Status::InternalError("Arrow BufferOutputStream create failed: {}",
+                                     out_stream_res.status().ToString());
+    }
+    auto out_stream = *out_stream_res;
+
+    auto writer_res = arrow::ipc::MakeStreamWriter(out_stream, arrow_schema);
+    if (!writer_res.ok()) {
+        return Status::InternalError("Arrow StreamWriter create failed: {}",
+                                     writer_res.status().ToString());
+    }
+    auto ipc_writer = *writer_res;
+    if (!ipc_writer->WriteRecordBatch(*record_batch).ok()) {
+        return Status::InternalError("Arrow WriteRecordBatch failed");
+    }
+    if (!ipc_writer->Close().ok()) {
+        return Status::InternalError("Arrow StreamWriter close failed");
+    }
+
+    auto buffer_res = out_stream->Finish();
+    if (!buffer_res.ok()) {
+        return Status::InternalError("Arrow output stream finish failed: {}",
+                                     buffer_res.status().ToString());
+    }
+    std::shared_ptr<arrow::Buffer> buffer = *buffer_res;
+
+    // Step 4: Wrap the IPC buffer in a JNI direct ByteBuffer (zero-copy) and
+    // call PaimonJniWriter.write(ByteBuffer). Java side reads the Arrow IPC
+    // stream via ArrowStreamReader.
+    JNIEnv* env = nullptr;
+    RETURN_IF_ERROR(_get_jni_env(&env));
+
+    jobject direct_buffer =
+            env->NewDirectByteBuffer(buffer->mutable_data(), static_cast<jlong>(buffer->size()));
+    RETURN_IF_ERROR(Jni::Env::GetJniExceptionMsg(
+            env, false, "JNI exception in NewDirectByteBuffer for PaimonJniWriter::write: "));
+
+    env->CallVoidMethod(_jni_writer_obj, _write_id, direct_buffer);
+    Status write_status =
+            Jni::Env::GetJniExceptionMsg(env, false, "JNI exception in JniPaimonWriter::write: ");
+    env->DeleteLocalRef(direct_buffer);
+    return write_status;
+}
+
+Status JniPaimonWriter::write(RuntimeState* state, Block& block) {
+    return _write_projected_block(state, block);
+}
+
+Status JniPaimonWriter::prepare_commit(std::vector<TPaimonCommitMessage>& messages) {
+    JNIEnv* env = nullptr;
+    RETURN_IF_ERROR(_get_jni_env(&env));
+
+    // Call PaimonJniWriter.prepareCommit() which returns byte[][] —
+    // each element is a DPCM-framed serialized CommitMessage chunk produced
+    // by PaimonCommitCodec.encode().
+    jobject j_payloads_obj = env->CallObjectMethod(_jni_writer_obj, _prepare_commit_id);
+    Status st = Jni::Env::GetJniExceptionMsg(env, false, "JNI exception in prepareCommit: ");
+    if (!st.ok()) {
+        return st;
+    }
+
+    if (j_payloads_obj == nullptr) {
+        return Status::InternalError("PaimonJniWriter.prepareCommit returned null");
+    }
+
+    // Unpack the byte[][] into TPaimonCommitMessage structs for FE transport.
+    auto* j_payloads = static_cast<jobjectArray>(j_payloads_obj);
+    jsize num_payloads = env->GetArrayLength(j_payloads);
+
+    for (jsize i = 0; i < num_payloads; ++i) {
+        auto j_bytes = static_cast<jbyteArray>(env->GetObjectArrayElement(j_payloads, i));
+        if (j_bytes == nullptr) {
+            env->DeleteLocalRef(j_payloads);
+            return Status::InternalError("PaimonJniWriter.prepareCommit returned a null payload");
+        }
+        jsize len = env->GetArrayLength(j_bytes);
+        if (len == 0) {
+            env->DeleteLocalRef(j_bytes);
+            env->DeleteLocalRef(j_payloads);
+            return Status::InternalError("PaimonJniWriter.prepareCommit returned an empty payload");
+        }
+        jbyte* bytes = env->GetByteArrayElements(j_bytes, nullptr);
+        if (bytes == nullptr) {
+            env->DeleteLocalRef(j_bytes);
+            env->DeleteLocalRef(j_payloads);
+            RETURN_IF_ERROR(Jni::Env::GetJniExceptionMsg(
+                    env, false, "JNI exception while reading Paimon commit payload: "));
+            return Status::InternalError("Failed to read Paimon commit payload");
+        }
+        std::string payload(reinterpret_cast<char*>(bytes), static_cast<size_t>(len));
+        TPaimonCommitMessage msg;
+        msg.__set_payload(payload);
+        messages.emplace_back(std::move(msg));
+        env->ReleaseByteArrayElements(j_bytes, bytes, JNI_ABORT);
+        env->DeleteLocalRef(j_bytes);
+    }
+    env->DeleteLocalRef(j_payloads);
+    return Status::OK();
+}
+
+Status JniPaimonWriter::abort() {
+    JNIEnv* env = nullptr;
+    RETURN_IF_ERROR(_get_jni_env(&env));
+    env->CallVoidMethod(_jni_writer_obj, _abort_id);
+    return Jni::Env::GetJniExceptionMsg(env, true, "JNI exception in abort: ");
+}
+
+void JniPaimonWriteBackend::_refresh_memory_profile() {
+    if (_memory_manager == nullptr) {
+        return;
+    }
+    COUNTER_SET(_native_page_memory_limit, _memory_manager->memory_limit());
+    COUNTER_SET(_native_page_memory_peak, _memory_manager->native_peak_allocated_bytes());
+}
+
+} // namespace doris
diff --git a/be/src/exec/sink/writer/paimon/jni_paimon_write_backend.h b/be/src/exec/sink/writer/paimon/jni_paimon_write_backend.h
new file mode 100644
index 00000000000000..46cea7da85f7a6
--- /dev/null
+++ b/be/src/exec/sink/writer/paimon/jni_paimon_write_backend.h
@@ -0,0 +1,110 @@
+// 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.
+
+#pragma once
+
+#include <gen_cpp/DataSinks_types.h>
+#include <jni.h>
+
+#include <memory>
+#include <string>
+
+#include "common/status.h"
+#include "exec/sink/writer/paimon/paimon_jni_memory_manager.h"
+#include "exec/sink/writer/paimon/paimon_write_backend.h"
+#include "format/parquet/arrow_memory_pool.h"
+#include "runtime/runtime_profile.h"
+
+namespace doris {
+
+class RuntimeState;
+
+/// JNI backend that owns the Java PaimonJniWriter object and its JNI method
+/// handles. Creates lightweight JniPaimonWriter adapters that share this
+/// backend's JVM connection.
+///
+/// Each JniPaimonWriteBackend corresponds to one Java PaimonJniWriter
+/// instance; the JniPaimonWriter adapters are thin wrappers that delegate
+/// write/prepare_commit/abort calls through the cached JNI method IDs. JNI-only
+/// memory ownership and Profile counters stay here and are not part of the
+/// common backend contract.
+class JniPaimonWriteBackend final : public IPaimonWriteBackend {
+public:
+    ~JniPaimonWriteBackend() override;
+
+    Status open(const TPaimonTableSink& sink, RuntimeState* state,
+                RuntimeProfile* profile) override;
+    Status create_writer(std::unique_ptr<IPaimonWriter>* writer) override;
+    Status close() override;
+
+    /// Abort prepared files without retaining the original Java writer object.
+    static Status abort_prepared_commit(const TPaimonTableSink& sink,
+                                        const std::vector<TPaimonCommitMessage>& commit_messages);
+
+private:
+    static Status _check_jni_exception(JNIEnv* env, const std::string& method_name);
+    static Status _load_writer_class(JNIEnv* env, jclass* writer_class);
+    void _refresh_memory_profile();
+
+    // JNI global references — live for the duration of this backend.
+    jclass _jni_writer_cls = nullptr;
+    jobject _jni_writer_obj = nullptr;
+
+    // Cached JNI method IDs for the PaimonJniWriter Java methods.
+    jmethodID _write_id = nullptr;
+    jmethodID _prepare_commit_id = nullptr;
+    jmethodID _abort_id = nullptr;
+    jmethodID _close_id = nullptr;
+
+    TPaimonTableSink _sink;
+    std::unique_ptr<PaimonJniMemoryManager> _memory_manager;
+    RuntimeProfile::Counter* _native_page_memory_limit = nullptr;
+    RuntimeProfile::Counter* _native_page_memory_peak = nullptr;
+    bool _opened = false;
+};
+
+/// Lightweight C++ adapter that delegates to the shared JNI backend.
+///
+/// Owns the Arrow memory pool used for Block → Arrow IPC conversion.
+/// Each JniPaimonWriter is created by JniPaimonWriteBackend::create_writer()
+/// and shares the backend's JNI method IDs and Java writer object reference.
+class JniPaimonWriter final : public IPaimonWriter {
+public:
+    JniPaimonWriter(jobject jni_writer_obj, jmethodID write_id, jmethodID prepare_commit_id,
+                    jmethodID abort_id, std::unique_ptr<ArrowMemoryPool<>> arrow_pool,
+                    TPaimonTableSink sink);
+
+    Status write(RuntimeState* state, Block& block) override;
+    Status prepare_commit(std::vector<TPaimonCommitMessage>& messages) override;
+    Status abort() override;
+
+private:
+    /// Convert Block → Arrow RecordBatch → IPC Stream, then pass to Java via JNI direct buffer.
+    Status _write_projected_block(RuntimeState* state, Block& block);
+
+    // Shared JNI state (owned by JniPaimonWriteBackend, not this adapter).
+    jobject _jni_writer_obj;
+    jmethodID _write_id;
+    jmethodID _prepare_commit_id;
+    jmethodID _abort_id;
+
+    // Arrow resources owned by this writer adapter.
+    std::unique_ptr<ArrowMemoryPool<>> _arrow_pool;
+    TPaimonTableSink _sink;
+};
+
+} // namespace doris
diff --git a/be/src/exec/sink/writer/paimon/paimon_jni_memory_manager.cpp b/be/src/exec/sink/writer/paimon/paimon_jni_memory_manager.cpp
new file mode 100644
index 00000000000000..63eae9904e8c73
--- /dev/null
+++ b/be/src/exec/sink/writer/paimon/paimon_jni_memory_manager.cpp
@@ -0,0 +1,304 @@
+// 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.
+
+#include "exec/sink/writer/paimon/paimon_jni_memory_manager.h"
+
+#include <algorithm>
+#include <mutex>
+#include <utility>
+#include <vector>
+
+#include "common/check.h"
+#include "common/config.h"
+#include "common/exception.h"
+#include "common/logging.h"
+#include "core/allocator.h"
+#include "runtime/memory/mem_tracker_limiter.h"
+#include "runtime/query_context.h"
+#include "runtime/runtime_state.h"
+#include "runtime/thread_context.h"
+#include "util/defer_op.h"
+#include "util/jni-util.h"
+#include "util/pretty_printer.h"
+
+namespace doris {
+
+class PaimonJniMemoryManager::Impl {
+public:
+    Impl(std::shared_ptr<ResourceContext> resource_context, int64_t memory_limit)
+            : _resource_context(std::move(resource_context)), _memory_limit(memory_limit) {
+        DORIS_CHECK(_resource_context != nullptr);
+        DORIS_CHECK(_memory_limit > 0);
+    }
+
+    ~Impl() {
+        // Java may retain direct buffers until its writer is closed.  Release
+        // every outstanding page here as the final native ownership boundary.
+        try {
+            release_all_pages();
+        } catch (const std::exception& e) {
+            LOG(WARNING) << "Failed to release Paimon JNI native memory: " << e.what();
+        } catch (...) {
+            LOG(WARNING) << "Failed to release Paimon JNI native memory: unknown exception";
+        }
+    }
+
+    jobject allocate_page(JNIEnv* env, jint bytes) {
+        if (bytes <= 0) {
+            throw Exception(Status::InvalidArgument(
+                    "Paimon JNI memory page size must be positive, actual={}", bytes));
+        }
+
+        // Reserve the writer-local budget before entering the allocator. This
+        // prevents concurrent JNI callbacks from transiently allocating past
+        // the configured cap and only discovering it after query accounting
+        // or the system allocator has already rejected the request.
+        {
+            std::lock_guard<std::mutex> lock(_mutex);
+            if (bytes > _memory_limit - _native_allocated_bytes - _native_reserved_bytes) {
+                throw Exception(Status::Error<ErrorCode::QUERY_MEMORY_EXCEEDED>(
+                        "Paimon JNI write buffer exceeded its {} native memory limit",
+                        PrettyPrinter::print_bytes(_memory_limit)));
+            }
+            _native_reserved_bytes += bytes;
+        }
+        bool reservation_committed = false;
+        Defer rollback_reservation {[&]() {
+            if (!reservation_committed) {
+                std::lock_guard<std::mutex> lock(_mutex);
+                _native_reserved_bytes -= bytes;
+            }
+        }};
+
+        // Allocate and account while attached to the query's resource
+        // context.  The callback can run on a JVM-created thread, so merely
+        // relying on the calling BE thread's context would bypass query
+        // memory accounting.
+        void* address = with_resource_context([&]() {
+            enable_thread_catch_bad_alloc++;
+            Defer restore_bad_alloc_catch {[&]() { enable_thread_catch_bad_alloc--; }};
+            void* allocated = _allocator.alloc(static_cast<size_t>(bytes));
+            try {
+                std::lock_guard<std::mutex> lock(_mutex);
+                _allocations.emplace_back(allocated, static_cast<size_t>(bytes));
+                _native_reserved_bytes -= bytes;
+                _native_allocated_bytes += bytes;
+                _native_peak_allocated_bytes =
+                        std::max(_native_peak_allocated_bytes, _native_allocated_bytes);
+                reservation_committed = true;
+            } catch (...) {
+                _allocator.free(allocated, static_cast<size_t>(bytes));
+                throw;
+            }
+            return allocated;
+        });
+
+        // NewDirectByteBuffer does not copy memory; Paimon will read/write the
+        // page directly.  If JNI rejects the address, undo the native
+        // allocation and its accounting entry before returning.
+        jobject buffer = env->NewDirectByteBuffer(address, bytes);
+        if (buffer == nullptr || env->ExceptionCheck()) {
+            remove_and_free_page(address, static_cast<size_t>(bytes));
+            return nullptr;
+        }
+        return buffer;
+    }
+
+    int64_t memory_limit() const { return _memory_limit; }
+
+    int64_t native_peak_allocated_bytes() const {
+        std::lock_guard<std::mutex> lock(_mutex);
+        return _native_peak_allocated_bytes;
+    }
+
+private:
+    template <typename Function>
+    auto with_resource_context(Function&& function)
+            -> decltype(std::forward<Function>(function)()) {
+        // JNI normally re-enters on an attached async-writer thread.  Attach
+        // Java-created threads explicitly too, so every allocation/free is
+        // charged to the query rather than to an unrelated thread context.
+        if (!pthread_context_ptr_init && bthread_self() == 0) {
+            SCOPED_ATTACH_TASK(_resource_context);
+            return std::forward<Function>(function)();
+        }
+        if (thread_context()->is_attach_task()) {
+            SCOPED_SWITCH_RESOURCE_CONTEXT(_resource_context);
+            return std::forward<Function>(function)();
+        }
+        SCOPED_ATTACH_TASK(_resource_context);
+        return std::forward<Function>(function)();
+    }
+
+    void release_all_pages() {
+        // Detach ownership from the bookkeeping vector under the lock, then
+        // free outside the lock.  Allocator/free may invoke code that takes
+        // unrelated locks and must not block page accounting readers.
+        std::vector<std::pair<void*, size_t>> allocations;
+        {
+            std::lock_guard<std::mutex> lock(_mutex);
+            allocations.swap(_allocations);
+            _native_allocated_bytes = 0;
+        }
+        if (allocations.empty()) {
+            return;
+        }
+
+        with_resource_context([&]() {
+            for (const auto& [address, bytes] : allocations) {
+                _allocator.free(address, bytes);
+            }
+            std::vector<std::pair<void*, size_t>>().swap(allocations);
+        });
+    }
+
+    void remove_and_free_page(void* address, size_t bytes) {
+        // Roll back a page whose Java direct-buffer wrapper could not be
+        // created.  The address is removed under the same lock used by the
+        // normal accounting path, while the potentially expensive free is
+        // performed after releasing it.
+        {
+            std::lock_guard<std::mutex> lock(_mutex);
+            auto it = std::find_if(
+                    _allocations.begin(), _allocations.end(),
+                    [&](const auto& allocation) { return allocation.first == address; });
+            if (it != _allocations.end()) {
+                _allocations.erase(it);
+                _native_allocated_bytes -= bytes;
+            }
+        }
+        with_resource_context([&]() { _allocator.free(address, bytes); });
+    }
+
+    // Query resource context used for all native allocator operations.
+    std::shared_ptr<ResourceContext> _resource_context;
+    // Immutable per-writer cap, calculated by PaimonJniMemoryManager::create.
+    const int64_t _memory_limit;
+    // Doris allocator used instead of JVM/Arrow allocation so native pages are
+    // visible to Doris' memory accounting and allocator hooks.
+    Allocator<false> _allocator;
+    // Protects the allocation list and both usage counters.  JNI callbacks and
+    // Java close/finalizer paths may arrive concurrently.
+    mutable std::mutex _mutex;
+    // Every entry is (native address, size) and remains here until released.
+    std::vector<std::pair<void*, size_t>> _allocations;
+    // Bytes reserved by callbacks which have passed the local limit check but
+    // have not yet completed their allocator call.
+    int64_t _native_reserved_bytes = 0;
+    // Committed and high-water native page usage, respectively.
+    int64_t _native_allocated_bytes = 0;
+    int64_t _native_peak_allocated_bytes = 0;
+};
+
+namespace {
+
+jobject allocate_paimon_memory_page(JNIEnv* env, jclass, jlong manager_handle, jint bytes) {
+    // This is called from PaimonJniWriter's Java memory pool.  The handle is
+    // the native manager address passed when the writer is opened; ownership
+    // stays with the C++ writer/backend, so this callback must never delete it.
+    auto* manager = reinterpret_cast<PaimonJniMemoryManager*>(manager_handle);
+    if (manager == nullptr) {
+        jclass exception_class = env->FindClass("java/lang/IllegalStateException");
+        env->ThrowNew(exception_class, "Paimon JNI memory manager is null");
+        env->DeleteLocalRef(exception_class);
+        return nullptr;
+    }
+    try {
+        return manager->allocate_page(env, bytes);
+    } catch (const std::exception& e) {
+        jclass exception_class = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(exception_class, e.what());
+        env->DeleteLocalRef(exception_class);
+        return nullptr;
+    }
+}
+
+} // namespace
+
+PaimonJniMemoryManager::PaimonJniMemoryManager(std::unique_ptr<Impl> impl)
+        : _impl(std::move(impl)) {}
+
+PaimonJniMemoryManager::~PaimonJniMemoryManager() = default;
+
+Status PaimonJniMemoryManager::create(RuntimeState* state,
+                                      std::unique_ptr<PaimonJniMemoryManager>* manager) {
+    DORIS_CHECK(state != nullptr);
+    DORIS_CHECK(manager != nullptr);
+    if (state->query_mem_tracker() == nullptr) {
+        return Status::InternalError(
+                "Paimon JNI writer cannot size its write buffer without a query tracker");
+    }
+    if (state->get_query_ctx() == nullptr) {
+        return Status::InternalError(
+                "Paimon JNI writer cannot allocate native memory without QueryContext");
+    }
+
+    // A query can create multiple local sink instances.  Divide its budget
+    // before applying the configured cap so one writer cannot consume the
+    // entire query allowance.
+    const int64_t writer_count = std::max<int64_t>(1, state->num_local_sink());
+    const int64_t query_limit = state->query_mem_tracker()->limit();
+    const int64_t query_share = query_limit > 0 ? query_limit / writer_count : query_limit;
+    const int64_t configured_memory_limit = config::paimon_jni_writer_memory_pool_limit_bytes;
+    const int64_t memory_limit = query_share > 0 ? std::min(query_share, configured_memory_limit)
+                                                 : configured_memory_limit;
+    if (memory_limit <= 0) {
+        return Status::Error<ErrorCode::QUERY_MEMORY_EXCEEDED>(
+                "Paimon JNI writer has insufficient memory budget: query_limit={}, "
+                "local_sink_count={}, write_buffer_limit={}",
+                PrettyPrinter::print_bytes(query_limit), writer_count,
+                PrettyPrinter::print_bytes(memory_limit));
+    }
+
+    // ResourceContext is retained by Impl for the manager's whole lifetime;
+    // this is what keeps asynchronous JNI callbacks associated with the query.
+    auto impl = std::make_unique<Impl>(state->get_query_ctx()->resource_ctx(), memory_limit);
+    *manager = std::unique_ptr<PaimonJniMemoryManager>(new PaimonJniMemoryManager(std::move(impl)));
+    return Status::OK();
+}
+
+Status PaimonJniMemoryManager::register_natives(JNIEnv* env, jclass writer_class) {
+    // Keep the JNI surface minimal: Java asks native code only for a page;
+    // all ownership, limits, and cleanup stay in PaimonJniMemoryManager.
+    static char allocate_name[] = "allocatePaimonMemoryPage";
+    static char allocate_signature[] = "(JI)Ljava/nio/ByteBuffer;";
+    static ::JNINativeMethod methods[] = {
+            {allocate_name, allocate_signature,
+             reinterpret_cast<void*>(&allocate_paimon_memory_page)},
+    };
+    if (env->RegisterNatives(writer_class, methods,
+                             static_cast<jint>(sizeof(methods) / sizeof(methods[0]))) != JNI_OK) {
+        RETURN_IF_ERROR(Jni::Env::GetJniExceptionMsg(
+                env, true, "JNI exception registering Paimon memory native methods: "));
+        return Status::JniError("Failed to register Paimon memory native methods");
+    }
+    return Status::OK();
+}
+
+jobject PaimonJniMemoryManager::allocate_page(JNIEnv* env, jint bytes) {
+    return _impl->allocate_page(env, bytes);
+}
+
+int64_t PaimonJniMemoryManager::memory_limit() const {
+    return _impl->memory_limit();
+}
+
+int64_t PaimonJniMemoryManager::native_peak_allocated_bytes() const {
+    return _impl->native_peak_allocated_bytes();
+}
+
+} // namespace doris
diff --git a/be/src/exec/sink/writer/paimon/paimon_jni_memory_manager.h b/be/src/exec/sink/writer/paimon/paimon_jni_memory_manager.h
new file mode 100644
index 00000000000000..0d4818cd6dce42
--- /dev/null
+++ b/be/src/exec/sink/writer/paimon/paimon_jni_memory_manager.h
@@ -0,0 +1,81 @@
+// 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.
+
+#pragma once
+
+#include <jni.h>
+
+#include <cstdint>
+#include <memory>
+
+#include "common/status.h"
+
+namespace doris {
+
+class RuntimeState;
+
+/// Owns the Doris-side native memory used by one Java Paimon writer.
+///
+/// Paimon's sort/merge buffers are Java objects, but their page storage is
+/// requested through a JNI callback.  This manager is the bridge for that
+/// callback: it allocates each page with Doris' allocator, exposes the page as
+/// a direct ByteBuffer, tracks it until the writer is closed, and releases all
+/// pages in its destructor.  The native writer/backend therefore keeps this
+/// manager alive for at least as long as the Java writer can access its
+/// callback handle.
+///
+/// The limit is a per-writer budget.  It is derived from the query memory
+/// limit and the number of local sink instances, then capped by the global
+/// Paimon JNI configuration.  The manager accounts only for pages allocated
+/// by this callback; Java heap and other Paimon-managed memory remain under
+/// their respective runtimes.
+class PaimonJniMemoryManager {
+public:
+    ~PaimonJniMemoryManager();
+
+    /// Construct a manager whose budget is sized from the query context.
+    ///
+    /// The query must provide both a memory tracker and QueryContext.  The
+    /// latter supplies the ResourceContext used whenever allocation/freeing
+    /// crosses into a JNI-created or asynchronous thread.
+    static Status create(RuntimeState* state, std::unique_ptr<PaimonJniMemoryManager>* manager);
+    /// Register the static JNI callback used by PaimonJniWriter.
+    static Status register_natives(JNIEnv* env, jclass writer_class);
+
+    /// Allocate one native page and return it as a direct ByteBuffer.
+    ///
+    /// On failure this method leaves no accounting entry behind and reports
+    /// the error through the JNI environment.  The returned buffer remains
+    /// valid until the manager is destroyed (or allocation of that page is
+    /// rolled back because NewDirectByteBuffer failed).
+    jobject allocate_page(JNIEnv* env, jint bytes);
+
+    /// Return the immutable per-writer native page budget in bytes.
+    int64_t memory_limit() const;
+
+    /// Return the high-water mark of native pages allocated by this manager.
+    int64_t native_peak_allocated_bytes() const;
+
+private:
+    class Impl;
+
+    explicit PaimonJniMemoryManager(std::unique_ptr<Impl> impl);
+
+    std::unique_ptr<Impl> _impl;
+};
+
+} // namespace doris
diff --git a/be/src/exec/sink/writer/paimon/paimon_table_writer.cpp b/be/src/exec/sink/writer/paimon/paimon_table_writer.cpp
new file mode 100644
index 00000000000000..66238cc621760a
--- /dev/null
+++ b/be/src/exec/sink/writer/paimon/paimon_table_writer.cpp
@@ -0,0 +1,193 @@
+// 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.
+
+#include "exec/sink/writer/paimon/paimon_table_writer.h"
+
+#include "common/check.h"
+#include "common/logging.h"
+#include "core/block/block.h"
+#include "exec/sink/writer/paimon/jni_paimon_write_backend.h"
+#include "runtime/runtime_state.h"
+
+namespace doris {
+
+PaimonTableWriter::PaimonTableWriter(TDataSink t_sink, const VExprContextSPtrs& output_exprs,
+                                     std::shared_ptr<Dependency> dep,
+                                     std::shared_ptr<Dependency> fin_dep)
+        : AsyncResultWriter(output_exprs, std::move(dep), std::move(fin_dep)),
+          _t_sink(std::move(t_sink)) {
+    DCHECK(_t_sink.__isset.paimon_table_sink);
+}
+
+Status PaimonTableWriter::open(RuntimeState* state, RuntimeProfile* profile) {
+    _state = state;
+    _operator_profile = profile;
+
+    // Register profile counters
+    _written_rows_counter = ADD_COUNTER(_operator_profile, "WrittenRows", TUnit::UNIT);
+    _written_bytes_counter = ADD_COUNTER(_operator_profile, "WrittenBytes", TUnit::BYTES);
+    _send_data_timer = ADD_TIMER(_operator_profile, "SendDataTime");
+    _project_timer = ADD_CHILD_TIMER(_operator_profile, "ProjectTime", "SendDataTime");
+    _file_store_write_timer =
+            ADD_CHILD_TIMER(_operator_profile, "FileStoreWriteTime", "SendDataTime");
+    _open_timer = ADD_TIMER(_operator_profile, "OpenTime");
+    _close_timer = ADD_TIMER(_operator_profile, "CloseTime");
+    _prepare_commit_timer = ADD_TIMER(_operator_profile, "PrepareCommitTime");
+    _commit_payload_count = ADD_COUNTER(_operator_profile, "CommitPayloadCount", TUnit::UNIT);
+    _commit_payload_bytes_counter =
+            ADD_COUNTER(_operator_profile, "CommitPayloadBytes", TUnit::BYTES);
+
+    SCOPED_TIMER(_open_timer);
+
+    // Step 1: Create the JNI backend that owns the Java Paimon SDK writer.
+    _backend = std::make_unique<JniPaimonWriteBackend>();
+    // Step 2: Open the backend — for JNI this loads the Java class and calls PaimonJniWriter.open().
+    RETURN_IF_ERROR(_backend->open(_t_sink.paimon_table_sink, state, profile));
+    // Step 3: Create a lightweight writer adapter that delegates to the opened backend.
+    RETURN_IF_ERROR(_backend->create_writer(&_writer));
+    DCHECK(_writer);
+
+    LOG(INFO) << "PaimonTableWriter opened: backend=JNI, writer_scope=local_state";
+    return Status::OK();
+}
+
+Status PaimonTableWriter::write(RuntimeState* state, Block& block) {
+    if (block.rows() == 0) {
+        return Status::OK();
+    }
+
+    SCOPED_TIMER(_send_data_timer);
+
+    // Step 1: Apply output expressions to produce the columns selected by FE.
+    Block output_block;
+    {
+        SCOPED_TIMER(_project_timer);
+        RETURN_IF_ERROR(_projection_block(block, &output_block));
+    }
+
+    COUNTER_UPDATE(_written_rows_counter, block.rows());
+    COUNTER_UPDATE(_written_bytes_counter, block.bytes());
+    _state->update_num_rows_load_total(block.rows());
+    _state->update_num_bytes_load_total(block.bytes());
+
+    // Step 2: Convert Block → Arrow IPC → direct buffer → Java PaimonJniWriter.
+    DCHECK(_writer);
+    {
+        SCOPED_TIMER(_file_store_write_timer);
+        RETURN_IF_ERROR(_writer->write(_state, output_block));
+    }
+    _written_rows += block.rows();
+    return Status::OK();
+}
+
+Status PaimonTableWriter::close(Status status) {
+    SCOPED_TIMER(_close_timer);
+
+    // Prepare messages first, but do not publish them until the backend confirms
+    // that every SDK user has stopped and its native backing memory is safe to release.
+    std::vector<TPaimonCommitMessage> messages;
+    if (status.ok()) {
+        DCHECK(_writer);
+        {
+            SCOPED_TIMER(_prepare_commit_timer);
+            Status prep_st = _writer->prepare_commit(messages);
+            if (!prep_st.ok()) {
+                status = prep_st;
+            }
+        }
+    }
+
+    // If prepare_commit failed or the incoming status was already an error,
+    // abort the writer to clean up uncommitted data files.
+    if (!status.ok()) {
+        LOG(WARNING) << "Paimon writer closing with error: " << status.to_string();
+        if (_writer) {
+            Status abort_st = _writer->abort();
+            if (!abort_st.ok()) {
+                LOG(WARNING) << "Paimon writer abort failed: " << abort_st.to_string();
+            }
+        }
+    }
+
+    // Record message metrics before backend shutdown, but retain local ownership until
+    // every Java SDK user has stopped successfully.
+    if (status.ok() && !messages.empty()) {
+        messages.front().__set_row_count(_written_rows);
+        COUNTER_UPDATE(_commit_payload_count, static_cast<int64_t>(messages.size()));
+        for (const auto& msg : messages) {
+            DORIS_CHECK(msg.__isset.payload);
+            COUNTER_UPDATE(_commit_payload_bytes_counter, static_cast<int64_t>(msg.payload.size()));
+        }
+    }
+
+    // The adapter only owns Arrow conversion resources. Release it before closing
+    // the backend, whose Java close is the authoritative SDK shutdown boundary.
+    _writer.reset();
+
+    if (_backend) {
+        Status close_st = _backend->close();
+        if (!close_st.ok()) {
+            if (status.ok()) {
+                status = close_st;
+            } else {
+                LOG(WARNING) << "Paimon backend close also failed: " << close_st.to_string();
+            }
+        }
+    }
+
+    // A clean backend close is the ownership boundary. On any failure, the FE must never
+    // observe these messages; use an independent committer to clean prepared files because
+    // the original Java writer is already closed (or its close outcome is unsafe).
+    if (!status.ok() && !messages.empty()) {
+        WARN_IF_ERROR(
+                JniPaimonWriteBackend::abort_prepared_commit(_t_sink.paimon_table_sink, messages),
+                "failed to abort Paimon files after backend close failure");
+    }
+
+    _backend.reset();
+
+    if (!status.ok() || messages.empty()) {
+        return status;
+    }
+
+    // Transfer payload ownership only after backend shutdown. If the report budget rejects
+    // the transfer, abort immediately. If FE later explicitly rejects the final report, the
+    // callback reads the same RuntimeState payloads and aborts them without retaining a second copy.
+    Status publish_status = _state->add_paimon_commit_messages(messages);
+    if (!publish_status.ok()) {
+        WARN_IF_ERROR(
+                JniPaimonWriteBackend::abort_prepared_commit(_t_sink.paimon_table_sink, messages),
+                "failed to abort Paimon files after report-budget rejection");
+        return publish_status;
+    }
+
+    RuntimeState* cleanup_state = _state;
+    TPaimonTableSink cleanup_sink = _t_sink.paimon_table_sink;
+    _state->add_rejected_external_file_report_cleanup([cleanup_state,
+                                                       cleanup_sink = std::move(cleanup_sink)] {
+        std::vector<TPaimonCommitMessage> rejected_messages;
+        cleanup_state->append_paimon_commit_messages(&rejected_messages);
+        WARN_IF_ERROR(JniPaimonWriteBackend::abort_prepared_commit(cleanup_sink, rejected_messages),
+                      "failed to abort Paimon files after final report rejection");
+    });
+
+    LOG(INFO) << "Paimon writer closed: " << messages.size()
+              << " commit messages, total rows=" << _written_rows;
+    return status;
+}
+
+} // namespace doris
diff --git a/be/src/exec/sink/writer/paimon/paimon_table_writer.h b/be/src/exec/sink/writer/paimon/paimon_table_writer.h
new file mode 100644
index 00000000000000..850d5dea4b001f
--- /dev/null
+++ b/be/src/exec/sink/writer/paimon/paimon_table_writer.h
@@ -0,0 +1,102 @@
+// 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.
+
+#pragma once
+
+#include <gen_cpp/DataSinks_types.h>
+
+#include <memory>
+#include <string>
+
+#include "common/status.h"
+#include "core/block/block.h"
+#include "exec/sink/writer/async_result_writer.h"
+#include "exec/sink/writer/paimon/paimon_write_backend.h"
+#include "exprs/vexpr_fwd.h"
+#include "runtime/runtime_profile.h"
+
+namespace doris {
+
+class RuntimeState;
+
+/// Each PaimonTableSinkLocalState owns one PaimonTableWriter, which in turn
+/// owns one IPaimonWriteBackend and one IPaimonWriter. Pipeline parallelism
+/// therefore determines the number of independent Paimon writer sessions;
+/// each writer session delegates partition and bucket routing to the Paimon
+/// Java SDK through JNI. FE currently places Paimon writes on GATHER to keep
+/// dynamic-bucket assignment single-writer correct.
+///
+/// Doris does NOT compute partition values or bucket ids — it passes complete
+/// Blocks through the JNI backend to the Paimon SDK, which
+/// internally computes partition values, bucket ids, and routes rows to the
+/// correct file writers.
+///
+/// Architecture:
+///   PaimonTableSinkOperatorX
+///     │  sink_impl() → AsyncWriterSink::sink()  (no routing)
+///     ▼
+///   PaimonTableWriter (one per LocalState / pipeline instance)
+///     │  owns IPaimonWriteBackend (JNI)
+///     │    └─ create_writer() → IPaimonWriter
+///     │  write()
+///     │    → JNI backend: Block → Arrow IPC → Java Paimon SDK
+///     │    → Paimon SDK owns row normalization, routing, buffering,
+///     │      file writing, and compaction
+///     ▼
+///   close() → prepareCommit() → CommitMessage[]
+///
+/// Commit flow (BE only prepares messages; FE is the commit coordinator):
+///   close() → writer->prepare_commit()
+///          → collect TPaimonCommitMessage[] (DPCM-framed serialized messages)
+///          → RuntimeState::add_paimon_commit_messages()
+///          → RPC to FE Coordinator → PaimonTransaction
+class PaimonTableWriter final : public AsyncResultWriter {
+public:
+    PaimonTableWriter(TDataSink t_sink, const VExprContextSPtrs& output_exprs,
+                      std::shared_ptr<Dependency> dep, std::shared_ptr<Dependency> fin_dep);
+
+    ~PaimonTableWriter() override = default;
+
+    Status open(RuntimeState* state, RuntimeProfile* profile) override;
+
+    Status write(RuntimeState* state, Block& block) override;
+
+    Status close(Status status) override;
+
+private:
+    TDataSink _t_sink;
+    RuntimeState* _state = nullptr;
+
+    // Backend owns the JNI connection and creates the writer adapter.
+    // Both are scoped to this PaimonTableWriter (one per LocalState).
+    std::unique_ptr<IPaimonWriteBackend> _backend;
+    std::unique_ptr<IPaimonWriter> _writer;
+
+    // Profile counters
+    RuntimeProfile::Counter* _written_rows_counter = nullptr;
+    RuntimeProfile::Counter* _written_bytes_counter = nullptr;
+    RuntimeProfile::Counter* _send_data_timer = nullptr;
+    RuntimeProfile::Counter* _project_timer = nullptr;
+    RuntimeProfile::Counter* _file_store_write_timer = nullptr;
+    RuntimeProfile::Counter* _open_timer = nullptr;
+    RuntimeProfile::Counter* _close_timer = nullptr;
+    RuntimeProfile::Counter* _prepare_commit_timer = nullptr;
+    RuntimeProfile::Counter* _commit_payload_count = nullptr;
+    RuntimeProfile::Counter* _commit_payload_bytes_counter = nullptr;
+};
+
+} // namespace doris
diff --git a/be/src/exec/sink/writer/paimon/paimon_write_backend.h b/be/src/exec/sink/writer/paimon/paimon_write_backend.h
new file mode 100644
index 00000000000000..ade863aec8cde1
--- /dev/null
+++ b/be/src/exec/sink/writer/paimon/paimon_write_backend.h
@@ -0,0 +1,84 @@
+// 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.
+
+#pragma once
+
+#include <gen_cpp/DataSinks_types.h>
+
+#include <memory>
+#include <vector>
+
+#include "common/status.h"
+#include "core/block/block.h"
+
+namespace doris {
+
+class RuntimeState;
+class RuntimeProfile;
+
+/// Writer contract implemented by one SDK writer adapter. Each
+/// PaimonTableWriter owns one IPaimonWriter, which delegates to the
+/// Paimon Java SDK through JNI. Partition and bucket routing happens
+/// inside the SDK.
+///
+/// Lifecycle: created by IPaimonWriteBackend::create_writer() after the
+/// backend is opened; used for the duration of one pipeline instance.
+class IPaimonWriter {
+public:
+    virtual ~IPaimonWriter() = default;
+
+    /// Write a projected Block to the Paimon SDK.
+    /// For the JNI path: Block → Arrow IPC → direct buffer → Java.
+    virtual Status write(RuntimeState* state, Block& block) = 0;
+
+    /// Flush all buffered data, close files, and collect serialized commit
+    /// messages (DPCM-framed). Called once at EOS.
+    virtual Status prepare_commit(std::vector<TPaimonCommitMessage>& messages) = 0;
+
+    /// Discard written data files on error. Called when write or prepare_commit fails.
+    virtual Status abort() = 0;
+};
+
+/// Backend boundary for creating writers through the Paimon Java SDK.
+///
+/// The backend owns the JVM class reference, method IDs, and Java writer object.
+///
+/// Each backend creates one or more IPaimonWriter adapters that share the
+/// same underlying connection. Snapshot commit is deliberately excluded from
+/// this boundary: BE only prepares commit messages (byte payloads), while FE
+/// PaimonTransaction is the single commit coordinator.
+class IPaimonWriteBackend {
+public:
+    virtual ~IPaimonWriteBackend() = default;
+
+    /// Initialize the backend connection. For JNI this loads the writer class,
+    /// creates the Java object, and calls PaimonJniWriter.open().
+    virtual Status open(const TPaimonTableSink& sink, RuntimeState* state,
+                        RuntimeProfile* profile) = 0;
+
+    /// Create a lightweight writer adapter that delegates to this backend.
+    virtual Status create_writer(std::unique_ptr<IPaimonWriter>* writer) = 0;
+
+    /// Stop all SDK users and release backend resources.
+    ///
+    /// A successful return is the ownership boundary after which native memory
+    /// backing SDK buffers can be reclaimed safely. Callers must not publish
+    /// prepared commit messages until this succeeds.
+    virtual Status close() = 0;
+};
+
+} // namespace doris
diff --git a/be/src/format/jni/jni_data_bridge.cpp b/be/src/format/jni/jni_data_bridge.cpp
index 9dc935e0b62da5..51b4d0e7089c01 100644
--- a/be/src/format/jni/jni_data_bridge.cpp
+++ b/be/src/format/jni/jni_data_bridge.cpp
@@ -29,6 +29,7 @@
 #include "core/column/column_string.h"
 #include "core/column/column_struct.h"
 #include "core/column/column_varbinary.h"
+#include "core/column/variant_v2/column_variant_v2.h"
 #include "core/data_type/data_type_array.h"
 #include "core/data_type/data_type_map.h"
 #include "core/data_type/data_type_nullable.h"
@@ -38,6 +39,7 @@
 #include "core/data_type/primitive_type.h"
 #include "core/types.h"
 #include "core/value/decimalv2_value.h"
+#include "core/value/variant/variant_batch_builder.h"
 #include "util/string_util.h"
 #include "util/url_coding.h"
 
@@ -148,6 +150,10 @@ Status JniDataBridge::fill_column(TableMetaAddress& address, ColumnPtr& doris_co
     case PrimitiveType::TYPE_VARBINARY:
         status = _fill_varbinary_column(address, data_column, num_rows);
         break;
+    case PrimitiveType::TYPE_VARIANT:
+        status = _fill_variant_column(address, data_column, static_cast<const bool*>(null_map_ptr),
+                                      num_rows);
+        break;
     default:
         status = Status::InvalidArgument("Unsupported type {} in jni scanner",
                                          data_type->get_name());
@@ -179,6 +185,37 @@ Status JniDataBridge::_fill_varbinary_column(TableMetaAddress& address,
     return Status::OK();
 }
 
+Status JniDataBridge::_fill_variant_column(TableMetaAddress& address,
+                                           MutableColumnPtr& doris_column, const bool* null_map,
+                                           size_t num_rows) {
+    ColumnPtr values = ColumnVarbinary::create();
+    ColumnPtr metadatas = ColumnVarbinary::create();
+    const DataTypePtr binary_type = std::make_shared<DataTypeVarbinary>();
+    RETURN_IF_ERROR(fill_column(address, values, binary_type, num_rows));
+    RETURN_IF_ERROR(fill_column(address, metadatas, binary_type, num_rows));
+
+    RETURN_IF_CATCH_EXCEPTION({
+        const auto& value_column = assert_cast<const ColumnVarbinary&>(*values);
+        const auto& metadata_column = assert_cast<const ColumnVarbinary&>(*metadatas);
+        VariantBatchBuilder builder;
+        for (size_t row_index = 0; row_index < num_rows; ++row_index) {
+            auto row = builder.begin_row();
+            if (null_map[row_index]) {
+                row.add_null();
+            } else {
+                const StringRef value = value_column.get_data_at(row_index);
+                const StringRef metadata = metadata_column.get_data_at(row_index);
+                row.add_value({.metadata = {.data = metadata.data, .size = metadata.size},
+                               .value = value});
+            }
+            row.finish();
+        }
+        VariantBatchBuilder batch = builder.finish_batch();
+        assert_cast<ColumnVariantV2&>(*doris_column).insert_encoded_batch(batch);
+    });
+    return Status::OK();
+}
+
 Status JniDataBridge::_fill_string_column(TableMetaAddress& address, MutableColumnPtr& doris_column,
                                           size_t num_rows) {
     auto& string_col = static_cast<ColumnString&>(*doris_column);
@@ -358,6 +395,8 @@ std::string JniDataBridge::get_jni_type(const DataTypePtr& data_type) {
     }
     case TYPE_VARBINARY:
         return "varbinary";
+    case TYPE_VARIANT:
+        return "struct<value:varbinary,metadata:varbinary>";
     // bitmap, hll, quantile_state, jsonb are transferred as strings via JNI
     case TYPE_BITMAP:
         [[fallthrough]];
@@ -433,6 +472,8 @@ std::string JniDataBridge::get_jni_type_with_different_string(const DataTypePtr&
                << assert_cast<const DataTypeVarbinary*>(remove_nullable(data_type).get())->len()
                << ")";
         return buffer.str();
+    case TYPE_VARIANT:
+        return "struct<value:varbinary,metadata:varbinary>";
     case TYPE_DECIMALV2: {
         buffer << "decimalv2(" << DecimalV2Value::PRECISION << "," << DecimalV2Value::SCALE << ")";
         return buffer.str();
@@ -506,6 +547,8 @@ std::string JniDataBridge::encode_schema_values(const std::vector<std::string>&
 
 std::string JniDataBridge::get_jni_type_with_encoded_struct_fields(const DataTypePtr& data_type) {
     switch (data_type->get_primitive_type()) {
+    case TYPE_VARIANT:
+        return "struct<$dmFsdWU=:varbinary,$bWV0YWRhdGE=:varbinary>";
     case TYPE_STRUCT: {
         const auto* type_struct =
                 assert_cast<const DataTypeStruct*>(remove_nullable(data_type).get());
diff --git a/be/src/format/jni/jni_data_bridge.h b/be/src/format/jni/jni_data_bridge.h
index e037ffec3d4d5a..5a0eea8aa55b26 100644
--- a/be/src/format/jni/jni_data_bridge.h
+++ b/be/src/format/jni/jni_data_bridge.h
@@ -154,6 +154,9 @@ class JniDataBridge {
     static Status _fill_varbinary_column(TableMetaAddress& address, MutableColumnPtr& doris_column,
                                          size_t num_rows);
 
+    static Status _fill_variant_column(TableMetaAddress& address, MutableColumnPtr& doris_column,
+                                       const bool* null_map, size_t num_rows);
+
     static Status _fill_array_column(TableMetaAddress& address, MutableColumnPtr& doris_column,
                                      const DataTypePtr& data_type, size_t num_rows);
 
diff --git a/be/src/runtime/runtime_state.cpp b/be/src/runtime/runtime_state.cpp
index 380bc8f8f72081..c02c7478a5a471 100644
--- a/be/src/runtime/runtime_state.cpp
+++ b/be/src/runtime/runtime_state.cpp
@@ -72,18 +72,52 @@ Status RuntimeState::add_iceberg_commit_datas(TIcebergCommitData iceberg_commit_
             thrift_limit > report_envelope_headroom ? thrift_limit - report_envelope_headroom : 0;
     std::lock_guard<std::mutex> budget_lock(_external_file_report_state->mutex);
     // Parallel task states share this budget because FE receives their vectors in one fragment report.
-    if (_external_file_report_state->iceberg_serialized_bytes + serialized_size + sizeof(uint32_t) >
+    if (_external_file_report_state->serialized_commit_bytes + serialized_size + sizeof(uint32_t) >
         commit_data_limit) {
         return Status::InternalError(
                 "Iceberg commit metadata exceeds the Thrift report limit; reduce output file "
                 "count");
     }
     std::lock_guard<std::mutex> data_lock(_iceberg_commit_datas_mutex);
-    _external_file_report_state->iceberg_serialized_bytes += serialized_size + sizeof(uint32_t);
+    _external_file_report_state->serialized_commit_bytes += serialized_size + sizeof(uint32_t);
     _iceberg_commit_datas.emplace_back(std::move(iceberg_commit_data));
     return Status::OK();
 }
 
+Status RuntimeState::add_paimon_commit_messages(std::vector<TPaimonCommitMessage> commit_messages) {
+    if (commit_messages.empty()) {
+        return Status::OK();
+    }
+
+    ThriftSerializer serializer(false, 256);
+    size_t messages_size = 0;
+    for (auto& message : commit_messages) {
+        uint32_t serialized_size = 0;
+        uint8_t* buffer = nullptr;
+        RETURN_IF_ERROR(serializer.serialize(&message, &serialized_size, &buffer));
+        messages_size += serialized_size + sizeof(uint32_t);
+    }
+
+    constexpr size_t report_envelope_headroom = 1024 * 1024;
+    const size_t thrift_limit = coordinator_thrift_message_limit();
+    const size_t commit_data_limit =
+            thrift_limit > report_envelope_headroom ? thrift_limit - report_envelope_headroom : 0;
+    std::lock_guard<std::mutex> budget_lock(_external_file_report_state->mutex);
+    if (messages_size >
+        commit_data_limit -
+                std::min(commit_data_limit, _external_file_report_state->serialized_commit_bytes)) {
+        return Status::InternalError(
+                "Paimon commit metadata exceeds the Thrift report limit; reduce output file "
+                "count");
+    }
+    std::lock_guard<std::mutex> data_lock(_paimon_commit_messages_mutex);
+    _external_file_report_state->serialized_commit_bytes += messages_size;
+    _paimon_commit_messages.insert(_paimon_commit_messages.end(),
+                                   std::make_move_iterator(commit_messages.begin()),
+                                   std::make_move_iterator(commit_messages.end()));
+    return Status::OK();
+}
+
 size_t RuntimeState::coordinator_thrift_message_limit() const {
     int32_t effective_thrift_limit = std::max(config::thrift_max_message_size, 0);
     if (_query_options.__isset.coordinator_thrift_max_message_size &&
@@ -115,6 +149,10 @@ void RuntimeState::append_external_file_commit_data(TReportExecStatusParams* par
         params->mc_commit_datas.insert(params->mc_commit_datas.end(), commit_datas.begin(),
                                        commit_datas.end());
     }
+    append_paimon_commit_messages(&params->paimon_commit_messages);
+    if (!params->paimon_commit_messages.empty()) {
+        params->__isset.paimon_commit_messages = true;
+    }
 }
 
 void RuntimeState::add_rejected_external_file_report_cleanup(std::function<void()> cleanup) {
diff --git a/be/src/runtime/runtime_state.h b/be/src/runtime/runtime_state.h
index a3cfc5e4cad782..44e054a593070f 100644
--- a/be/src/runtime/runtime_state.h
+++ b/be/src/runtime/runtime_state.h
@@ -84,7 +84,7 @@ class ExternalFileReportState {
 
 private:
     std::mutex mutex;
-    size_t iceberg_serialized_bytes = 0;
+    size_t serialized_commit_bytes = 0;
     bool ownership_may_have_transferred = false;
     std::vector<std::function<void()>> rejected_report_cleanups;
 };
@@ -547,6 +547,14 @@ class RuntimeState {
 
     Status add_iceberg_commit_datas(TIcebergCommitData iceberg_commit_data);
 
+    void append_paimon_commit_messages(std::vector<TPaimonCommitMessage>* output) const {
+        std::lock_guard<std::mutex> lock(_paimon_commit_messages_mutex);
+        output->insert(output->end(), _paimon_commit_messages.begin(),
+                       _paimon_commit_messages.end());
+    }
+
+    Status add_paimon_commit_messages(std::vector<TPaimonCommitMessage> commit_messages);
+
     size_t coordinator_thrift_message_limit() const;
 
     void append_external_file_commit_data(TReportExecStatusParams* params, bool final_report) const;
@@ -1012,6 +1020,9 @@ class RuntimeState {
     mutable std::mutex _mc_commit_datas_mutex;
     std::vector<TMCCommitData> _mc_commit_datas;
 
+    mutable std::mutex _paimon_commit_messages_mutex;
+    std::vector<TPaimonCommitMessage> _paimon_commit_messages;
+
     std::vector<std::unique_ptr<doris::PipelineXLocalStateBase>> _op_id_to_local_state;
 
     std::unique_ptr<doris::PipelineXSinkLocalStateBase> _sink_local_state;
diff --git a/be/test/core/data_type_serde/data_type_variant_v2_serde_output_test.cpp b/be/test/core/data_type_serde/data_type_variant_v2_serde_output_test.cpp
index 9f5e6054a1fba7..da30c0a040c1fc 100644
--- a/be/test/core/data_type_serde/data_type_variant_v2_serde_output_test.cpp
+++ b/be/test/core/data_type_serde/data_type_variant_v2_serde_output_test.cpp
@@ -15,7 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <arrow/array/array_nested.h>
 #include <arrow/array/builder_binary.h>
+#include <arrow/array/builder_nested.h>
 #include <gtest/gtest.h>
 
 #include <array>
@@ -251,6 +253,34 @@ TEST(DataTypeVariantV2SerdeOutputTest, DormantDirectClassExists) {
     EXPECT_EQ(serde.get_name(), "Variant");
 }
 
+TEST(DataTypeVariantV2SerdeOutputTest, VariantStructArrowPreservesBinaryEncoding) {
+    DataTypeVariantV2SerDe serde;
+    auto documents = encoded_json({R"({"id":7,"tags":["doris"]})", R"([1,true,null])"});
+    auto value_builder = std::make_shared<arrow::BinaryBuilder>();
+    auto metadata_builder = std::make_shared<arrow::BinaryBuilder>();
+    auto arrow_type = arrow::struct_({arrow::field("value", arrow::binary(), false),
+                                      arrow::field("metadata", arrow::binary(), false)});
+    arrow::StructBuilder builder(arrow_type, arrow::default_memory_pool(),
+                                 {value_builder, metadata_builder});
+    NullMap forced_nulls {0, 1};
+
+    ASSERT_TRUE(serde.write_column_to_arrow(*documents, &forced_nulls, &builder, 0,
+                                            documents->size(), cctz::utc_time_zone())
+                        .ok());
+    std::shared_ptr<arrow::StructArray> output;
+    ASSERT_TRUE(builder.Finish(&output).ok());
+    ASSERT_EQ(output->length(), 2);
+    EXPECT_FALSE(output->IsNull(0));
+    EXPECT_TRUE(output->IsNull(1));
+
+    const auto& values = assert_cast<const arrow::BinaryArray&>(*output->field(0));
+    const auto& metadatas = assert_cast<const arrow::BinaryArray&>(*output->field(1));
+    const VariantRef expected = documents->get_value_ref(0);
+    EXPECT_EQ(values.GetView(0), std::string_view(expected.value.data, expected.value.size));
+    EXPECT_EQ(metadatas.GetView(0),
+              std::string_view(expected.metadata.data, expected.metadata.size));
+}
+
 TEST(DataTypeVariantV2SerdeOutputTest, SqlScalarsFollowLegacyOutputAndDataFormatsUseJson) {
     DataTypeVariantV2SerDe serde;
     auto strings = typed_strings({std::string_view("a\"\n"), std::string_view(""), std::nullopt,
diff --git a/be/test/format/table/paimon_jni_reader_test.cpp b/be/test/format/table/paimon_jni_reader_test.cpp
index 969713429c29d6..c2e5eb4224145a 100644
--- a/be/test/format/table/paimon_jni_reader_test.cpp
+++ b/be/test/format/table/paimon_jni_reader_test.cpp
@@ -19,10 +19,21 @@
 
 #include <gtest/gtest.h>
 
+#include <array>
+#include <cstdint>
 #include <string>
+#include <string_view>
 #include <utility>
 #include <vector>
 
+#include "core/assert_cast.h"
+#include "core/column/column_nullable.h"
+#include "core/column/variant_v2/column_variant_v2.h"
+#include "core/data_type/data_type_nullable.h"
+#include "core/data_type/data_type_variant_v2.h"
+#include "core/value/variant/variant_batch_builder.h"
+#include "exprs/function/parse/variant_string_parse.h"
+#include "format/jni/jni_data_bridge.h"
 #include "gen_cpp/PlanNodes_types.h"
 #include "runtime/runtime_state.h"
 
@@ -40,6 +51,13 @@ TFileRangeDesc make_legacy_paimon_jni_range() {
     return range;
 }
 
+struct JavaVarbinaryEntry {
+    int64_t length;
+    uint64_t address;
+};
+
+static_assert(sizeof(JavaVarbinaryEntry) == 16);
+
 TEST(LegacyPaimonJniReaderTest, GeneratesMissingOrEmptySerializedTableCacheKey) {
     const auto range = make_legacy_paimon_jni_range();
     TFileScanRangeParams scan_params;
@@ -61,5 +79,52 @@ TEST(LegacyPaimonJniReaderTest, GeneratesMissingOrEmptySerializedTableCacheKey)
     EXPECT_NE(missing_key, empty_key);
 }
 
+TEST(LegacyPaimonJniReaderTest, PublishesVariantV2BinaryStructSchema) {
+    const DataTypePtr type = std::make_shared<DataTypeVariantV2>();
+    EXPECT_EQ(JniDataBridge::get_jni_type_with_different_string(type),
+              "struct<value:varbinary,metadata:varbinary>");
+    EXPECT_EQ(JniDataBridge::get_jni_type_with_encoded_struct_fields(type),
+              "struct<$dmFsdWU=:varbinary,$bWV0YWRhdGE=:varbinary>");
+}
+
+TEST(LegacyPaimonJniReaderTest, DecodesVariantV2BinaryStructFromJavaMetadata) {
+    const std::string json = R"({"id":7,"tags":["doris"]})";
+    JsonStringToVariantEncoder encoder;
+    encoder.add_json({json.data(), json.size()});
+    VariantBatchBuilder source = encoder.finish_batch();
+    const VariantRef expected = source.value_at(0);
+
+    std::array<uint8_t, 2> outer_nulls {0, 1};
+    std::array<uint8_t, 2> child_nulls {0, 1};
+    std::array<JavaVarbinaryEntry, 2> value_entries {
+            JavaVarbinaryEntry {static_cast<int64_t>(expected.value.size),
+                                reinterpret_cast<uint64_t>(expected.value.data)},
+            JavaVarbinaryEntry {0, 0}};
+    std::array<JavaVarbinaryEntry, 2> metadata_entries {
+            JavaVarbinaryEntry {static_cast<int64_t>(expected.metadata.size),
+                                reinterpret_cast<uint64_t>(expected.metadata.data)},
+            JavaVarbinaryEntry {0, 0}};
+    std::array<long, 5> metadata {reinterpret_cast<long>(outer_nulls.data()),
+                                  reinterpret_cast<long>(child_nulls.data()),
+                                  reinterpret_cast<long>(value_entries.data()),
+                                  reinterpret_cast<long>(child_nulls.data()),
+                                  reinterpret_cast<long>(metadata_entries.data())};
+
+    const DataTypePtr type = make_nullable(std::make_shared<DataTypeVariantV2>());
+    ColumnPtr result = type->create_column();
+    JniDataBridge::TableMetaAddress address(reinterpret_cast<long>(metadata.data()));
+    ASSERT_TRUE(JniDataBridge::fill_column(address, result, type, 2).ok());
+
+    const auto& nullable = assert_cast<const ColumnNullable&>(*result);
+    EXPECT_EQ(nullable.get_null_map_data(), (NullMap {0, 1}));
+    const auto& variants = assert_cast<const ColumnVariantV2&>(nullable.get_nested_column());
+    ASSERT_EQ(variants.size(), 2);
+    const VariantRef actual = variants.get_value_ref(0);
+    EXPECT_EQ(actual.value, expected.value);
+    EXPECT_EQ(std::string_view(actual.metadata.data, actual.metadata.size),
+              std::string_view(expected.metadata.data, expected.metadata.size));
+    EXPECT_TRUE(variants.get_value_ref(1).is_null());
+}
+
 } // namespace
 } // namespace doris
diff --git a/be/test/runtime/runtime_state_block_budget_test.cpp b/be/test/runtime/runtime_state_block_budget_test.cpp
index 5a384378ec382b..cb55639b6cd120 100644
--- a/be/test/runtime/runtime_state_block_budget_test.cpp
+++ b/be/test/runtime/runtime_state_block_budget_test.cpp
@@ -60,6 +60,27 @@ TEST(RuntimeStateIcebergCommitDataTest, SharesTheReportBudgetAcrossParallelTasks
     EXPECT_FALSE(second_status.ok());
 }
 
+TEST(RuntimeStateIcebergCommitDataTest, SharesTheReportBudgetWithPaimon) {
+    RuntimeState iceberg_state;
+    RuntimeState paimon_state;
+    auto budget = std::make_shared<ExternalFileReportState>();
+    iceberg_state.set_external_file_report_state(budget);
+    paimon_state.set_external_file_report_state(budget);
+    const int32_t saved_limit = config::thrift_max_message_size;
+    config::thrift_max_message_size = 1024 * 1024 + 512;
+    TIcebergCommitData iceberg_data;
+    iceberg_data.__set_file_path(std::string(300, 'x'));
+    TPaimonCommitMessage paimon_data;
+    paimon_data.__set_payload(std::string(300, 'x'));
+
+    Status iceberg_status = iceberg_state.add_iceberg_commit_datas(iceberg_data);
+    Status paimon_status = paimon_state.add_paimon_commit_messages({std::move(paimon_data)});
+
+    config::thrift_max_message_size = saved_limit;
+    EXPECT_TRUE(iceberg_status.ok()) << iceberg_status;
+    EXPECT_FALSE(paimon_status.ok());
+}
+
 TEST(RuntimeStateIcebergCommitDataTest, UsesTheSmallerCoordinatorThriftLimit) {
     RuntimeState state;
     const int32_t saved_limit = config::thrift_max_message_size;
@@ -91,6 +112,9 @@ TEST(RuntimeStateIcebergCommitDataTest, PeriodicReportOmitsExternalCommitData) {
     ASSERT_TRUE(state.add_iceberg_commit_datas(iceberg_data).ok());
     TMCCommitData mc_data;
     state.add_mc_commit_datas(mc_data);
+    TPaimonCommitMessage paimon_data;
+    paimon_data.__set_payload("paimon-commit");
+    ASSERT_TRUE(state.add_paimon_commit_messages({std::move(paimon_data)}).ok());
     TReportExecStatusParams periodic_params;
 
     state.append_external_file_commit_data(&periodic_params, false);
@@ -98,12 +122,14 @@ TEST(RuntimeStateIcebergCommitDataTest, PeriodicReportOmitsExternalCommitData) {
     EXPECT_FALSE(periodic_params.__isset.hive_partition_updates);
     EXPECT_FALSE(periodic_params.__isset.iceberg_commit_datas);
     EXPECT_FALSE(periodic_params.__isset.mc_commit_datas);
+    EXPECT_FALSE(periodic_params.__isset.paimon_commit_messages);
 
     TReportExecStatusParams final_params;
     state.append_external_file_commit_data(&final_params, true);
     EXPECT_TRUE(final_params.__isset.hive_partition_updates);
     EXPECT_TRUE(final_params.__isset.iceberg_commit_datas);
     EXPECT_TRUE(final_params.__isset.mc_commit_datas);
+    EXPECT_TRUE(final_params.__isset.paimon_commit_messages);
 }
 
 TEST(RuntimeStateIcebergCommitDataTest, RetainsFileCleanupUntilReportAcknowledgement) {
diff --git a/fe/be-java-extensions/paimon-scanner/pom.xml b/fe/be-java-extensions/paimon-scanner/pom.xml
index fa7c27e4e98319..7f415dae329855 100644
--- a/fe/be-java-extensions/paimon-scanner/pom.xml
+++ b/fe/be-java-extensions/paimon-scanner/pom.xml
@@ -61,6 +61,11 @@ under the License.
             <artifactId>paimon-format</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>org.apache.arrow</groupId>
+            <artifactId>arrow-vector</artifactId>
+        </dependency>
+
         <!--
           Paimon OSS/S3 FileIO plugins. These register org.apache.paimon.fs.FileIOLoader
           service providers (paimon-s3 -> S3Loader, paimon-jindo -> JindoLoader) used to read
diff --git a/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/DorisMemorySegmentPool.java b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/DorisMemorySegmentPool.java
new file mode 100644
index 00000000000000..e917eaaf2b393c
--- /dev/null
+++ b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/DorisMemorySegmentPool.java
@@ -0,0 +1,57 @@
+// 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.doris.paimon;
+
+import org.apache.paimon.memory.AbstractMemorySegmentPool;
+import org.apache.paimon.memory.MemorySegment;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Paimon write-buffer pool backed by memory allocated and tracked by Doris BE.
+ *
+ * <p>This class only adapts the Paimon page interface to the BE allocator. The native memory
+ * manager owns every returned page and releases them after the Java writer has closed.
+ */
+final class DorisMemorySegmentPool extends AbstractMemorySegmentPool {
+    private final long nativeMemoryManager;
+
+    DorisMemorySegmentPool(long maxMemory, int pageSize, long nativeMemoryManager) {
+        super(maxMemory, pageSize);
+        if (nativeMemoryManager == 0) {
+            throw new IllegalArgumentException("Doris native memory manager must not be null");
+        }
+        if (maxMemory < pageSize) {
+            throw new IllegalArgumentException(
+                    "Doris-managed Paimon memory pool must contain at least one page: maxMemory="
+                            + maxMemory + ", pageSize=" + pageSize);
+        }
+        this.nativeMemoryManager = nativeMemoryManager;
+    }
+
+    @Override
+    protected MemorySegment allocateMemory() {
+        ByteBuffer buffer =
+                PaimonJniWriter.allocatePaimonMemoryPage(nativeMemoryManager, pageSize);
+        if (buffer == null) {
+            throw new OutOfMemoryError(
+                    "Doris failed to allocate a native Paimon memory page of " + pageSize + " bytes");
+        }
+        return MemorySegment.wrapOffHeapMemory(buffer);
+    }
+}
diff --git a/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonArrowConverter.java b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonArrowConverter.java
new file mode 100644
index 00000000000000..18b267f060abf3
--- /dev/null
+++ b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonArrowConverter.java
@@ -0,0 +1,479 @@
+// 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.doris.paimon;
+
+import org.apache.arrow.vector.BigIntVector;
+import org.apache.arrow.vector.BitVector;
+import org.apache.arrow.vector.DateDayVector;
+import org.apache.arrow.vector.DecimalVector;
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.Float4Vector;
+import org.apache.arrow.vector.Float8Vector;
+import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.SmallIntVector;
+import org.apache.arrow.vector.TimeStampVector;
+import org.apache.arrow.vector.TinyIntVector;
+import org.apache.arrow.vector.VarBinaryVector;
+import org.apache.arrow.vector.VarCharVector;
+import org.apache.arrow.vector.VectorSchemaRoot;
+import org.apache.arrow.vector.complex.ListVector;
+import org.apache.arrow.vector.complex.MapVector;
+import org.apache.arrow.vector.complex.StructVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.paimon.data.BinaryString;
+import org.apache.paimon.data.BinaryVector;
+import org.apache.paimon.data.Blob;
+import org.apache.paimon.data.Decimal;
+import org.apache.paimon.data.GenericArray;
+import org.apache.paimon.data.GenericMap;
+import org.apache.paimon.data.GenericRow;
+import org.apache.paimon.data.Timestamp;
+import org.apache.paimon.data.variant.GenericVariant;
+import org.apache.paimon.types.ArrayType;
+import org.apache.paimon.types.BinaryType;
+import org.apache.paimon.types.BlobType;
+import org.apache.paimon.types.DataField;
+import org.apache.paimon.types.DataType;
+import org.apache.paimon.types.LocalZonedTimestampType;
+import org.apache.paimon.types.MapType;
+import org.apache.paimon.types.RowType;
+import org.apache.paimon.types.TimestampType;
+import org.apache.paimon.types.VarBinaryType;
+import org.apache.paimon.types.VariantType;
+import org.apache.paimon.types.VectorType;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/** Converts Arrow columns into Paimon internal values without owning writer state. */
+final class PaimonArrowConverter {
+
+    static final String VARIANT_VALUE_FIELD = "value";
+    static final String VARIANT_METADATA_FIELD = "metadata";
+
+    private final ZoneId sessionTimeZone;
+
+    PaimonArrowConverter(ZoneId sessionTimeZone) {
+        this.sessionTimeZone = sessionTimeZone;
+    }
+
+    RowReader rows(VectorSchemaRoot root, DataType[] targetTypes) {
+        List<Field> fields = root.getSchema().getFields();
+        List<FieldVector> vectors = root.getFieldVectors();
+        if (fields.size() != targetTypes.length) {
+            throw new IllegalArgumentException("Arrow column count does not match Paimon write type");
+        }
+        return new RowReader(fields, vectors, targetTypes);
+    }
+
+    /** Bound view of one Arrow batch which converts only the requested row. */
+    final class RowReader {
+        private final List<Field> fields;
+        private final List<FieldVector> vectors;
+        private final DataType[] targetTypes;
+
+        private RowReader(
+                List<Field> fields, List<FieldVector> vectors, DataType[] targetTypes) {
+            this.fields = fields;
+            this.vectors = vectors;
+            this.targetTypes = targetTypes;
+        }
+
+        Object[] values(int rowIndex) {
+            Object[] values = new Object[vectors.size()];
+            for (int column = 0; column < vectors.size(); column++) {
+                try {
+                    values[column] = convertVectorValue(
+                            vectors.get(column), rowIndex, fields.get(column), targetTypes[column]);
+                } catch (RuntimeException e) {
+                    throw new IllegalArgumentException(
+                            "Failed to convert Arrow column '" + fields.get(column).getName()
+                                    + "' at row " + rowIndex + " to Paimon "
+                                    + targetTypes[column],
+                            e);
+                }
+            }
+            return values;
+        }
+    }
+
+    private Object convertVectorValue(
+            FieldVector vector, int index, Field arrowField, DataType targetType) {
+        if (targetType instanceof BlobType) {
+            if (!(vector instanceof VarBinaryVector)) {
+                throw new IllegalArgumentException(
+                        "Paimon BLOB write requires an Arrow binary vector, but got "
+                                + vector.getField());
+            }
+            return vector.isNull(index)
+                    ? null : Blob.fromData(((VarBinaryVector) vector).get(index));
+        }
+        if (targetType instanceof VariantType) {
+            if (!(vector instanceof StructVector)) {
+                throw new IllegalArgumentException(
+                        "Paimon VARIANT write only supports Variant V2 Arrow "
+                                + "struct<value: binary, metadata: binary>, but got "
+                                + vector.getField());
+            }
+            return vector.isNull(index)
+                    ? null
+                    : convertVariantVector((StructVector) vector, index);
+        }
+        if (targetType instanceof VectorType) {
+            if (!(vector instanceof ListVector)) {
+                throw new IllegalArgumentException(
+                        "Paimon VECTOR write requires an Arrow list vector, but got "
+                                + vector.getField());
+            }
+            return vector.isNull(index)
+                    ? null : convertVectorVector((ListVector) vector, index, (VectorType) targetType);
+        }
+        if (vector.isNull(index)) {
+            return null;
+        }
+        if (vector instanceof StructVector && targetType instanceof RowType) {
+            return convertStructVector((StructVector) vector, index, (RowType) targetType);
+        }
+        if (vector instanceof MapVector && targetType instanceof MapType) {
+            return convertMapVector((MapVector) vector, index, (MapType) targetType);
+        }
+        if (vector instanceof ListVector && targetType instanceof ArrayType) {
+            return convertArrayVector((ListVector) vector, index, (ArrayType) targetType);
+        }
+        if (vector instanceof IntVector) {
+            return ((IntVector) vector).get(index);
+        }
+        if (vector instanceof BigIntVector) {
+            return ((BigIntVector) vector).get(index);
+        }
+        if (vector instanceof SmallIntVector) {
+            return ((SmallIntVector) vector).get(index);
+        }
+        if (vector instanceof TinyIntVector) {
+            return ((TinyIntVector) vector).get(index);
+        }
+        if (vector instanceof Float4Vector) {
+            return ((Float4Vector) vector).get(index);
+        }
+        if (vector instanceof Float8Vector) {
+            return ((Float8Vector) vector).get(index);
+        }
+        if (vector instanceof BitVector) {
+            return ((BitVector) vector).get(index) == 1;
+        }
+        if (vector instanceof DateDayVector) {
+            return ((DateDayVector) vector).get(index);
+        }
+        if (vector instanceof VarCharVector) {
+            byte[] value = ((VarCharVector) vector).get(index);
+            return convertText(value, targetType);
+        }
+        if (vector instanceof VarBinaryVector) {
+            return ((VarBinaryVector) vector).get(index);
+        }
+        if (vector instanceof TimeStampVector) {
+            ArrowType.Timestamp timestampType = (ArrowType.Timestamp) arrowField.getType();
+            return toPaimonTimestamp(
+                    arrowTimestampToMicros(((TimeStampVector) vector).get(index), timestampType),
+                    timestampType, targetType);
+        }
+        if (vector instanceof DecimalVector) {
+            DecimalVector decimalVector = (DecimalVector) vector;
+            int precision = decimalVector.getPrecision();
+            int scale = decimalVector.getScale();
+            BigDecimal decimal = getBigDecimalFromArrowBuf(
+                    decimalVector.getDataBuffer(), index, scale, DecimalVector.TYPE_WIDTH);
+            return Decimal.fromBigDecimal(decimal, precision, scale);
+        }
+        return convertToPaimonType(vector.getObject(index), arrowField, targetType);
+    }
+
+    private Object convertToPaimonType(Object value, Field arrowField, DataType targetType) {
+        if (value == null) {
+            return null;
+        }
+        if (targetType instanceof BlobType) {
+            return Blob.fromData(toBytes(value));
+        }
+        if (targetType instanceof BinaryType || targetType instanceof VarBinaryType) {
+            return toBytes(value);
+        }
+        if (value instanceof BinaryString) {
+            return value;
+        }
+        if (value instanceof byte[]) {
+            return BinaryString.fromBytes((byte[]) value);
+        }
+        if (value instanceof org.apache.arrow.vector.util.Text) {
+            return BinaryString.fromBytes(((org.apache.arrow.vector.util.Text) value).copyBytes());
+        }
+        if (value instanceof org.apache.hadoop.io.Text) {
+            org.apache.hadoop.io.Text text = (org.apache.hadoop.io.Text) value;
+            return BinaryString.fromBytes(text.getBytes(), 0, text.getLength());
+        }
+        if (value instanceof CharSequence) {
+            return BinaryString.fromString(value.toString());
+        }
+
+        ArrowType.ArrowTypeID typeId = arrowField == null
+                ? null : arrowField.getType().getTypeID();
+        if (value instanceof LocalDateTime) {
+            return toPaimonTimestamp((LocalDateTime) value, targetType);
+        }
+        if (value instanceof Long && typeId == ArrowType.ArrowTypeID.Timestamp) {
+            ArrowType.Timestamp timestampType = (ArrowType.Timestamp) arrowField.getType();
+            return toPaimonTimestamp(
+                    arrowTimestampToMicros((Long) value, timestampType), timestampType, targetType);
+        }
+        if (value instanceof Integer && typeId == ArrowType.ArrowTypeID.Date) {
+            return value;
+        }
+        if (value instanceof java.time.LocalDate) {
+            return (int) ((java.time.LocalDate) value).toEpochDay();
+        }
+        if (value instanceof BigDecimal) {
+            BigDecimal decimal = (BigDecimal) value;
+            return Decimal.fromBigDecimal(decimal, decimal.precision(), decimal.scale());
+        }
+        return value;
+    }
+
+    private static byte[] toBytes(Object value) {
+        if (value instanceof byte[]) {
+            return (byte[]) value;
+        }
+        if (value instanceof BinaryString) {
+            return ((BinaryString) value).toBytes();
+        }
+        if (value instanceof org.apache.arrow.vector.util.Text) {
+            return ((org.apache.arrow.vector.util.Text) value).copyBytes();
+        }
+        if (value instanceof String) {
+            return ((String) value).getBytes(StandardCharsets.UTF_8);
+        }
+        return value.toString().getBytes(StandardCharsets.UTF_8);
+    }
+
+    static Object convertText(byte[] value, DataType targetType) {
+        if (targetType instanceof BinaryType || targetType instanceof VarBinaryType) {
+            return value;
+        }
+        return BinaryString.fromBytes(value);
+    }
+
+    private GenericVariant convertVariantVector(StructVector vector, int index) {
+        List<FieldVector> children = vector.getChildrenFromFields();
+        if (children.size() != 2
+                || !VARIANT_VALUE_FIELD.equals(children.get(0).getName())
+                || !VARIANT_METADATA_FIELD.equals(children.get(1).getName())
+                || !(children.get(0) instanceof VarBinaryVector)
+                || !(children.get(1) instanceof VarBinaryVector)) {
+            throw new IllegalArgumentException(
+                    "Paimon VARIANT binary transport requires Arrow "
+                            + "struct<value: binary, metadata: binary>, but got "
+                            + vector.getField());
+        }
+        VarBinaryVector valueVector = (VarBinaryVector) children.get(0);
+        VarBinaryVector metadataVector = (VarBinaryVector) children.get(1);
+        if (valueVector.isNull(index) || metadataVector.isNull(index)) {
+            throw new IllegalArgumentException(
+                    "A non-null Paimon VARIANT struct requires non-null value and metadata");
+        }
+        // BE validates the complete Variant value for Paimon before Arrow transport.
+        // Keep this JNI boundary allocation-only instead of traversing the same tree again.
+        return new GenericVariant(valueVector.get(index), metadataVector.get(index));
+    }
+
+    private GenericRow convertStructVector(
+            StructVector vector, int index, RowType rowType) {
+        List<DataField> childFields = rowType.getFields();
+        List<FieldVector> childVectors = vector.getChildrenFromFields();
+        validateStructVectors(childFields, childVectors);
+        GenericRow row = new GenericRow(childFields.size());
+        for (int i = 0; i < childFields.size(); i++) {
+            DataField childField = childFields.get(i);
+            FieldVector childVector = childVectors.get(i);
+            row.setField(i, convertVectorValue(
+                    childVector, index, childVector.getField(), childField.type()));
+        }
+        return row;
+    }
+
+    private static void validateStructVectors(
+            List<DataField> childFields, List<FieldVector> childVectors) {
+        if (childVectors.size() != childFields.size()) {
+            throw structFieldCountMismatch(childVectors.size(), childFields.size());
+        }
+        for (int i = 0; i < childFields.size(); i++) {
+            validateStructField(i, childFields.get(i), childVectors.get(i).getName());
+        }
+    }
+
+    static void validateStructSchema(RowType rowType, List<String> arrowFieldNames) {
+        List<DataField> childFields = rowType.getFields();
+        if (arrowFieldNames.size() != childFields.size()) {
+            throw structFieldCountMismatch(arrowFieldNames.size(), childFields.size());
+        }
+        for (int i = 0; i < childFields.size(); i++) {
+            validateStructField(i, childFields.get(i), arrowFieldNames.get(i));
+        }
+    }
+
+    private static IllegalArgumentException structFieldCountMismatch(
+            int arrowFieldCount, int paimonFieldCount) {
+        return new IllegalArgumentException(
+                "Arrow struct field count does not match Paimon row type: arrow="
+                        + arrowFieldCount + ", paimon=" + paimonFieldCount);
+    }
+
+    private static void validateStructField(
+            int position, DataField paimonField, String arrowFieldName) {
+        if (!arrowFieldName.equalsIgnoreCase(paimonField.name())) {
+            throw new IllegalArgumentException(
+                    "Arrow struct field at position " + position + " does not match Paimon field "
+                            + paimonField.name() + ": " + arrowFieldName);
+        }
+    }
+
+    private GenericMap convertMapVector(
+            MapVector vector, int index, MapType mapType) {
+        StructVector entries = (StructVector) vector.getDataVector();
+        List<FieldVector> entryVectors = entries.getChildrenFromFields();
+        if (entryVectors.size() < 2) {
+            throw new IllegalArgumentException("Arrow map must contain key and value vectors");
+        }
+        FieldVector keyVector = entryVectors.get(0);
+        FieldVector valueVector = entryVectors.get(1);
+        int start = vector.getElementStartIndex(index);
+        int end = vector.getElementEndIndex(index);
+        Map<Object, Object> converted = new HashMap<>();
+        for (int entryIndex = start; entryIndex < end; entryIndex++) {
+            converted.put(
+                    convertVectorValue(
+                            keyVector, entryIndex, keyVector.getField(), mapType.getKeyType()),
+                    convertVectorValue(
+                            valueVector, entryIndex, valueVector.getField(),
+                            mapType.getValueType()));
+        }
+        return new GenericMap(converted);
+    }
+
+    private GenericArray convertArrayVector(
+            ListVector vector, int index, ArrayType arrayType) {
+        FieldVector elementVector = vector.getDataVector();
+        int start = vector.getElementStartIndex(index);
+        int end = vector.getElementEndIndex(index);
+        Object[] converted = new Object[end - start];
+        for (int elementIndex = start; elementIndex < end; elementIndex++) {
+            converted[elementIndex - start] = convertVectorValue(
+                    elementVector, elementIndex, elementVector.getField(),
+                    arrayType.getElementType());
+        }
+        return new GenericArray(converted);
+    }
+
+    private BinaryVector convertVectorVector(
+            ListVector vector, int index, VectorType vectorType) {
+        FieldVector elementVector = vector.getDataVector();
+        int start = vector.getElementStartIndex(index);
+        int end = vector.getElementEndIndex(index);
+        int actualLength = end - start;
+        if (actualLength != vectorType.getLength()) {
+            throw new IllegalArgumentException(
+                    "Paimon VECTOR requires " + vectorType.getLength()
+                            + " elements, but Arrow row has " + actualLength);
+        }
+        Object[] converted = new Object[actualLength];
+        for (int elementIndex = start; elementIndex < end; elementIndex++) {
+            if (elementVector.isNull(elementIndex)) {
+                throw new IllegalArgumentException("Paimon VECTOR elements must not be null");
+            }
+            converted[elementIndex - start] = convertVectorValue(
+                    elementVector, elementIndex, elementVector.getField(),
+                    vectorType.getElementType());
+        }
+        return BinaryVector.fromInternalArray(
+                new GenericArray(converted), vectorType.getElementType());
+    }
+
+    private static BigDecimal getBigDecimalFromArrowBuf(
+            org.apache.arrow.memory.ArrowBuf buffer, int index, int scale, int byteWidth) {
+        byte[] value = new byte[byteWidth];
+        buffer.getBytes((long) index * byteWidth, value, 0, byteWidth);
+        if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+            for (int i = 0; i < byteWidth / 2; i++) {
+                byte temporary = value[i];
+                int opposite = byteWidth - 1 - i;
+                value[i] = value[opposite];
+                value[opposite] = temporary;
+            }
+        }
+        return new BigDecimal(new BigInteger(value), scale);
+    }
+
+    private static long arrowTimestampToMicros(
+            long value, ArrowType.Timestamp timestampType) {
+        switch (timestampType.getUnit()) {
+            case SECOND:
+                return Math.multiplyExact(value, 1_000_000L);
+            case MILLISECOND:
+                return Math.multiplyExact(value, 1_000L);
+            case MICROSECOND:
+                return value;
+            case NANOSECOND:
+                return Math.floorDiv(value, 1_000L);
+            default:
+                throw new IllegalArgumentException(
+                        "Unsupported Arrow timestamp unit: " + timestampType.getUnit());
+        }
+    }
+
+    Timestamp toPaimonTimestamp(long micros, ArrowType.Timestamp arrowType,
+                                DataType targetType) {
+        String arrowTimeZone = arrowType.getTimezone();
+        if (arrowTimeZone != null && !arrowTimeZone.isEmpty()) {
+            throw new IllegalArgumentException(
+                    "Paimon write timestamp must use a timezone-free Arrow type");
+        }
+        long epochSecond = Math.floorDiv(micros, 1_000_000L);
+        long microsOfSecond = Math.floorMod(micros, 1_000_000L);
+        LocalDateTime civilTime = LocalDateTime.ofEpochSecond(
+                epochSecond, (int) microsOfSecond * 1_000, ZoneOffset.UTC);
+        return toPaimonTimestamp(civilTime, targetType);
+    }
+
+    Timestamp toPaimonTimestamp(LocalDateTime civilTime, DataType targetType) {
+        if (targetType instanceof LocalZonedTimestampType) {
+            return Timestamp.fromInstant(civilTime.atZone(sessionTimeZone).toInstant());
+        }
+        if (targetType instanceof TimestampType) {
+            return Timestamp.fromLocalDateTime(civilTime);
+        }
+        throw new IllegalArgumentException(
+                "Arrow timestamp cannot be written to Paimon type " + targetType);
+    }
+}
diff --git a/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonColumnValue.java b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonColumnValue.java
index 339feb97c9b9f1..cf84871d6b7ffa 100644
--- a/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonColumnValue.java
+++ b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonColumnValue.java
@@ -24,12 +24,17 @@
 import org.apache.paimon.data.InternalArray;
 import org.apache.paimon.data.InternalMap;
 import org.apache.paimon.data.InternalRow;
+import org.apache.paimon.data.InternalVector;
 import org.apache.paimon.data.Timestamp;
+import org.apache.paimon.data.variant.Variant;
 import org.apache.paimon.types.ArrayType;
+import org.apache.paimon.types.BlobType;
 import org.apache.paimon.types.DataType;
 import org.apache.paimon.types.LocalZonedTimestampType;
 import org.apache.paimon.types.MapType;
 import org.apache.paimon.types.RowType;
+import org.apache.paimon.types.VariantType;
+import org.apache.paimon.types.VectorType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -64,6 +69,8 @@ public class PaimonColumnValue implements ColumnValue {
     private ColumnType dorisType;
     private DataType dataType;
     private ZoneId timeZone;
+    private boolean directBinary;
+    private byte[] directBytes;
     // Keep these caches lazy so scalar columns do not pay for complex-type reuse bookkeeping.
     private List<PaimonColumnValue> arrayValues;
     private List<PaimonColumnValue> mapKeys;
@@ -90,6 +97,8 @@ public void setIdx(int idx, ColumnType dorisType, DataType dataType) {
         this.idx = idx;
         this.dorisType = dorisType;
         this.dataType = dataType;
+        this.directBinary = false;
+        this.directBytes = null;
     }
 
     public void setOffsetRow(InternalRow record) {
@@ -185,6 +194,9 @@ public LocalDateTime getTimeStampTz() {
 
     @Override
     public boolean isNull() {
+        if (directBinary) {
+            return directBytes == null;
+        }
         boolean isNull = record.isNullAt(idx);
         if (isNull) {
             // A null complex value has no live descendants; release wrappers retained by its prior row.
@@ -195,17 +207,36 @@ public boolean isNull() {
 
     @Override
     public byte[] getBytes() {
+        if (directBinary) {
+            return directBytes;
+        }
+        if (dataType instanceof BlobType) {
+            return record.getBlob(idx).toData();
+        }
         return record.getBinary(idx);
     }
 
     @Override
     public void unpackArray(List<ColumnValue> values) {
-        InternalArray recordArray = record.getArray(idx);
+        InternalArray recordArray;
+        DataType elementPaimonType;
+        if (dataType instanceof VectorType) {
+            VectorType vectorType = (VectorType) dataType;
+            InternalVector vector = record.getVector(idx);
+            if (vector.size() != vectorType.getLength()) {
+                throw new IllegalArgumentException("Paimon VECTOR length " + vector.size()
+                        + " does not match declared length " + vectorType.getLength());
+            }
+            recordArray = vector;
+            elementPaimonType = vectorType.getElementType();
+        } else {
+            recordArray = record.getArray(idx);
+            elementPaimonType = ((ArrayType) dataType).getElementType();
+        }
         if (arrayValues == null) {
             arrayValues = new ArrayList<>();
         }
         ColumnType elementDorisType = dorisType.getChildTypes().get(0);
-        DataType elementPaimonType = ((ArrayType) dataType).getElementType();
         for (int i = 0; i < recordArray.size(); i++) {
             values.add(reuseColumnValue(arrayValues, i, (DataGetters) recordArray, i,
                     elementDorisType, elementPaimonType));
@@ -240,6 +271,10 @@ public void unpackMap(List<ColumnValue> keys, List<ColumnValue> values) {
 
     @Override
     public void unpackStruct(List<Integer> structFieldIndex, List<ColumnValue> values) {
+        if (dataType instanceof VariantType) {
+            unpackVariant(structFieldIndex, values);
+            return;
+        }
         RowType rowType = (RowType) dataType;
         // Projection entries are original child indexes, so the binary row must keep the full RowType arity.
         InternalRow row = record.getRow(idx, rowType.getFieldCount());
@@ -252,6 +287,22 @@ public void unpackStruct(List<Integer> structFieldIndex, List<ColumnValue> value
         }
     }
 
+    private void unpackVariant(List<Integer> structFieldIndex, List<ColumnValue> values) {
+        Variant variant = record.getVariant(idx);
+        if (structValues == null) {
+            structValues = new ArrayList<>();
+        }
+        for (int fieldIndex : structFieldIndex) {
+            if (fieldIndex < 0 || fieldIndex > 1) {
+                throw new IllegalArgumentException(
+                        "Paimon VARIANT transport only has value and metadata fields");
+            }
+            byte[] bytes = fieldIndex == 0 ? variant.value() : variant.metadata();
+            values.add(reuseBinaryColumnValue(
+                    structValues, fieldIndex, bytes, dorisType.getChildTypes().get(fieldIndex)));
+        }
+    }
+
     private PaimonColumnValue reuseColumnValue(
             List<PaimonColumnValue> cache, int cacheIndex, DataGetters childRecord, int childIndex,
             ColumnType childDorisType, DataType childPaimonType) {
@@ -270,6 +321,20 @@ private PaimonColumnValue reuseColumnValue(
         return value;
     }
 
+    private PaimonColumnValue reuseBinaryColumnValue(
+            List<PaimonColumnValue> cache, int cacheIndex, byte[] bytes, ColumnType childDorisType) {
+        while (cache.size() <= cacheIndex) {
+            cache.add(null);
+        }
+        PaimonColumnValue value = cache.get(cacheIndex);
+        if (value == null) {
+            value = new PaimonColumnValue();
+            cache.set(cacheIndex, value);
+        }
+        value.resetBinary(bytes, childDorisType);
+        return value;
+    }
+
     private void reset(
             DataGetters record, int idx, ColumnType dorisType, DataType dataType, ZoneId timeZone) {
         this.record = record;
@@ -277,6 +342,18 @@ private void reset(
         this.dorisType = dorisType;
         this.dataType = dataType;
         this.timeZone = timeZone;
+        this.directBinary = false;
+        this.directBytes = null;
+    }
+
+    private void resetBinary(byte[] bytes, ColumnType dorisType) {
+        this.record = null;
+        this.idx = 0;
+        this.dorisType = dorisType;
+        this.dataType = null;
+        this.directBinary = true;
+        this.directBytes = bytes;
+        clearChildCaches();
     }
 
     private static ZoneId resolveTimeZone(String timeZone) {
diff --git a/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonCommitCodec.java b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonCommitCodec.java
new file mode 100644
index 00000000000000..a000ab4be718a4
--- /dev/null
+++ b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonCommitCodec.java
@@ -0,0 +1,222 @@
+// 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.doris.paimon;
+
+import org.apache.paimon.io.DataInputDeserializer;
+import org.apache.paimon.io.DataOutputViewStreamWrapper;
+import org.apache.paimon.table.sink.CommitMessage;
+import org.apache.paimon.table.sink.CommitMessageSerializer;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Encodes Paimon commit messages into the DPCM (Doris-Paimon Commit Message) payload
+ * format forwarded to FE.
+ *
+ * <h3>DPCM framing format</h3>
+ * Each payload is framed as:
+ * <pre>
+ *   ┌──────────┬─────────────┬────────────┬──────────────────────┐
+ *   │ Magic (4)│ Version (4) │ Length (4) │ Serialized Messages  │
+ *   │  "DPCM"  │  big-endian │ big-endian │     (varies)         │
+ *   └──────────┴─────────────┴────────────┴──────────────────────┘
+ * </pre>
+ *
+ * <p>Messages are serialized using Paimon's {@link CommitMessageSerializer} and
+ * split into chunks if the serialized payload exceeds {@link #MAX_PAYLOAD_BYTES}
+ * (8 MiB). Chunk size starts at {@link #DEFAULT_CHUNK_SIZE} (512 messages) and
+ * is halved adaptively until each chunk fits within the size limit.
+ */
+final class PaimonCommitCodec {
+    static final int HEADER_BYTES = 12;
+    /** Maximum framed payload size per chunk (8 MiB). */
+    static final int MAX_PAYLOAD_BYTES = 8 * 1024 * 1024;
+    /** Starting number of commit messages per chunk. */
+    static final int DEFAULT_CHUNK_SIZE = 512;
+
+    private final CommitMessageSerializer serializer = new CommitMessageSerializer();
+    private final int maxPayloadBytes;
+    private final int defaultChunkSize;
+
+    PaimonCommitCodec() {
+        this(MAX_PAYLOAD_BYTES, DEFAULT_CHUNK_SIZE);
+    }
+
+    PaimonCommitCodec(int maxPayloadBytes, int defaultChunkSize) {
+        if (maxPayloadBytes <= HEADER_BYTES || defaultChunkSize <= 0) {
+            throw new IllegalArgumentException("Invalid Paimon commit payload limits");
+        }
+        this.maxPayloadBytes = maxPayloadBytes;
+        this.defaultChunkSize = defaultChunkSize;
+    }
+
+    /**
+     * Encode commit messages into DPCM-framed byte chunks.
+     *
+     * @param messages Paimon commit messages from {@code prepareCommit()}
+     * @return byte[][] where each element is a complete DPCM-framed chunk
+     */
+    byte[][] encode(List<CommitMessage> messages) throws Exception {
+        if (messages.isEmpty()) {
+            return new byte[0][];
+        }
+
+        // Adaptive chunking uses a size-limited output. An oversized attempt
+        // therefore stops before allocating beyond one chunk's budget.
+        int chunkSize = defaultChunkSize;
+        List<byte[]> payloads = new ArrayList<>();
+        int offset = 0;
+        while (offset < messages.size()) {
+            int end = Math.min(offset + chunkSize, messages.size());
+            byte[] payload;
+            try {
+                payload = encodeChunk(messages.subList(offset, end));
+            } catch (PayloadTooLargeException e) {
+                if (chunkSize > 1) {
+                    chunkSize = Math.max(1, chunkSize / 2);
+                    continue;
+                }
+                throw new IOException("A single Paimon commit message exceeds the "
+                        + maxPayloadBytes + " byte framed payload limit", e);
+            }
+            payloads.add(payload);
+            offset = end;
+        }
+        return payloads.toArray(new byte[0][]);
+    }
+
+    /** Decode DPCM-framed chunks back into Paimon commit messages. */
+    List<CommitMessage> decode(byte[][] payloads) throws IOException {
+        List<CommitMessage> messages = new ArrayList<>();
+        if (payloads == null) {
+            throw new IOException("Paimon commit payloads are null");
+        }
+        for (byte[] payload : payloads) {
+            if (payload == null || payload.length < HEADER_BYTES
+                    || payload[0] != 'D' || payload[1] != 'P'
+                    || payload[2] != 'C' || payload[3] != 'M') {
+                throw new IOException("Invalid Paimon commit message payload header");
+            }
+            int version = readInt(payload, 4);
+            int length = readInt(payload, 8);
+            if (length < 0 || payload.length != HEADER_BYTES + length) {
+                throw new IOException("Invalid Paimon commit message payload length");
+            }
+            List<CommitMessage> chunk = serializer.deserializeList(
+                    version,
+                    new DataInputDeserializer(Arrays.copyOfRange(
+                            payload, HEADER_BYTES, payload.length)));
+            if (chunk == null) {
+                throw new IOException("Paimon commit message payload deserialized to null");
+            }
+            messages.addAll(chunk);
+        }
+        return messages;
+    }
+
+    /** Serialize one chunk of messages and wrap it in a DPCM frame. */
+    private byte[] encodeChunk(List<CommitMessage> messages) throws Exception {
+        BoundedOutputStream output = new BoundedOutputStream(maxPayloadBytes);
+        output.write(new byte[HEADER_BYTES]);
+        serializer.serializeList(messages, new DataOutputViewStreamWrapper(output));
+
+        byte[] payload = output.toByteArray();
+        payload[0] = 'D';
+        payload[1] = 'P';
+        payload[2] = 'C';
+        payload[3] = 'M';
+        writeInt(payload, 4, serializer.getVersion());
+        writeInt(payload, 8, payload.length - HEADER_BYTES);
+        return payload;
+    }
+
+    /**
+     * Wrap serialized data in a DPCM frame: 4-byte magic "DPCM", 4-byte version
+     * (big-endian), 4-byte data length (big-endian), followed by the data.
+     */
+    static byte[] frame(byte[] data, int version) {
+        byte[] payload = new byte[HEADER_BYTES + data.length];
+        payload[0] = 'D';
+        payload[1] = 'P';
+        payload[2] = 'C';
+        payload[3] = 'M';
+        writeInt(payload, 4, version);
+        writeInt(payload, 8, data.length);
+        System.arraycopy(data, 0, payload, HEADER_BYTES, data.length);
+        return payload;
+    }
+
+    /** Write a 32-bit integer in big-endian byte order. */
+    private static void writeInt(byte[] output, int offset, int value) {
+        output[offset] = (byte) ((value >>> 24) & 0xFF);
+        output[offset + 1] = (byte) ((value >>> 16) & 0xFF);
+        output[offset + 2] = (byte) ((value >>> 8) & 0xFF);
+        output[offset + 3] = (byte) (value & 0xFF);
+    }
+
+    private static int readInt(byte[] input, int offset) {
+        return ((input[offset] & 0xff) << 24)
+                | ((input[offset + 1] & 0xff) << 16)
+                | ((input[offset + 2] & 0xff) << 8)
+                | (input[offset + 3] & 0xff);
+    }
+
+    private static final class PayloadTooLargeException extends IOException {
+        private PayloadTooLargeException(int limit) {
+            super("Paimon commit serialization exceeds " + limit + " bytes");
+        }
+    }
+
+    /** Output stream which fails before Paimon serialization can exceed one framed chunk. */
+    private static final class BoundedOutputStream extends OutputStream {
+        private final ByteArrayOutputStream output;
+        private final int limit;
+
+        private BoundedOutputStream(int limit) {
+            this.output = new ByteArrayOutputStream(Math.min(1024, limit));
+            this.limit = limit;
+        }
+
+        private void reserve(int bytes) throws IOException {
+            if (bytes < 0 || bytes > limit - output.size()) {
+                throw new PayloadTooLargeException(limit);
+            }
+        }
+
+        @Override
+        public void write(int value) throws IOException {
+            reserve(1);
+            output.write(value);
+        }
+
+        @Override
+        public void write(byte[] value, int offset, int length) throws IOException {
+            reserve(length);
+            output.write(value, offset, length);
+        }
+
+        private byte[] toByteArray() {
+            return output.toByteArray();
+        }
+    }
+}
diff --git a/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonJniWriter.java b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonJniWriter.java
new file mode 100644
index 00000000000000..67c998e06d5fbc
--- /dev/null
+++ b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonJniWriter.java
@@ -0,0 +1,781 @@
+// 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.doris.paimon;
+
+import org.apache.doris.common.classloader.ThreadClassLoaderContext;
+import org.apache.doris.kerberos.PreExecutionAuthenticator;
+import org.apache.doris.kerberos.PreExecutionAuthenticatorCache;
+
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.VectorSchemaRoot;
+import org.apache.arrow.vector.ipc.ArrowStreamReader;
+import org.apache.paimon.CoreOptions;
+import org.apache.paimon.crosspartition.GlobalIndexAssigner;
+import org.apache.paimon.crosspartition.IndexBootstrap;
+import org.apache.paimon.data.BinaryRow;
+import org.apache.paimon.data.InternalRow;
+import org.apache.paimon.disk.IOManager;
+import org.apache.paimon.disk.IOManagerImpl;
+import org.apache.paimon.index.BucketAssigner;
+import org.apache.paimon.index.HashBucketAssigner;
+import org.apache.paimon.index.SimpleHashBucketAssigner;
+import org.apache.paimon.memory.MemoryPoolFactory;
+import org.apache.paimon.options.MemorySize;
+import org.apache.paimon.options.Options;
+import org.apache.paimon.table.BucketMode;
+import org.apache.paimon.table.FileStoreTable;
+import org.apache.paimon.table.sink.CommitMessage;
+import org.apache.paimon.table.sink.InnerTableCommit;
+import org.apache.paimon.table.sink.PartitionKeyExtractor;
+import org.apache.paimon.table.sink.RowPartitionKeyExtractor;
+import org.apache.paimon.table.sink.SinkRecord;
+import org.apache.paimon.table.sink.TableWriteImpl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.time.ZoneId;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * JNI entry point for Paimon write operations.
+ *
+ * <p>Called from C++ ({@code JniPaimonWriter}) via JNI. One instance per BE pipeline
+ * fragment (one per {@code PaimonTableWriter}). Data path:
+ *
+ * <pre>
+ *   C++ Block → Arrow IPC Stream → JNI direct ByteBuffer
+ *   → PaimonJniWriter.write(directBuffer)
+ *   → ArrowStreamReader → VectorSchemaRoot
+ *   → PaimonArrowConverter (row-at-a-time typed extraction)
+ *   → PaimonWriteSchema.tableRow() (canonical table-schema order)
+ *   → Paimon SDK bucket assignment and table write
+ * </pre>
+ *
+ * <p>Commit path:
+ *
+ * <pre>
+ *   PaimonTableWriter::close() → JNI → PaimonJniWriter.prepareCommit()
+ *   → TableWriteImpl.prepareCommit()
+ *   → PaimonCommitCodec.encode() → DPCM-framed byte[][]
+ *   → C++ collects TPaimonCommitMessage[] → RPC to FE → PaimonTransaction
+ * </pre>
+ */
+public class PaimonJniWriter {
+    private static final Logger LOG = LoggerFactory.getLogger(PaimonJniWriter.class);
+
+    private final ClassLoader classLoader;
+    private final PaimonCommitCodec commitCodec = new PaimonCommitCodec();
+
+    private BufferAllocator allocator;
+    private PreExecutionAuthenticator preExecutionAuthenticator;
+    private PaimonArrowConverter arrowConverter;
+
+    private PaimonWriteSchema writeSchema;
+    private FileStoreTable table;
+    private TableWriteImpl<?> writer;
+    private IOManager ioManager;
+    private long commitIdentifier;
+    private String commitUser;
+    private BucketMode bucketMode;
+    private BucketAssigner hashBucketAssigner;
+    private PartitionKeyExtractor<InternalRow> dynamicBucketExtractor;
+    private GlobalIndexAssigner globalIndexAssigner;
+    private boolean fullCompactionChangelog;
+    private final Set<PartitionBucket> fullCompactionBuckets = new HashSet<>();
+    private List<CommitMessage> preparedCommitMessages = Collections.emptyList();
+    private boolean sdkCloseFailed;
+
+    public PaimonJniWriter() {
+        this.classLoader = this.getClass().getClassLoader();
+    }
+
+    // ────────────────────────────────────────────────────────────
+    // JNI entry points (called from C++)
+    // ────────────────────────────────────────────────────────────
+
+    /**
+     * Initialize the writer. Called once per BE pipeline fragment via JNI.
+     *
+     * <p>This method:
+     * <ol>
+     *   <li>Deserializes the target Paimon {@link FileStoreTable} selected by FE.</li>
+     *   <li>Creates a {@link PaimonWriteSchema} which normalizes Doris input
+     *       columns to the table-schema row layout.</li>
+     *   <li>Opens one Paimon SDK writer session.</li>
+     * </ol>
+     *
+     * @param serializedTable serialized Paimon table selected by FE
+     * @param hadoopConfig   filesystem and authentication configuration
+     * @param columnNames    output column names in the order produced by BE
+     * @param transactionId  Doris external transaction identifier
+     * @param commitUser     Paimon commit user shared with the FE committer
+     * @param overwrite      whether this is an overwrite write
+     * @param timeZone       normalized Doris session timezone used for Paimon LTZ values
+     * @param spillDirectories Doris storage-root scoped directories for Paimon write-buffer spill
+     * @param memoryPoolLimitBytes maximum Doris-managed Paimon write-buffer memory
+     * @param nativeMemoryManager opaque BE manager used to allocate tracked native pages
+     */
+    public void open(String serializedTable, Map<String, String> hadoopConfig,
+                     String[] columnNames, long transactionId, String commitUser,
+                     boolean overwrite, String timeZone, String spillDirectories,
+                     long memoryPoolLimitBytes, long nativeMemoryManager) throws Exception {
+        try (ThreadClassLoaderContext ignored = new ThreadClassLoaderContext(classLoader)) {
+            if (memoryPoolLimitBytes <= 0) {
+                throw new IllegalArgumentException(
+                        "PaimonJniWriter requires a positive memory pool limit");
+            }
+            if (nativeMemoryManager == 0) {
+                throw new IllegalArgumentException(
+                        "PaimonJniWriter requires a native memory manager");
+            }
+            this.preExecutionAuthenticator = PreExecutionAuthenticatorCache.getAuthenticator(hadoopConfig);
+            this.arrowConverter = new PaimonArrowConverter(ZoneId.of(timeZone));
+            preExecutionAuthenticator.execute(() -> {
+                try {
+                    FileStoreTable table = PaimonUtils.deserialize(serializedTable);
+                    LOG.info("PaimonJniWriter opening: table={}, columns={}",
+                            table.fullName(), columnNames != null ? columnNames.length : 0);
+                    this.commitIdentifier = transactionId;
+                    this.table = table;
+                    this.commitUser = commitUser;
+                    this.bucketMode = table.bucketMode();
+
+                    CoreOptions coreOptions = CoreOptions.fromMap(table.options());
+                    MemoryBudget memoryBudget = createMemoryBudget(
+                            memoryPoolLimitBytes, coreOptions.pageSize(), bucketMode);
+                    this.allocator = new RootAllocator(memoryBudget.arrowMemoryBytes);
+                    LOG.info(
+                            "Paimon writer memory budget: total={}, arrow={}, writer={}, "
+                                    + "globalIndexLookup={}, globalIndexWriteBuffer={}",
+                            memoryPoolLimitBytes,
+                            memoryBudget.arrowMemoryBytes,
+                            memoryBudget.writerMemoryBytes,
+                            memoryBudget.globalIndexLookupMemoryBytes,
+                            memoryBudget.globalIndexWriteBufferBytes);
+                    this.writeSchema = PaimonWriteSchema.create(table.rowType(), columnNames);
+                    validateWriteColumnsForMergeEngine(columnNames.length, coreOptions);
+                    this.fullCompactionChangelog =
+                            !coreOptions.writeOnly()
+                                    && coreOptions.changelogProducer()
+                                    == CoreOptions.ChangelogProducer.FULL_COMPACTION;
+                    openFileStoreWriter(
+                            table,
+                            commitUser,
+                            overwrite,
+                            spillDirectories,
+                            coreOptions,
+                            memoryBudget,
+                            nativeMemoryManager);
+                    return null;
+                } catch (Throwable t) {
+                    try {
+                        closeResources();
+                    } catch (Throwable closeFailure) {
+                        t.addSuppressed(closeFailure);
+                    }
+                    throw new RuntimeException("PaimonJniWriter open failed", t);
+                }
+            });
+        }
+    }
+
+    /**
+     * Write a batch of rows from an Arrow IPC Stream buffer.
+     *
+     * <p>Called from C++ {@code JniPaimonWriter::_write_projected_block()}
+     * once per Block. The buffer is a zero-copy direct view of the native
+     * Arrow IPC Stream bytes. Rows are deserialized, normalized to table-schema
+     * order, and handed to Paimon's writer and bucket assigner APIs. The SDK
+     * owns partition/bucket semantics, buffering, spill, and file rolling.
+     *
+     * @param directBuffer direct view of the native Arrow IPC Stream bytes (no copy)
+     */
+    public void write(ByteBuffer directBuffer) throws Exception {
+        try (ThreadClassLoaderContext ignored = new ThreadClassLoaderContext(classLoader)) {
+            preExecutionAuthenticator.execute(() -> {
+                try {
+                    try (ArrowStreamReader reader = new ArrowStreamReader(
+                            new DirectBufInputStream(directBuffer), allocator)) {
+                        VectorSchemaRoot root = reader.getVectorSchemaRoot();
+                        while (reader.loadNextBatch()) {
+                            writeBatch(root);
+                        }
+                    }
+                    return null;
+                } catch (Throwable t) {
+                    throw new RuntimeException(
+                            "PaimonJniWriter write failed: bytes=" + directBuffer.capacity(), t);
+                }
+            });
+        }
+    }
+
+    /**
+     * Prepare commit: flush all in-memory data, close files, and serialize commit
+     * messages for the FE coordinator.
+     *
+     * <p>Flushes and collects Paimon {@link CommitMessage}s, then encodes them via
+     * {@link PaimonCommitCodec} into DPCM-framed byte chunks that are forwarded to
+     * FE through the BE.
+     *
+     * @return byte[][]  each element is a DPCM-framed serialized CommitMessage chunk
+     */
+    public byte[][] prepareCommit() throws Exception {
+        try (ThreadClassLoaderContext ignored = new ThreadClassLoaderContext(classLoader)) {
+            return preExecutionAuthenticator.execute(() -> {
+                try {
+                    List<CommitMessage> messages = prepareCommitMessages();
+                    if (messages.isEmpty()) {
+                        LOG.info("PaimonJniWriter prepareCommit: empty");
+                        return new byte[0][];
+                    }
+                    LOG.info("PaimonJniWriter prepareCommit: {} messages", messages.size());
+                    return commitCodec.encode(messages);
+                } catch (Throwable t) {
+                    throw new RuntimeException("PaimonJniWriter prepareCommit failed", t);
+                }
+            });
+        }
+    }
+
+    /**
+     * Abort: discard all written data files and close the SDK writer.
+     * Called from C++ when write or prepareCommit fails.
+     */
+    public void abort() throws Exception {
+        try (ThreadClassLoaderContext ignored = new ThreadClassLoaderContext(classLoader)) {
+            try {
+                if (preExecutionAuthenticator != null) {
+                    preExecutionAuthenticator.execute(() -> {
+                        abortWriter();
+                        return null;
+                    });
+                } else {
+                    abortWriter();
+                }
+            } catch (Exception e) {
+                LOG.error("PaimonJniWriter abort failed", e);
+                throw e;
+            }
+        }
+    }
+
+    /**
+     * Close: release all resources.
+     */
+    public void close() throws Exception {
+        try (ThreadClassLoaderContext ignored = new ThreadClassLoaderContext(classLoader)) {
+            try {
+                if (preExecutionAuthenticator != null) {
+                    preExecutionAuthenticator.execute(() -> {
+                        closeResources();
+                        return null;
+                    });
+                } else {
+                    closeResources();
+                }
+            } catch (Exception e) {
+                LOG.warn("PaimonJniWriter close error", e);
+                throw e;
+            }
+        }
+    }
+
+    /**
+     * Aborts prepared files after the writer itself has closed and FE explicitly rejected the
+     * final ownership report.
+     */
+    public static void abortPreparedCommit(String serializedTable,
+            Map<String, String> hadoopConfig, String commitUser, byte[][] payloads) throws Exception {
+        ClassLoader classLoader = PaimonJniWriter.class.getClassLoader();
+        try (ThreadClassLoaderContext ignored = new ThreadClassLoaderContext(classLoader)) {
+            PreExecutionAuthenticator authenticator =
+                    PreExecutionAuthenticatorCache.getAuthenticator(hadoopConfig);
+            authenticator.execute(() -> {
+                FileStoreTable table = PaimonUtils.deserialize(serializedTable);
+                List<CommitMessage> messages = new PaimonCommitCodec().decode(payloads);
+                if (messages.isEmpty()) {
+                    return null;
+                }
+                InnerTableCommit committer = table.newCommit(commitUser);
+                try {
+                    committer.abort(messages);
+                    return null;
+                } finally {
+                    committer.close();
+                }
+            });
+        }
+    }
+
+    // ────────────────────────────────────────────────────────────
+    // Initialization helpers
+    // ────────────────────────────────────────────────────────────
+
+    private void openFileStoreWriter(FileStoreTable table, String commitUser, boolean overwrite,
+            String spillDirectories, CoreOptions coreOptions, MemoryBudget memoryBudget,
+            long nativeMemoryManager) throws Exception {
+        writer = table.newWrite(commitUser);
+        if (overwrite) {
+            writer.withIgnorePreviousFiles(true);
+        }
+        openMemoryResources(
+                coreOptions, spillDirectories, memoryBudget.writerMemoryBytes, nativeMemoryManager);
+        openDynamicBucketAssigner(table, commitUser, overwrite, coreOptions, memoryBudget);
+    }
+
+    private void validateWriteColumnsForMergeEngine(int writeColumnCount, CoreOptions coreOptions) {
+        if (writeColumnCount == table.rowType().getFieldCount() || table.primaryKeys().isEmpty()) {
+            return;
+        }
+
+        CoreOptions.MergeEngine mergeEngine = coreOptions.mergeEngine();
+        if (mergeEngine != CoreOptions.MergeEngine.PARTIAL_UPDATE) {
+            throw new UnsupportedOperationException(
+                    "Paimon primary-key partial-column write requires "
+                            + "merge-engine=partial-update, but table uses merge-engine="
+                            + mergeEngine);
+        }
+    }
+
+    static MemoryBudget createMemoryBudget(
+            long totalBytes, int pageSize, BucketMode bucketMode) {
+        if (pageSize <= 0) {
+            throw new IllegalArgumentException("Paimon page size must be positive");
+        }
+        boolean keyDynamic = bucketMode == BucketMode.KEY_DYNAMIC;
+        long minimumBytes = Math.multiplyExact((long) pageSize, keyDynamic ? 5L : 2L);
+        if (totalBytes < minimumBytes) {
+            throw new IllegalArgumentException(
+                    "Paimon writer memory budget is too small for " + bucketMode
+                            + ": totalBytes=" + totalBytes + ", minimumBytes=" + minimumBytes);
+        }
+
+        if (!keyDynamic) {
+            long writerBytes = alignDownToPage(totalBytes / 2, pageSize);
+            return new MemoryBudget(totalBytes - writerBytes, writerBytes, 0, 0);
+        }
+
+        long componentBytes = totalBytes / 4;
+        long writerBytes = alignDownToPage(componentBytes, pageSize);
+        long indexWriteBufferBytes = Math.max(
+                Math.multiplyExact((long) pageSize, 2L),
+                alignDownToPage(componentBytes, pageSize));
+        long indexLookupBytes = componentBytes;
+        long arrowBytes = totalBytes - writerBytes - indexLookupBytes - indexWriteBufferBytes;
+        if (arrowBytes <= 0) {
+            throw new IllegalArgumentException(
+                    "Paimon key-dynamic writer has no Arrow memory after budget allocation");
+        }
+        return new MemoryBudget(
+                arrowBytes, writerBytes, indexLookupBytes, indexWriteBufferBytes);
+    }
+
+    private static long alignDownToPage(long bytes, int pageSize) {
+        return bytes - bytes % pageSize;
+    }
+
+    static FileStoreTable tableWithGlobalIndexMemoryLimits(
+            FileStoreTable table, MemoryBudget memoryBudget) {
+        Options options = Options.fromMap(new HashMap<>(table.options()));
+        options.set(
+                CoreOptions.LOOKUP_CACHE_MAX_MEMORY_SIZE,
+                new MemorySize(memoryBudget.globalIndexLookupMemoryBytes));
+        options.set(
+                CoreOptions.WRITE_BUFFER_SIZE,
+                new MemorySize(memoryBudget.globalIndexWriteBufferBytes));
+        return table.copy(options.toMap());
+    }
+
+    private void openMemoryResources(
+            CoreOptions coreOptions,
+            String spillDirectories,
+            long memoryPoolLimitBytes,
+            long nativeMemoryManager) throws Exception {
+        int pageSize = coreOptions.pageSize();
+        long effectivePoolLimit = Math.min(coreOptions.writeBufferSize(), memoryPoolLimitBytes);
+        DorisMemorySegmentPool memorySegmentPool =
+                new DorisMemorySegmentPool(effectivePoolLimit, pageSize, nativeMemoryManager);
+        MemoryPoolFactory memoryPoolFactory = new MemoryPoolFactory(memorySegmentPool);
+        writer.withMemoryPoolFactory(memoryPoolFactory);
+        LOG.info("Paimon writer uses Doris-managed memory pool: limit={} bytes, pageSize={}",
+                memoryPoolFactory.totalBufferSize(), pageSize);
+
+        boolean writerSpillEnabled = coreOptions.writeBufferSpillable();
+        if (!writerSpillEnabled && bucketMode != BucketMode.KEY_DYNAMIC) {
+            return;
+        }
+
+        String[] splitDirectories = IOManagerImpl.splitPaths(spillDirectories);
+        for (String directory : splitDirectories) {
+            Files.createDirectories(Paths.get(directory));
+        }
+        ioManager = IOManager.create(splitDirectories);
+        if (writerSpillEnabled) {
+            writer.withIOManager(ioManager);
+        }
+        LOG.info("Paimon writer IOManager enabled: dirs={}, writerSpillEnabled={}",
+                spillDirectories, writerSpillEnabled);
+    }
+
+    private void openDynamicBucketAssigner(FileStoreTable table, String commitUser,
+            boolean overwrite, CoreOptions coreOptions, MemoryBudget memoryBudget) throws Exception {
+        switch (bucketMode) {
+            case HASH_DYNAMIC:
+                openHashDynamicBucketAssigner(table, commitUser, overwrite, coreOptions);
+                break;
+            case KEY_DYNAMIC:
+                openKeyDynamicBucketAssigner(table, overwrite, memoryBudget);
+                break;
+            default:
+                // Fixed, unaware and postpone modes route through TableWrite.write(row).
+                break;
+        }
+    }
+
+    private void openHashDynamicBucketAssigner(FileStoreTable table, String commitUser,
+            boolean overwrite, CoreOptions coreOptions) {
+        dynamicBucketExtractor = new RowPartitionKeyExtractor(table.schema());
+        if (overwrite) {
+            hashBucketAssigner =
+                    new SimpleHashBucketAssigner(
+                            1,
+                            0,
+                            coreOptions.dynamicBucketTargetRowNum(),
+                            coreOptions.dynamicBucketMaxBuckets());
+            return;
+        }
+
+        hashBucketAssigner =
+                new HashBucketAssigner(
+                        table.snapshotManager(),
+                        commitUser,
+                        table.store().newIndexFileHandler(),
+                        1,
+                        1,
+                        0,
+                        coreOptions.dynamicBucketTargetRowNum(),
+                        coreOptions.dynamicBucketMaxBuckets());
+    }
+
+    private void openKeyDynamicBucketAssigner(
+            FileStoreTable table, boolean overwrite, MemoryBudget memoryBudget) throws Exception {
+        if (ioManager == null) {
+            throw new IllegalStateException("Paimon key-dynamic writer requires an IOManager");
+        }
+        FileStoreTable indexTable = tableWithGlobalIndexMemoryLimits(table, memoryBudget);
+        globalIndexAssigner = new GlobalIndexAssigner(indexTable);
+        globalIndexAssigner.open(
+                memoryBudget.globalIndexLookupMemoryBytes,
+                null,
+                ioManager,
+                1,
+                0,
+                this::writeAssignedRow);
+        if (!overwrite) {
+            new IndexBootstrap(indexTable).bootstrap(
+                    1, 0, this::bootstrapGlobalIndexKey);
+        }
+        globalIndexAssigner.endBoostrap(false);
+    }
+
+    // ────────────────────────────────────────────────────────────
+    // Data writing
+    // ────────────────────────────────────────────────────────────
+
+    private void writeBatch(VectorSchemaRoot root) throws Exception {
+        int rowCount = root.getRowCount();
+        if (rowCount == 0) {
+            return;
+        }
+        // Convert and write one row at a time. Keeping only one row of boxed values
+        // avoids retaining a second, Object[][] representation of the full Arrow batch.
+        PaimonArrowConverter.RowReader rows =
+                arrowConverter.rows(root, writeSchema.targetTypes());
+        for (int r = 0; r < rowCount; r++) {
+            InternalRow row = writeSchema.tableRow(rows.values(r));
+            switch (bucketMode) {
+                case HASH_DYNAMIC:
+                    writeHashDynamicRow(row);
+                    break;
+                case KEY_DYNAMIC:
+                    globalIndexAssigner.processInput(row);
+                    break;
+                default:
+                    writeRow(row);
+                    break;
+            }
+        }
+    }
+
+    private void writeHashDynamicRow(InternalRow row) throws Exception {
+        int bucket =
+                hashBucketAssigner.assign(
+                        dynamicBucketExtractor.partition(row),
+                        dynamicBucketExtractor.trimmedPrimaryKey(row).hashCode());
+        writeRow(row, bucket);
+    }
+
+    private void writeAssignedRow(InternalRow row, Integer bucket) {
+        try {
+            writeRow(row, bucket);
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to write Paimon key-dynamic bucket row", e);
+        }
+    }
+
+    private void bootstrapGlobalIndexKey(InternalRow row) {
+        try {
+            globalIndexAssigner.bootstrapKey(row);
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to bootstrap Paimon key-dynamic index", e);
+        }
+    }
+
+    private void writeRow(InternalRow row) throws Exception {
+        if (!fullCompactionChangelog) {
+            writer.write(row);
+            return;
+        }
+
+        trackFullCompactionBucket(writer.writeAndReturn(row));
+    }
+
+    private void writeRow(InternalRow row, int bucket) throws Exception {
+        if (!fullCompactionChangelog) {
+            writer.write(row, bucket);
+            return;
+        }
+
+        trackFullCompactionBucket(writer.writeAndReturn(row, bucket));
+    }
+
+    private void trackFullCompactionBucket(SinkRecord sinkRecord) {
+        if (sinkRecord == null) {
+            return;
+        }
+        fullCompactionBuckets.add(
+                new PartitionBucket(
+                        sinkRecord.partition().copy(), sinkRecord.bucket()));
+    }
+
+    // ────────────────────────────────────────────────────────────
+    // Resource management
+    // ────────────────────────────────────────────────────────────
+
+    private void closeResources() throws Exception {
+        try {
+            closeWriter();
+        } finally {
+            writeSchema = null;
+            arrowConverter = null;
+            if (allocator != null) {
+                allocator.close();
+                allocator = null;
+            }
+        }
+    }
+
+    private List<CommitMessage> prepareCommitMessages() throws Exception {
+        if (writer == null) {
+            throw new IllegalStateException("Paimon writer is not open");
+        }
+        prepareDynamicBucketCommit();
+        submitFullCompaction();
+        List<CommitMessage> messages = commitIdentifier > 0
+                ? writer.prepareCommit(true, commitIdentifier)
+                : writer.prepareCommit();
+        preparedCommitMessages = new ArrayList<>(messages);
+        return messages;
+    }
+
+    private void prepareDynamicBucketCommit() throws Exception {
+        if (hashBucketAssigner != null) {
+            hashBucketAssigner.prepareCommit(commitIdentifier);
+        }
+    }
+
+    private void submitFullCompaction() throws Exception {
+        if (!fullCompactionChangelog || fullCompactionBuckets.isEmpty()) {
+            return;
+        }
+        LOG.info("PaimonJniWriter submitting full compaction for {} buckets",
+                fullCompactionBuckets.size());
+        Iterator<PartitionBucket> iterator = fullCompactionBuckets.iterator();
+        while (iterator.hasNext()) {
+            PartitionBucket partitionBucket = iterator.next();
+            writer.compact(partitionBucket.partition, partitionBucket.bucket, true);
+            iterator.remove();
+        }
+    }
+
+    private void closeWriter() throws Exception {
+        if (sdkCloseFailed) {
+            throw new IllegalStateException(
+                    "A previous Paimon SDK close failed; native memory cannot be released safely");
+        }
+        Exception failure = closeResource(writer, null);
+        failure = closeResource(globalIndexAssigner, failure);
+        failure = closeResource(ioManager, failure);
+        clearWriterState();
+        if (failure != null) {
+            sdkCloseFailed = true;
+            throw failure;
+        }
+    }
+
+    private static Exception closeResource(AutoCloseable resource, Exception previousFailure) {
+        if (resource == null) {
+            return previousFailure;
+        }
+        try {
+            resource.close();
+        } catch (Exception closeFailure) {
+            if (previousFailure == null) {
+                return closeFailure;
+            }
+            previousFailure.addSuppressed(closeFailure);
+        }
+        return previousFailure;
+    }
+
+    private void clearWriterState() {
+        writer = null;
+        table = null;
+        commitIdentifier = 0;
+        commitUser = null;
+        bucketMode = null;
+        hashBucketAssigner = null;
+        dynamicBucketExtractor = null;
+        globalIndexAssigner = null;
+        ioManager = null;
+        fullCompactionChangelog = false;
+        fullCompactionBuckets.clear();
+        preparedCommitMessages = Collections.emptyList();
+    }
+
+    private void abortWriter() throws Exception {
+        try {
+            List<CommitMessage> messages = preparedCommitMessages;
+            if (messages.isEmpty() && writer != null) {
+                messages = prepareCommitMessages();
+            }
+            if (!messages.isEmpty()) {
+                InnerTableCommit committer = table.newCommit(commitUser);
+                try {
+                    committer.abort(messages);
+                } finally {
+                    committer.close();
+                }
+            }
+        } finally {
+            closeWriter();
+        }
+    }
+
+    // ────────────────────────────────────────────────────────────
+    // Utilities
+    // ────────────────────────────────────────────────────────────
+
+    static native ByteBuffer allocatePaimonMemoryPage(long nativeMemoryManager, int bytes);
+
+    static final class MemoryBudget {
+        final long arrowMemoryBytes;
+        final long writerMemoryBytes;
+        final long globalIndexLookupMemoryBytes;
+        final long globalIndexWriteBufferBytes;
+
+        private MemoryBudget(
+                long arrowMemoryBytes,
+                long writerMemoryBytes,
+                long globalIndexLookupMemoryBytes,
+                long globalIndexWriteBufferBytes) {
+            this.arrowMemoryBytes = arrowMemoryBytes;
+            this.writerMemoryBytes = writerMemoryBytes;
+            this.globalIndexLookupMemoryBytes = globalIndexLookupMemoryBytes;
+            this.globalIndexWriteBufferBytes = globalIndexWriteBufferBytes;
+        }
+    }
+
+    private static class PartitionBucket {
+        private final BinaryRow partition;
+        private final int bucket;
+
+        private PartitionBucket(BinaryRow partition, int bucket) {
+            this.partition = partition;
+            this.bucket = bucket;
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            if (this == other) {
+                return true;
+            }
+            if (!(other instanceof PartitionBucket)) {
+                return false;
+            }
+            PartitionBucket that = (PartitionBucket) other;
+            return bucket == that.bucket && partition.equals(that.partition);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(partition, bucket);
+        }
+    }
+
+    /** InputStream over a direct ByteBuffer (no copy). */
+    private static class DirectBufInputStream extends InputStream {
+        private final ByteBuffer buf;
+
+        DirectBufInputStream(ByteBuffer buf) {
+            this.buf = buf;
+        }
+
+        @Override
+        public int read() {
+            if (buf.hasRemaining()) {
+                return buf.get() & 0xFF;
+            }
+            return -1;
+        }
+
+        @Override
+        public int read(byte[] b, int off, int len) {
+            if (!buf.hasRemaining()) {
+                return -1;
+            }
+            int n = Math.min(len, buf.remaining());
+            buf.get(b, off, n);
+            return n;
+        }
+    }
+}
diff --git a/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonWriteSchema.java b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonWriteSchema.java
new file mode 100644
index 00000000000000..127d96adb9e3a7
--- /dev/null
+++ b/fe/be-java-extensions/paimon-scanner/src/main/java/org/apache/doris/paimon/PaimonWriteSchema.java
@@ -0,0 +1,131 @@
+// 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.doris.paimon;
+
+import org.apache.paimon.data.GenericRow;
+import org.apache.paimon.types.DataField;
+import org.apache.paimon.types.DataType;
+import org.apache.paimon.types.RowType;
+import org.apache.paimon.utils.DefaultValueUtils;
+
+import java.util.Arrays;
+
+/**
+ * Immutable mapping from Doris input columns to a Paimon table row.
+ *
+ * <p>The input may contain a subset of table columns in a different order. This class
+ * resolves their types and table positions once, then converts each input row to the
+ * table-schema layout expected by the Paimon writer.
+ */
+final class PaimonWriteSchema {
+    private final DataType[] targetTypes;
+    /** Maps Doris input-column position → Paimon table-schema position. */
+    private final int[] tableFieldIndexes;
+    /** Paimon defaults for table fields omitted from the Doris input. */
+    private final int[] omittedDefaultFieldIndexes;
+    private final Object[] omittedDefaultValues;
+    private final int tableFieldCount;
+
+    private PaimonWriteSchema(DataType[] targetTypes, int[] tableFieldIndexes,
+            int[] omittedDefaultFieldIndexes, Object[] omittedDefaultValues, int tableFieldCount) {
+        this.targetTypes = targetTypes;
+        this.tableFieldIndexes = tableFieldIndexes;
+        this.omittedDefaultFieldIndexes = omittedDefaultFieldIndexes;
+        this.omittedDefaultValues = omittedDefaultValues;
+        this.tableFieldCount = tableFieldCount;
+    }
+
+    /**
+     * Create the write schema by resolving {@code columnNames} against the
+     * Paimon table schema.
+     *
+     * @param tableType   full Paimon table row type (all columns in table order)
+     * @param columnNames output column names from BE (in Doris output order)
+     * @return immutable schema metadata for this writer session
+     * @throws IllegalArgumentException if any column name is not found in the table schema
+     */
+    static PaimonWriteSchema create(RowType tableType, String[] columnNames) {
+        if (columnNames == null || columnNames.length == 0) {
+            throw new IllegalArgumentException(
+                    "PaimonJniWriter requires explicit column names");
+        }
+
+        DataType[] targetTypes = new DataType[columnNames.length];
+        int[] tableFieldIndexes = new int[columnNames.length];
+        boolean[] specifiedFields = new boolean[tableType.getFieldCount()];
+        for (int i = 0; i < columnNames.length; i++) {
+            int tableIndex = tableType.getFieldIndex(columnNames[i]);
+            if (tableIndex < 0) {
+                throw new IllegalArgumentException(
+                        "Paimon column '" + columnNames[i] + "' not found in table schema");
+            }
+            if (specifiedFields[tableIndex]) {
+                throw new IllegalArgumentException(
+                        "Duplicate Paimon write column '" + columnNames[i] + "'");
+            }
+            specifiedFields[tableIndex] = true;
+            DataField field = tableType.getFields().get(tableIndex);
+            targetTypes[i] = field.type();
+            tableFieldIndexes[i] = tableIndex;
+        }
+
+        int[] omittedDefaultFieldIndexes = new int[tableType.getFieldCount()];
+        Object[] omittedDefaultValues = new Object[tableType.getFieldCount()];
+        int omittedDefaultCount = 0;
+        for (int tableIndex = 0; tableIndex < tableType.getFieldCount(); tableIndex++) {
+            DataField field = tableType.getFields().get(tableIndex);
+            if (specifiedFields[tableIndex] || field.defaultValue() == null) {
+                continue;
+            }
+            omittedDefaultFieldIndexes[omittedDefaultCount] = tableIndex;
+            omittedDefaultValues[omittedDefaultCount] =
+                    DefaultValueUtils.convertDefaultValue(field.type(), field.defaultValue());
+            omittedDefaultCount++;
+        }
+
+        return new PaimonWriteSchema(
+                targetTypes,
+                tableFieldIndexes,
+                Arrays.copyOf(omittedDefaultFieldIndexes, omittedDefaultCount),
+                Arrays.copyOf(omittedDefaultValues, omittedDefaultCount),
+                tableType.getFieldCount());
+    }
+
+    /** Paimon {@link DataType}s for each write column, in write order. */
+    DataType[] targetTypes() {
+        return targetTypes;
+    }
+
+    /** Expand one input row to the full Paimon table-schema layout. */
+    GenericRow tableRow(Object[] columnValues) {
+        if (columnValues.length != tableFieldIndexes.length) {
+            throw new IllegalArgumentException(
+                    "Paimon input value count does not match write schema");
+        }
+        GenericRow row = new GenericRow(tableFieldCount);
+        for (int i = 0; i < omittedDefaultFieldIndexes.length; i++) {
+            row.setField(omittedDefaultFieldIndexes[i], omittedDefaultValues[i]);
+        }
+        for (int i = 0; i < tableFieldIndexes.length; i++) {
+            // Actual Doris input is applied last so an explicit NULL remains distinct
+            // from an omitted field and retains Paimon's writer-side semantics.
+            row.setField(tableFieldIndexes[i], columnValues[i]);
+        }
+        return row;
+    }
+}
diff --git a/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonArrowConverterTest.java b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonArrowConverterTest.java
new file mode 100644
index 00000000000000..6e60da77b16b1d
--- /dev/null
+++ b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonArrowConverterTest.java
@@ -0,0 +1,334 @@
+// 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.doris.paimon;
+
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.Float4Vector;
+import org.apache.arrow.vector.VarBinaryVector;
+import org.apache.arrow.vector.VarCharVector;
+import org.apache.arrow.vector.VectorSchemaRoot;
+import org.apache.arrow.vector.complex.ListVector;
+import org.apache.arrow.vector.complex.StructVector;
+import org.apache.arrow.vector.types.TimeUnit;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.FieldType;
+import org.apache.arrow.vector.types.pojo.Schema;
+import org.apache.paimon.data.Blob;
+import org.apache.paimon.data.InternalVector;
+import org.apache.paimon.data.Timestamp;
+import org.apache.paimon.data.variant.GenericVariant;
+import org.apache.paimon.types.BlobType;
+import org.apache.paimon.types.DataTypes;
+import org.apache.paimon.types.FloatType;
+import org.apache.paimon.types.LocalZonedTimestampType;
+import org.apache.paimon.types.RowType;
+import org.apache.paimon.types.TimestampType;
+import org.apache.paimon.types.VariantType;
+import org.apache.paimon.types.VectorType;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.util.Arrays;
+import java.util.Collections;
+
+public class PaimonArrowConverterTest {
+
+    @Test
+    public void testTimestampWithoutTimeZonePreservesDstGapWallClock() {
+        LocalDateTime wallClock = LocalDateTime.parse("2024-03-10T02:30:00.123456");
+        long micros = wallClock.toEpochSecond(ZoneOffset.UTC) * 1_000_000L
+                + wallClock.getNano() / 1_000L;
+        ArrowType.Timestamp arrowType = new ArrowType.Timestamp(
+                TimeUnit.MICROSECOND, null);
+
+        PaimonArrowConverter converter = new PaimonArrowConverter(
+                ZoneId.of("America/Los_Angeles"));
+        Timestamp result = converter.toPaimonTimestamp(
+                micros, arrowType, new TimestampType(6));
+
+        Assertions.assertEquals(
+                wallClock, result.toLocalDateTime());
+    }
+
+    @Test
+    public void testLocalZonedTimestampPreservesInstant() {
+        LocalDateTime wallClock = LocalDateTime.parse("2024-01-15T10:30:00.123456");
+        long civilMicros = wallClock.toEpochSecond(ZoneOffset.UTC) * 1_000_000L
+                + wallClock.getNano() / 1_000L;
+        ArrowType.Timestamp arrowType = new ArrowType.Timestamp(
+                TimeUnit.MICROSECOND, null);
+
+        PaimonArrowConverter converter = new PaimonArrowConverter(
+                ZoneId.of("Asia/Shanghai"));
+        Timestamp result = converter.toPaimonTimestamp(
+                civilMicros, arrowType, new LocalZonedTimestampType(6));
+
+        long expectedMicros = wallClock.toEpochSecond(ZoneOffset.ofHours(8)) * 1_000_000L
+                + wallClock.getNano() / 1_000L;
+        Assertions.assertEquals(expectedMicros, result.toMicros());
+        Assertions.assertEquals(expectedMicros,
+                converter.toPaimonTimestamp(
+                        wallClock, new LocalZonedTimestampType(6)).toMicros());
+    }
+
+    @Test
+    public void testPaimonWriteRejectsTimezoneInArrowType() {
+        PaimonArrowConverter converter = new PaimonArrowConverter(ZoneId.of("UTC"));
+        ArrowType.Timestamp arrowType = new ArrowType.Timestamp(
+                TimeUnit.MICROSECOND, "Asia/Shanghai");
+
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> converter.toPaimonTimestamp(
+                        0, arrowType, new TimestampType(6)));
+    }
+
+    @Test
+    public void testVariantJsonTransportIsRejected() {
+        Field variantField = new Field(
+                "payload", FieldType.nullable(new ArrowType.Utf8()), null);
+        try (RootAllocator allocator = new RootAllocator();
+                VectorSchemaRoot root = VectorSchemaRoot.create(
+                        new Schema(Collections.singletonList(variantField)), allocator)) {
+            VarCharVector vector = (VarCharVector) root.getVector("payload");
+            root.allocateNew();
+            vector.setSafe(0, "{\"legacy\":true}".getBytes(StandardCharsets.UTF_8));
+            root.setRowCount(1);
+
+            PaimonArrowConverter.RowReader rows =
+                    new PaimonArrowConverter(ZoneId.of("UTC")).rows(
+                            root, new org.apache.paimon.types.DataType[] {new VariantType()});
+            IllegalArgumentException exception = Assertions.assertThrows(
+                    IllegalArgumentException.class, () -> rows.values(0));
+            Assertions.assertTrue(exception.getCause().getMessage().contains(
+                    "only supports Variant V2"));
+        }
+    }
+
+    @Test
+    public void testVariantBinaryTransportPreservesValueAndMetadata() {
+        GenericVariant expected = GenericVariant.fromJson(
+                "{\"id\":1,\"nested\":[true,null,\"doris\"]}");
+        Field variantField = variantField();
+
+        try (RootAllocator allocator = new RootAllocator();
+                VectorSchemaRoot root = VectorSchemaRoot.create(
+                        new Schema(Collections.singletonList(variantField)), allocator)) {
+            StructVector vector = (StructVector) root.getVector("payload");
+            VarBinaryVector values = (VarBinaryVector) vector.getChild(
+                    PaimonArrowConverter.VARIANT_VALUE_FIELD);
+            VarBinaryVector metadata = (VarBinaryVector) vector.getChild(
+                    PaimonArrowConverter.VARIANT_METADATA_FIELD);
+            root.allocateNew();
+            values.setSafe(0, expected.value());
+            metadata.setSafe(0, expected.metadata());
+            vector.setIndexDefined(0);
+            vector.setNull(1);
+            root.setRowCount(2);
+
+            PaimonArrowConverter converter = new PaimonArrowConverter(ZoneId.of("UTC"));
+            PaimonArrowConverter.RowReader rows = converter.rows(
+                    root, new org.apache.paimon.types.DataType[] {new VariantType()});
+            GenericVariant actual = (GenericVariant) rows.values(0)[0];
+
+            Assertions.assertArrayEquals(expected.value(), actual.value());
+            Assertions.assertArrayEquals(expected.metadata(), actual.metadata());
+            Assertions.assertNull(rows.values(1)[0]);
+        }
+    }
+
+    @Test
+    public void testVariantBinaryTransportReliesOnBeValidation() {
+        GenericVariant array = GenericVariant.fromJson("[0]");
+        byte[] unsupportedValue = array.value().clone();
+        int primitiveHeaderOffset = unsupportedValue.length - 2;
+        // This unit test constructs Arrow directly and therefore bypasses the BE compatibility
+        // check. The Java boundary intentionally remains allocation-only instead of repeating it.
+        // Replace INT1 (id 3) with TIME_NTZ_MICROS (id 17) to prove no second traversal occurs.
+        Assertions.assertEquals(3 << 2, unsupportedValue[primitiveHeaderOffset] & 0xff);
+        unsupportedValue[primitiveHeaderOffset] = (byte) (17 << 2);
+
+        try (RootAllocator allocator = new RootAllocator();
+                VectorSchemaRoot root = VectorSchemaRoot.create(
+                        new Schema(Collections.singletonList(variantField())), allocator)) {
+            StructVector vector = (StructVector) root.getVector("payload");
+            VarBinaryVector values = (VarBinaryVector) vector.getChild(
+                    PaimonArrowConverter.VARIANT_VALUE_FIELD);
+            VarBinaryVector metadata = (VarBinaryVector) vector.getChild(
+                    PaimonArrowConverter.VARIANT_METADATA_FIELD);
+            root.allocateNew();
+            values.setSafe(0, unsupportedValue);
+            metadata.setSafe(0, array.metadata());
+            vector.setIndexDefined(0);
+            root.setRowCount(1);
+
+            PaimonArrowConverter.RowReader rows =
+                    new PaimonArrowConverter(ZoneId.of("UTC")).rows(
+                            root, new org.apache.paimon.types.DataType[] {new VariantType()});
+            GenericVariant actual = (GenericVariant) rows.values(0)[0];
+            Assertions.assertArrayEquals(unsupportedValue, actual.value());
+            Assertions.assertArrayEquals(array.metadata(), actual.metadata());
+        }
+    }
+
+    @Test
+    public void testVariantBinaryTransportRejectsMissingMetadata() {
+        Field variantField = new Field(
+                "payload",
+                FieldType.nullable(new ArrowType.Struct()),
+                Arrays.asList(
+                        new Field("value", FieldType.nullable(new ArrowType.Binary()), null),
+                        new Field("metadata", FieldType.nullable(new ArrowType.Binary()), null)));
+        try (RootAllocator allocator = new RootAllocator();
+                VectorSchemaRoot root = VectorSchemaRoot.create(
+                        new Schema(Collections.singletonList(variantField)), allocator)) {
+            StructVector vector = (StructVector) root.getVector("payload");
+            VarBinaryVector values = (VarBinaryVector) vector.getChild("value");
+            root.allocateNew();
+            values.setSafe(0, GenericVariant.fromJson("1").value());
+            vector.setIndexDefined(0);
+            root.setRowCount(1);
+
+            PaimonArrowConverter.RowReader rows =
+                    new PaimonArrowConverter(ZoneId.of("UTC")).rows(
+                            root, new org.apache.paimon.types.DataType[] {new VariantType()});
+            IllegalArgumentException exception = Assertions.assertThrows(
+                    IllegalArgumentException.class, () -> rows.values(0));
+            Assertions.assertTrue(exception.getMessage().contains("payload"));
+            Assertions.assertTrue(exception.getCause().getMessage().contains("metadata"));
+        }
+    }
+
+    @Test
+    public void testBlobBinaryTransportCreatesPaimonBlob() {
+        Field blobField = new Field(
+                "payload", FieldType.nullable(new ArrowType.Binary()), null);
+        byte[] expected = new byte[] {0, 1, 2, (byte) 0xff};
+        try (RootAllocator allocator = new RootAllocator();
+                VectorSchemaRoot root = VectorSchemaRoot.create(
+                        new Schema(Collections.singletonList(blobField)), allocator)) {
+            VarBinaryVector vector = (VarBinaryVector) root.getVector("payload");
+            root.allocateNew();
+            vector.setSafe(0, expected);
+            root.setRowCount(1);
+
+            PaimonArrowConverter.RowReader rows =
+                    new PaimonArrowConverter(ZoneId.of("UTC")).rows(
+                            root, new org.apache.paimon.types.DataType[] {new BlobType()});
+            Blob actual = (Blob) rows.values(0)[0];
+            Assertions.assertArrayEquals(expected, actual.toData());
+        }
+    }
+
+    @Test
+    public void testVectorListTransportCreatesDenseFixedVector() {
+        Field vectorField = vectorField();
+        try (RootAllocator allocator = new RootAllocator();
+                VectorSchemaRoot root = VectorSchemaRoot.create(
+                        new Schema(Collections.singletonList(vectorField)), allocator)) {
+            ListVector vector = (ListVector) root.getVector("embedding");
+            Float4Vector elements = (Float4Vector) vector.getDataVector();
+            root.allocateNew();
+            vector.startNewValue(0);
+            elements.setSafe(0, 1.5f);
+            elements.setSafe(1, -2.0f);
+            elements.setSafe(2, 3.25f);
+            vector.endValue(0, 3);
+            root.setRowCount(1);
+
+            PaimonArrowConverter.RowReader rows =
+                    new PaimonArrowConverter(ZoneId.of("UTC")).rows(
+                            root, new org.apache.paimon.types.DataType[] {
+                                    new VectorType(3, new FloatType(false))});
+            InternalVector actual = (InternalVector) rows.values(0)[0];
+            Assertions.assertArrayEquals(
+                    new float[] {1.5f, -2.0f, 3.25f}, actual.toFloatArray());
+        }
+    }
+
+    @Test
+    public void testVectorTransportRejectsWrongDimension() {
+        Field vectorField = vectorField();
+        try (RootAllocator allocator = new RootAllocator();
+                VectorSchemaRoot root = VectorSchemaRoot.create(
+                        new Schema(Collections.singletonList(vectorField)), allocator)) {
+            ListVector vector = (ListVector) root.getVector("embedding");
+            Float4Vector elements = (Float4Vector) vector.getDataVector();
+            root.allocateNew();
+            vector.startNewValue(0);
+            elements.setSafe(0, 1.0f);
+            elements.setSafe(1, 2.0f);
+            vector.endValue(0, 2);
+            root.setRowCount(1);
+
+            PaimonArrowConverter.RowReader rows =
+                    new PaimonArrowConverter(ZoneId.of("UTC")).rows(
+                            root, new org.apache.paimon.types.DataType[] {
+                                    new VectorType(3, new FloatType(false))});
+            IllegalArgumentException exception = Assertions.assertThrows(
+                    IllegalArgumentException.class, () -> rows.values(0));
+            Assertions.assertTrue(exception.getCause().getMessage().contains("requires 3 elements"));
+        }
+    }
+
+    @Test
+    public void testStructSchemaUsesPositionAndAcceptsCaseInsensitiveNames() {
+        RowType rowType = mixedCaseRowType();
+        Assertions.assertDoesNotThrow(() -> PaimonArrowConverter.validateStructSchema(
+                rowType, Arrays.asList("foo", "FOO")));
+        Assertions.assertThrows(IllegalArgumentException.class,
+                () -> PaimonArrowConverter.validateStructSchema(
+                        rowType, Arrays.asList("foo", "different")));
+    }
+
+    private static RowType mixedCaseRowType() {
+        return DataTypes.ROW(
+                DataTypes.FIELD(0, "Foo", DataTypes.INT()),
+                DataTypes.FIELD(1, "foo", DataTypes.INT()));
+    }
+
+    private static Field variantField() {
+        return new Field(
+                "payload",
+                FieldType.nullable(new ArrowType.Struct()),
+                Arrays.asList(
+                        new Field(
+                                PaimonArrowConverter.VARIANT_VALUE_FIELD,
+                                FieldType.notNullable(new ArrowType.Binary()),
+                                null),
+                        new Field(
+                                PaimonArrowConverter.VARIANT_METADATA_FIELD,
+                                FieldType.notNullable(new ArrowType.Binary()),
+                                null)));
+    }
+
+    private static Field vectorField() {
+        return new Field(
+                "embedding",
+                FieldType.nullable(new ArrowType.List()),
+                Collections.singletonList(new Field(
+                        "element",
+                        FieldType.notNullable(new ArrowType.FloatingPoint(
+                                org.apache.arrow.vector.types.FloatingPointPrecision.SINGLE)),
+                        null)));
+    }
+}
diff --git a/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonColumnValueTest.java b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonColumnValueTest.java
index 20062ff2f6e58a..a6060517cdffde 100644
--- a/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonColumnValueTest.java
+++ b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonColumnValueTest.java
@@ -21,14 +21,18 @@
 import org.apache.doris.common.jni.vec.ColumnValue;
 
 import org.apache.paimon.data.BinaryString;
+import org.apache.paimon.data.BinaryVector;
+import org.apache.paimon.data.Blob;
 import org.apache.paimon.data.GenericArray;
 import org.apache.paimon.data.GenericMap;
 import org.apache.paimon.data.GenericRow;
 import org.apache.paimon.data.InternalRow;
 import org.apache.paimon.data.Timestamp;
 import org.apache.paimon.data.serializer.InternalRowSerializer;
+import org.apache.paimon.data.variant.GenericVariant;
 import org.apache.paimon.types.ArrayType;
 import org.apache.paimon.types.BigIntType;
+import org.apache.paimon.types.BlobType;
 import org.apache.paimon.types.DataType;
 import org.apache.paimon.types.IntType;
 import org.apache.paimon.types.LocalZonedTimestampType;
@@ -36,6 +40,8 @@
 import org.apache.paimon.types.RowType;
 import org.apache.paimon.types.TimestampType;
 import org.apache.paimon.types.VarCharType;
+import org.apache.paimon.types.VariantType;
+import org.apache.paimon.types.VectorType;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -240,6 +246,47 @@ public void testTimestampConversionsPreserveBoundaryValues() {
                 localZonedValue.getDateTime());
     }
 
+    @Test
+    public void testBlobReturnsMaterializedBytes() {
+        byte[] expected = new byte[] {0, 1, 2, (byte) 0xff};
+        PaimonColumnValue blobValue = new PaimonColumnValue(
+                GenericRow.of(Blob.fromData(expected)), 0,
+                ColumnType.parseType("payload", "varbinary"), new BlobType(), "UTC");
+
+        Assert.assertArrayEquals(expected, blobValue.getBytes());
+    }
+
+    @Test
+    public void testVectorUnpacksDenseElements() {
+        PaimonColumnValue vectorValue = new PaimonColumnValue(
+                GenericRow.of(BinaryVector.fromPrimitiveArray(new float[] {1.5f, -2.0f, 3.25f})), 0,
+                ColumnType.parseType("embedding", "array<float>"),
+                new VectorType(3, new org.apache.paimon.types.FloatType(false)), "UTC");
+        List<ColumnValue> values = new ArrayList<>();
+
+        vectorValue.unpackArray(values);
+
+        Assert.assertEquals(3, values.size());
+        Assert.assertEquals(1.5f, values.get(0).getFloat(), 0.0f);
+        Assert.assertEquals(-2.0f, values.get(1).getFloat(), 0.0f);
+        Assert.assertEquals(3.25f, values.get(2).getFloat(), 0.0f);
+    }
+
+    @Test
+    public void testVariantUnpacksLosslessBinaryChildren() {
+        GenericVariant variant = GenericVariant.fromJson("{\"id\":7,\"tags\":[\"doris\"]}");
+        PaimonColumnValue variantValue = new PaimonColumnValue(
+                GenericRow.of(variant), 0,
+                ColumnType.parseType("payload", "struct<value:varbinary,metadata:varbinary>"),
+                new VariantType(), "UTC");
+        List<ColumnValue> values = new ArrayList<>();
+
+        variantValue.unpackStruct(Arrays.asList(0, 1), values);
+
+        Assert.assertArrayEquals(variant.value(), values.get(0).getBytes());
+        Assert.assertArrayEquals(variant.metadata(), values.get(1).getBytes());
+    }
+
     private InternalRow nestedArrayRow(int outerSize, int innerSize, int populatedIndex, int nullIndex) {
         Object[] outerValues = new Object[outerSize];
         for (int i = 0; i < outerSize; i++) {
diff --git a/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonCommitCodecTest.java b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonCommitCodecTest.java
new file mode 100644
index 00000000000000..427f226817a716
--- /dev/null
+++ b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonCommitCodecTest.java
@@ -0,0 +1,149 @@
+// 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.doris.paimon;
+
+import org.apache.paimon.data.BinaryRow;
+import org.apache.paimon.io.CompactIncrement;
+import org.apache.paimon.io.DataFileMeta;
+import org.apache.paimon.io.DataIncrement;
+import org.apache.paimon.io.DataInputDeserializer;
+import org.apache.paimon.stats.SimpleStats;
+import org.apache.paimon.table.sink.CommitMessage;
+import org.apache.paimon.table.sink.CommitMessageImpl;
+import org.apache.paimon.table.sink.CommitMessageSerializer;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class PaimonCommitCodecTest {
+
+    @Test
+    public void testFrameContainsMagicVersionAndLength() {
+        byte[] data = new byte[] {1, 2, 3};
+
+        byte[] payload = PaimonCommitCodec.frame(data, 7);
+
+        Assertions.assertArrayEquals(new byte[] {'D', 'P', 'C', 'M'},
+                new byte[] {payload[0], payload[1], payload[2], payload[3]});
+        Assertions.assertEquals(7, ByteBuffer.wrap(payload, 4, 4).getInt());
+        Assertions.assertEquals(data.length, ByteBuffer.wrap(payload, 8, 4).getInt());
+        Assertions.assertArrayEquals(data,
+                java.util.Arrays.copyOfRange(payload, PaimonCommitCodec.HEADER_BYTES, payload.length));
+    }
+
+    @Test
+    public void testEncodeEmptyMessages() throws Exception {
+        PaimonCommitCodec codec = new PaimonCommitCodec();
+
+        Assertions.assertEquals(0, codec.encode(Collections.emptyList()).length);
+    }
+
+    @Test
+    public void testRejectOversizedSinglePayload() {
+        PaimonCommitCodec codec = new PaimonCommitCodec(1024, 1);
+
+        Exception exception = Assertions.assertThrows(
+                Exception.class,
+                () -> codec.encode(Collections.singletonList(
+                        commitMessage("x".repeat(2048)))));
+
+        Assertions.assertTrue(exception.getMessage().contains("exceeds"));
+    }
+
+    @Test
+    public void testAdaptiveChunkingStaysWithinFramedLimit() throws Exception {
+        PaimonCommitCodec codec = new PaimonCommitCodec(1024, 2);
+        List<CommitMessage> messages = new ArrayList<>();
+        messages.add(commitMessage("x".repeat(400)));
+        messages.add(commitMessage("y".repeat(400)));
+
+        byte[][] payloads = codec.encode(messages);
+
+        Assertions.assertEquals(2, payloads.length);
+        Assertions.assertTrue(payloads[0].length <= 1024);
+        Assertions.assertTrue(payloads[1].length <= 1024);
+    }
+
+    @Test
+    public void testEncodedMessageRoundTripsWithPaimonSerializer() throws Exception {
+        CommitMessage expected = commitMessage("data-file");
+        byte[] payload = new PaimonCommitCodec().encode(Collections.singletonList(expected))[0];
+        int version = ByteBuffer.wrap(payload, 4, 4).getInt();
+        int length = ByteBuffer.wrap(payload, 8, 4).getInt();
+        byte[] serialized = java.util.Arrays.copyOfRange(
+                payload, PaimonCommitCodec.HEADER_BYTES, payload.length);
+
+        List<CommitMessage> decoded = new CommitMessageSerializer()
+                .deserializeList(version, new DataInputDeserializer(serialized));
+
+        Assertions.assertEquals(serialized.length, length);
+        Assertions.assertEquals(Collections.singletonList(expected), decoded);
+    }
+
+    @Test
+    public void testCodecRoundTrip() throws Exception {
+        CommitMessage expected = commitMessage("data-file");
+        PaimonCommitCodec codec = new PaimonCommitCodec();
+
+        List<CommitMessage> decoded = codec.decode(
+                codec.encode(Collections.singletonList(expected)));
+
+        Assertions.assertEquals(Collections.singletonList(expected), decoded);
+    }
+
+    @Test
+    public void testDecodeRejectsMalformedFrame() {
+        PaimonCommitCodec codec = new PaimonCommitCodec();
+
+        Assertions.assertThrows(Exception.class,
+                () -> codec.decode(new byte[][] {new byte[] {'D', 'P', 'C', 'M'}}));
+        Assertions.assertThrows(Exception.class,
+                () -> codec.decode(new byte[][] {PaimonCommitCodec.frame(new byte[0], 1)}));
+    }
+
+    private static CommitMessage commitMessage(String fileName) {
+        DataFileMeta dataFile = DataFileMeta.forAppend(
+                fileName,
+                1,
+                1,
+                SimpleStats.EMPTY_STATS,
+                0,
+                0,
+                0,
+                Collections.emptyList(),
+                null,
+                null,
+                null,
+                null,
+                null,
+                null);
+        return new CommitMessageImpl(
+                BinaryRow.EMPTY_ROW,
+                0,
+                1,
+                new DataIncrement(
+                        Collections.singletonList(dataFile),
+                        Collections.emptyList(),
+                        Collections.emptyList()),
+                CompactIncrement.emptyIncrement());
+    }
+}
diff --git a/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniScannerTest.java b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniScannerTest.java
index c72c863d8f3750..54e403a74b7f5e 100644
--- a/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniScannerTest.java
+++ b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniScannerTest.java
@@ -862,6 +862,11 @@ public String[] tempDirs() {
             return tempDirs;
         }
 
+        @Override
+        public String pickTempDir() {
+            return tempDirs[0];
+        }
+
         @Override
         public FileIOChannel.Enumerator createChannelEnumerator() {
             throw new UnsupportedOperationException();
diff --git a/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniWriterTest.java b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniWriterTest.java
new file mode 100644
index 00000000000000..c5ea1cc2756eab
--- /dev/null
+++ b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonJniWriterTest.java
@@ -0,0 +1,195 @@
+// 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.doris.paimon;
+
+import org.apache.paimon.data.GenericRow;
+import org.apache.paimon.fs.local.LocalFileIO;
+import org.apache.paimon.schema.Schema;
+import org.apache.paimon.schema.SchemaManager;
+import org.apache.paimon.table.BucketMode;
+import org.apache.paimon.table.FileStoreTable;
+import org.apache.paimon.table.FileStoreTableFactory;
+import org.apache.paimon.table.sink.CommitMessage;
+import org.apache.paimon.table.sink.TableWriteImpl;
+import org.apache.paimon.types.DataTypes;
+import org.apache.paimon.utils.InstantiationUtil;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Base64;
+import java.util.Collections;
+import java.util.List;
+
+public class PaimonJniWriterTest {
+
+    @Test
+    public void testAbortPreparedCommitAfterWriterClose(@TempDir Path tableDirectory)
+            throws Exception {
+        org.apache.paimon.fs.Path tablePath =
+                new org.apache.paimon.fs.Path(tableDirectory.toUri());
+        LocalFileIO fileIO = LocalFileIO.create();
+        new SchemaManager(fileIO, tablePath).createTable(Schema.newBuilder()
+                .column("id", DataTypes.INT())
+                .build());
+        FileStoreTable table = FileStoreTableFactory.create(fileIO, tablePath);
+        String commitUser = "doris-report-reject-test";
+        List<CommitMessage> messages;
+        try (TableWriteImpl<?> writer = table.newWrite(commitUser)) {
+            writer.write(GenericRow.of(1));
+            messages = writer.prepareCommit(true, 31L);
+        }
+        byte[][] payloads = new PaimonCommitCodec().encode(messages);
+        long filesBeforeAbort = regularFileCount(tableDirectory);
+        String serializedTable = Base64.getEncoder().encodeToString(
+                InstantiationUtil.serializeObject(table));
+
+        PaimonJniWriter.abortPreparedCommit(
+                serializedTable, Collections.emptyMap(), commitUser, payloads);
+
+        Assertions.assertTrue(filesBeforeAbort > regularFileCount(tableDirectory));
+    }
+
+    @Test
+    public void testMemoryBudgetForFixedBucketTable() {
+        long total = 64L * 1024 * 1024;
+        int pageSize = 64 * 1024;
+        PaimonJniWriter.MemoryBudget budget =
+                PaimonJniWriter.createMemoryBudget(total, pageSize, BucketMode.HASH_FIXED);
+
+        Assertions.assertEquals(total, budget.arrowMemoryBytes + budget.writerMemoryBytes);
+        Assertions.assertEquals(0, budget.writerMemoryBytes % pageSize);
+        Assertions.assertTrue(budget.arrowMemoryBytes > 0);
+        Assertions.assertTrue(budget.writerMemoryBytes >= pageSize);
+        Assertions.assertEquals(0, budget.globalIndexLookupMemoryBytes);
+        Assertions.assertEquals(0, budget.globalIndexWriteBufferBytes);
+    }
+
+    @Test
+    public void testMemoryBudgetForKeyDynamicTable() {
+        long total = 64L * 1024 * 1024;
+        int pageSize = 64 * 1024;
+        PaimonJniWriter.MemoryBudget budget =
+                PaimonJniWriter.createMemoryBudget(total, pageSize, BucketMode.KEY_DYNAMIC);
+
+        Assertions.assertEquals(
+                total,
+                budget.arrowMemoryBytes
+                        + budget.writerMemoryBytes
+                        + budget.globalIndexLookupMemoryBytes
+                        + budget.globalIndexWriteBufferBytes);
+        Assertions.assertEquals(0, budget.writerMemoryBytes % pageSize);
+        Assertions.assertEquals(0, budget.globalIndexWriteBufferBytes % pageSize);
+        Assertions.assertTrue(budget.arrowMemoryBytes > 0);
+        Assertions.assertTrue(budget.writerMemoryBytes >= pageSize);
+        Assertions.assertTrue(budget.globalIndexLookupMemoryBytes > 0);
+        Assertions.assertTrue(budget.globalIndexWriteBufferBytes >= 2L * pageSize);
+    }
+
+    @Test
+    public void testMemoryBudgetRejectsInsufficientCapacity() {
+        int pageSize = 64 * 1024;
+        Assertions.assertThrows(
+                IllegalArgumentException.class,
+                () -> PaimonJniWriter.createMemoryBudget(
+                        2L * pageSize, pageSize, BucketMode.KEY_DYNAMIC));
+    }
+
+    @Test
+    public void testManagedMemoryPoolRequiresAtLeastOnePage() {
+        IllegalArgumentException exception = Assertions.assertThrows(
+                IllegalArgumentException.class,
+                () -> new DorisMemorySegmentPool(32 * 1024, 64 * 1024, 1L));
+        Assertions.assertTrue(exception.getMessage().contains("at least one page"));
+    }
+
+    @Test
+    public void testOpenFailureRestoresContextClassLoader() throws Exception {
+        Thread thread = Thread.currentThread();
+        ClassLoader originalClassLoader = thread.getContextClassLoader();
+        URLClassLoader testClassLoader = new URLClassLoader(new URL[0], originalClassLoader);
+        PaimonJniWriter writer = new PaimonJniWriter();
+        thread.setContextClassLoader(testClassLoader);
+        try {
+            Assertions.assertThrows(Exception.class, () -> writer.open(
+                    "not-a-serialized-table", Collections.emptyMap(), new String[0],
+                    1L, "test-user", false, "UTC", System.getProperty("java.io.tmpdir"),
+                    64L * 1024 * 1024, 1L));
+            Assertions.assertSame(testClassLoader, thread.getContextClassLoader());
+        } finally {
+            try {
+                writer.close();
+                Assertions.assertSame(testClassLoader, thread.getContextClassLoader());
+            } finally {
+                thread.setContextClassLoader(originalClassLoader);
+                testClassLoader.close();
+            }
+        }
+    }
+
+    @Test
+    public void testAbortRestoresContextClassLoader() throws Exception {
+        Thread thread = Thread.currentThread();
+        ClassLoader originalClassLoader = thread.getContextClassLoader();
+        URLClassLoader testClassLoader = new URLClassLoader(new URL[0], originalClassLoader);
+        PaimonJniWriter writer = new PaimonJniWriter();
+        thread.setContextClassLoader(testClassLoader);
+        try {
+            writer.abort();
+            Assertions.assertSame(testClassLoader, thread.getContextClassLoader());
+        } finally {
+            try {
+                writer.close();
+            } finally {
+                thread.setContextClassLoader(originalClassLoader);
+                testClassLoader.close();
+            }
+        }
+    }
+
+    @Test
+    public void testDataEntryPointFailuresRestoreContextClassLoader() throws Exception {
+        Thread thread = Thread.currentThread();
+        ClassLoader originalClassLoader = thread.getContextClassLoader();
+        URLClassLoader testClassLoader = new URLClassLoader(new URL[0], originalClassLoader);
+        PaimonJniWriter writer = new PaimonJniWriter();
+        thread.setContextClassLoader(testClassLoader);
+        try {
+            Assertions.assertThrows(Exception.class,
+                    () -> writer.write(ByteBuffer.allocateDirect(0)));
+            Assertions.assertSame(testClassLoader, thread.getContextClassLoader());
+
+            Assertions.assertThrows(Exception.class, writer::prepareCommit);
+            Assertions.assertSame(testClassLoader, thread.getContextClassLoader());
+        } finally {
+            thread.setContextClassLoader(originalClassLoader);
+            testClassLoader.close();
+        }
+    }
+
+    private static long regularFileCount(Path directory) throws Exception {
+        try (java.util.stream.Stream<Path> paths = Files.walk(directory)) {
+            return paths.filter(Files::isRegularFile).count();
+        }
+    }
+}
diff --git a/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonWriteSchemaTest.java b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonWriteSchemaTest.java
new file mode 100644
index 00000000000000..e7136ff6960631
--- /dev/null
+++ b/fe/be-java-extensions/paimon-scanner/src/test/java/org/apache/doris/paimon/PaimonWriteSchemaTest.java
@@ -0,0 +1,200 @@
+// 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.doris.paimon;
+
+import org.apache.paimon.data.BinaryString;
+import org.apache.paimon.data.InternalArray;
+import org.apache.paimon.data.InternalMap;
+import org.apache.paimon.data.InternalRow;
+import org.apache.paimon.types.DataField;
+import org.apache.paimon.types.DataTypes;
+import org.apache.paimon.types.DoubleType;
+import org.apache.paimon.types.IntType;
+import org.apache.paimon.types.RowType;
+import org.apache.paimon.types.VarCharType;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+public class PaimonWriteSchemaTest {
+
+    @Test
+    public void testReorderedInputProducesTableSchemaRow() {
+        PaimonWriteSchema schema = PaimonWriteSchema.create(tableType(),
+                new String[] {"region", "score", "name", "id"});
+        Object[] values = new Object[] {
+                BinaryString.fromString("south"),
+                86.5D,
+                BinaryString.fromString("erin"),
+                5
+        };
+
+        InternalRow tableRow = schema.tableRow(values);
+
+        Assertions.assertEquals(5, tableRow.getInt(0));
+        Assertions.assertEquals("erin", tableRow.getString(1).toString());
+        Assertions.assertEquals(86.5D, tableRow.getDouble(2));
+        Assertions.assertEquals("south", tableRow.getString(3).toString());
+    }
+
+    @Test
+    public void testPartialInputLeavesMissingTableFieldsNull() {
+        PaimonWriteSchema schema = PaimonWriteSchema.create(tableType(),
+                new String[] {"region", "id"});
+        Object[] values = new Object[] {
+                BinaryString.fromString("east"),
+                6
+        };
+
+        InternalRow tableRow = schema.tableRow(values);
+
+        Assertions.assertEquals(6, tableRow.getInt(0));
+        Assertions.assertTrue(tableRow.isNullAt(1));
+        Assertions.assertTrue(tableRow.isNullAt(2));
+        Assertions.assertEquals("east", tableRow.getString(3).toString());
+    }
+
+    @Test
+    public void testUnknownColumnRejectedDuringInitialization() {
+        IllegalArgumentException exception = Assertions.assertThrows(
+                IllegalArgumentException.class,
+                () -> PaimonWriteSchema.create(tableType(), new String[] {"unknown"}));
+
+        Assertions.assertTrue(exception.getMessage().contains("unknown"));
+    }
+
+    @Test
+    public void testOmittedNotNullDefaultIsAppliedBeforeTableWriter() {
+        RowType tableType = new RowType(Arrays.asList(
+                new DataField(0, "id", new IntType()),
+                new DataField(1, "name", new VarCharType(false, VarCharType.MAX_LENGTH),
+                        null, "unknown")));
+        PaimonWriteSchema schema = PaimonWriteSchema.create(tableType, new String[] {"id"});
+
+        InternalRow tableRow = schema.tableRow(new Object[] {7});
+
+        Assertions.assertEquals(7, tableRow.getInt(0));
+        Assertions.assertEquals("unknown", tableRow.getString(1).toString());
+    }
+
+    @Test
+    public void testOmittedNotNullWithoutDefaultIsLeftForTableWriterValidation() {
+        RowType tableType = new RowType(Arrays.asList(
+                new DataField(0, "id", new IntType()),
+                new DataField(1, "name", DataTypes.STRING().notNull())));
+        PaimonWriteSchema schema = PaimonWriteSchema.create(tableType, new String[] {"id"});
+
+        InternalRow tableRow = schema.tableRow(new Object[] {7});
+
+        Assertions.assertEquals(7, tableRow.getInt(0));
+        Assertions.assertTrue(tableRow.isNullAt(1));
+    }
+
+    @Test
+    public void testReorderedInputOverridesDefaultsWhileOmittedFieldUsesDefault() {
+        RowType tableType = new RowType(Arrays.asList(
+                new DataField(0, "id", new IntType()),
+                new DataField(1, "name", DataTypes.STRING(), null, "unknown"),
+                new DataField(2, "score", new DoubleType()),
+                new DataField(3, "region", DataTypes.STRING(), null, "north")));
+        PaimonWriteSchema schema = PaimonWriteSchema.create(tableType,
+                new String[] {"region", "score", "id"});
+
+        InternalRow tableRow = schema.tableRow(new Object[] {
+                BinaryString.fromString("south"),
+                92.5D,
+                8
+        });
+
+        Assertions.assertEquals(8, tableRow.getInt(0));
+        Assertions.assertEquals("unknown", tableRow.getString(1).toString());
+        Assertions.assertEquals(92.5D, tableRow.getDouble(2));
+        Assertions.assertEquals("south", tableRow.getString(3).toString());
+    }
+
+    @Test
+    public void testExplicitNullIsNotReplacedByOmittedFieldDefault() {
+        RowType tableType = new RowType(Arrays.asList(
+                new DataField(0, "id", new IntType()),
+                new DataField(1, "name", DataTypes.STRING(), null, "unknown")));
+        PaimonWriteSchema schema = PaimonWriteSchema.create(tableType,
+                new String[] {"name", "id"});
+
+        InternalRow tableRow = schema.tableRow(new Object[] {
+                null,
+                9
+        });
+
+        Assertions.assertEquals(9, tableRow.getInt(0));
+        Assertions.assertTrue(tableRow.isNullAt(1));
+    }
+
+    @Test
+    public void testOmittedComplexDefaultsUsePaimonInternalValues() {
+        RowType nestedType = RowType.of(DataTypes.INT(), DataTypes.STRING());
+        RowType tableType = new RowType(Arrays.asList(
+                new DataField(0, "id", DataTypes.INT()),
+                new DataField(1, "numbers", DataTypes.ARRAY(DataTypes.INT()), null, "[1, 2, 3]"),
+                new DataField(2, "properties",
+                        DataTypes.MAP(DataTypes.STRING(), DataTypes.INT()), null, "{one -> 1, two -> 2}"),
+                new DataField(3, "nested", nestedType, null, "{42, default-value}")));
+        PaimonWriteSchema schema = PaimonWriteSchema.create(tableType, new String[] {"id"});
+
+        InternalRow tableRow = schema.tableRow(new Object[] {10});
+
+        InternalArray numbers = tableRow.getArray(1);
+        Assertions.assertEquals(3, numbers.size());
+        Assertions.assertEquals(1, numbers.getInt(0));
+        Assertions.assertEquals(3, numbers.getInt(2));
+
+        InternalMap properties = tableRow.getMap(2);
+        Assertions.assertEquals(2, properties.size());
+        Map<String, Integer> actualProperties = new HashMap<>();
+        for (int i = 0; i < properties.size(); i++) {
+            actualProperties.put(
+                    properties.keyArray().getString(i).toString(),
+                    properties.valueArray().getInt(i));
+        }
+        Assertions.assertEquals(1, actualProperties.get("one"));
+        Assertions.assertEquals(2, actualProperties.get("two"));
+
+        InternalRow nested = tableRow.getRow(3, 2);
+        Assertions.assertEquals(42, nested.getInt(0));
+        Assertions.assertEquals("default-value", nested.getString(1).toString());
+    }
+
+    @Test
+    public void testDuplicateColumnRejectedDuringInitialization() {
+        IllegalArgumentException exception = Assertions.assertThrows(
+                IllegalArgumentException.class,
+                () -> PaimonWriteSchema.create(tableType(), new String[] {"id", "id"}));
+
+        Assertions.assertTrue(exception.getMessage().contains("Duplicate"));
+    }
+
+    private static RowType tableType() {
+        return new RowType(Arrays.asList(
+                new DataField(0, "id", new IntType()),
+                new DataField(1, "name", new VarCharType()),
+                new DataField(2, "score", new DoubleType()),
+                new DataField(3, "region", new VarCharType())));
+    }
+}
diff --git a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnector.java b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnector.java
index 5a620f1a222448..3880d626d11d10 100644
--- a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnector.java
+++ b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnector.java
@@ -33,6 +33,7 @@
 import org.apache.doris.connector.spi.ConnectorValidationContext;
 import org.apache.doris.connector.spi.handle.ConnectorTableHandle;
 import org.apache.doris.connector.spi.scan.ConnectorScanPlanProvider;
+import org.apache.doris.connector.spi.write.ConnectorWritePlanProvider;
 import org.apache.doris.filesystem.properties.StorageProperties;
 import org.apache.doris.kerberos.HadoopAuthenticator;
 import org.apache.doris.kerberos.KerberosAuthSpec;
@@ -340,11 +341,18 @@ public ConnectorScanPlanProvider getScanPlanProvider() {
                 context, schemaAtMemo);
     }
 
+    @Override
+    public ConnectorWritePlanProvider getWritePlanProvider() {
+        return new PaimonWritePlanProvider(catalogProps,
+                new PaimonCatalogOps.CatalogBackedPaimonCatalogOps(ensureCatalog(), tableOptions),
+                context);
+    }
+
     /**
      * Declares the E5 read-path capabilities paimon supports: MVCC snapshot pinning. The B5 fe-core
      * MvccTable wiring keys off this to call {@link PaimonConnectorMetadata#beginQuerySnapshot} /
      * {@code resolveTimeTravel}.
-     * No write capability is declared: paimon write is not migrated.
+     * Write support is exposed through {@link #getWritePlanProvider()} rather than a capability flag.
      */
     @Override
     public Set<ConnectorCapability> getCapabilities() {
diff --git a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorMetadata.java b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorMetadata.java
index 7f124db18c55fb..685d1ffc91a493 100644
--- a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorMetadata.java
+++ b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorMetadata.java
@@ -31,6 +31,7 @@
 import org.apache.doris.connector.spi.ddl.ConnectorCreateTableRequest;
 import org.apache.doris.connector.spi.handle.ConnectorColumnHandle;
 import org.apache.doris.connector.spi.handle.ConnectorTableHandle;
+import org.apache.doris.connector.spi.handle.ConnectorTransaction;
 import org.apache.doris.connector.spi.mvcc.ConnectorMvccSnapshot;
 import org.apache.doris.connector.spi.mvcc.ConnectorTimeTravelSpec;
 import org.apache.doris.connector.spi.pushdown.ConnectorExpression;
@@ -1055,6 +1056,28 @@ public void dropTable(ConnectorSession session, ConnectorTableHandle handle) {
         LOG.info("dropped Paimon table {}", id);
     }
 
+    @Override
+    public ConnectorTransaction beginTransaction(ConnectorSession session) {
+        return new PaimonConnectorTransaction(
+                session.allocateTransactionId(), catalogOps, context);
+    }
+
+    @Override
+    public void validateStaticPartitionColumns(ConnectorSession session,
+            ConnectorTableHandle handle, List<String> staticPartitionColumnNames) {
+        PaimonTableHandle table = (PaimonTableHandle) handle;
+        Set<String> partitionColumns = new HashSet<>();
+        for (String name : table.getPartitionKeys()) {
+            partitionColumns.add(name.toLowerCase(java.util.Locale.ROOT));
+        }
+        for (String name : staticPartitionColumnNames) {
+            if (!partitionColumns.contains(name.toLowerCase(java.util.Locale.ROOT))) {
+                throw new DorisConnectorException("Column '" + name
+                        + "' is not a partition column of Paimon table");
+            }
+        }
+    }
+
     // ==================== DDL: Create/Drop Database ====================
 
     /**
diff --git a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorTransaction.java b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorTransaction.java
new file mode 100644
index 00000000000000..2e6df4e4ca6ae2
--- /dev/null
+++ b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorTransaction.java
@@ -0,0 +1,402 @@
+// 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.doris.connector.paimon;
+
+import org.apache.doris.connector.spi.ConnectorContext;
+import org.apache.doris.connector.spi.DorisConnectorException;
+import org.apache.doris.connector.spi.handle.ConnectorTransaction;
+import org.apache.doris.thrift.TPaimonCommitMessage;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.paimon.catalog.Catalog;
+import org.apache.paimon.io.DataInputDeserializer;
+import org.apache.paimon.table.FileStoreTable;
+import org.apache.paimon.table.Table;
+import org.apache.paimon.table.sink.CommitMessage;
+import org.apache.paimon.table.sink.CommitMessageSerializer;
+import org.apache.paimon.table.sink.InnerTableCommit;
+import org.apache.thrift.TDeserializer;
+import org.apache.thrift.TException;
+import org.apache.thrift.protocol.TBinaryProtocol;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+/** FE coordinator for one Paimon write transaction. */
+public class PaimonConnectorTransaction implements ConnectorTransaction {
+
+    private static final Logger LOG = LogManager.getLogger(PaimonConnectorTransaction.class);
+    private static final int COMMIT_HEADER_SIZE = 12;
+    private static final byte[] COMMIT_MAGIC = new byte[] {'D', 'P', 'C', 'M'};
+
+    enum CommitState {
+        PREPARED,
+        COMMITTING,
+        COMMITTED,
+        OUTCOME_UNKNOWN
+    }
+
+    private final long transactionId;
+    private final String commitUser;
+    private final PaimonCatalogOps catalogOps;
+    private final ConnectorContext context;
+    private final List<byte[]> commitPayloads = new ArrayList<>();
+    private final Set<CommitPayloadKey> commitPayloadSet = new HashSet<>();
+
+    private PaimonWriteBinding binding;
+    private CommitState state = CommitState.PREPARED;
+    private long updateCount;
+
+    public PaimonConnectorTransaction(long transactionId, PaimonCatalogOps catalogOps,
+            ConnectorContext context) {
+        if (transactionId <= 0) {
+            throw new IllegalArgumentException("Paimon transaction id must be positive");
+        }
+        this.transactionId = transactionId;
+        this.catalogOps = catalogOps;
+        this.context = context;
+        // A random per-transaction user is stable across commit retries and cannot collide with
+        // another Doris cluster writing the same Paimon warehouse.
+        this.commitUser = "doris_txn_" + transactionId + "_" + UUID.randomUUID();
+    }
+
+    synchronized void bind(PaimonWriteBinding writeBinding) {
+        if (writeBinding == null) {
+            throw new IllegalArgumentException("Paimon write binding must not be null");
+        }
+        if (binding != null) {
+            throw new IllegalStateException("Paimon transaction is already bound");
+        }
+        if (state != CommitState.PREPARED) {
+            throw new IllegalStateException("Paimon transaction can only be bound while prepared");
+        }
+        binding = writeBinding;
+    }
+
+    String getCommitUser() {
+        return commitUser;
+    }
+
+    @Override
+    public long getTransactionId() {
+        return transactionId;
+    }
+
+    @Override
+    public void addCommitData(byte[] commitFragment) {
+        TPaimonCommitMessage data = new TPaimonCommitMessage();
+        try {
+            new TDeserializer(new TBinaryProtocol.Factory()).deserialize(data, commitFragment);
+        } catch (TException e) {
+            throw new DorisConnectorException("Failed to deserialize Paimon commit data", e);
+        }
+        if (!data.isSetPayload() || data.getPayload() == null || data.getPayload().length == 0) {
+            throw new DorisConnectorException("Paimon commit data is missing its payload");
+        }
+        byte[] payload = data.getPayload();
+        synchronized (this) {
+            if (commitPayloadSet.add(new CommitPayloadKey(payload))) {
+                commitPayloads.add(payload);
+                if (data.isSetRowCount()) {
+                    updateCount += data.getRowCount();
+                }
+            }
+        }
+    }
+
+    @Override
+    public long getUpdateCnt() {
+        synchronized (this) {
+            return updateCount;
+        }
+    }
+
+    @Override
+    public String profileLabel() {
+        return "PAIMON";
+    }
+
+    @Override
+    public void commit() {
+        PaimonWriteBinding writeBinding = requireBinding();
+        List<byte[]> payloads = snapshotPayloads();
+        if (payloads.isEmpty() && !writeBinding.isOverwrite()) {
+            synchronized (this) {
+                state = CommitState.COMMITTED;
+            }
+            return;
+        }
+        try {
+            List<CommitMessage> messages = deserializePayloads(payloads);
+            if (messages.isEmpty() && !writeBinding.isOverwrite()) {
+                throw new IOException("Paimon commit messages are empty");
+            }
+            commitWithReconciliation(writeBinding, messages);
+        } catch (Exception e) {
+            throw new DorisConnectorException(
+                    "Failed to commit Paimon transaction " + transactionId + ": " + e.getMessage(), e);
+        }
+    }
+
+    private void commitWithReconciliation(PaimonWriteBinding writeBinding,
+            List<CommitMessage> messages) throws Exception {
+        Exception firstFailure;
+        try {
+            doCommit(writeBinding, messages);
+            return;
+        } catch (Exception e) {
+            if (state() == CommitState.COMMITTED) {
+                return;
+            }
+            if (state() == CommitState.PREPARED) {
+                throw e;
+            }
+            firstFailure = e;
+        }
+
+        LOG.warn("Paimon commit outcome is unknown; retrying idempotently, txn={}, table={}",
+                transactionId, writeBinding.tableName(), firstFailure);
+        Exception retryFailure;
+        try {
+            doCommit(writeBinding, messages);
+            return;
+        } catch (Exception e) {
+            if (state() == CommitState.COMMITTED) {
+                return;
+            }
+            retryFailure = e;
+        }
+
+        try {
+            FileStoreTable current = loadCurrentTable(writeBinding);
+            if (!current.snapshotManager().findSnapshotsForIdentifiers(
+                    commitUser, Collections.singletonList(transactionId)).isEmpty()) {
+                markCommitted();
+                return;
+            }
+        } catch (Exception reconciliationFailure) {
+            retryFailure.addSuppressed(reconciliationFailure);
+        }
+        retryFailure.addSuppressed(firstFailure);
+        synchronized (this) {
+            state = CommitState.OUTCOME_UNKNOWN;
+        }
+        throw retryFailure;
+    }
+
+    private void doCommit(PaimonWriteBinding writeBinding, List<CommitMessage> messages)
+            throws Exception {
+        executeAuthenticated(() -> {
+            FileStoreTable current = loadCurrentTableUnauthenticated(writeBinding);
+            InnerTableCommit committer = current.newCommit(commitUser);
+            Exception failure = null;
+            try {
+                if (writeBinding.isOverwrite()) {
+                    committer.withOverwrite(writeBinding.getStaticPartition());
+                }
+                Map<Long, List<CommitMessage>> commitMap = new HashMap<>();
+                commitMap.put(transactionId, messages);
+                markCommitting();
+                committer.filterAndCommit(commitMap);
+                markCommitted();
+                return null;
+            } catch (Exception e) {
+                failure = e;
+                throw e;
+            } finally {
+                try {
+                    committer.close();
+                } catch (Exception closeFailure) {
+                    if (state() == CommitState.COMMITTED) {
+                        LOG.warn("Ignoring Paimon committer close failure after commit, txn={}",
+                                transactionId, closeFailure);
+                    } else if (failure != null) {
+                        failure.addSuppressed(closeFailure);
+                    } else {
+                        throw closeFailure;
+                    }
+                }
+            }
+        });
+    }
+
+    @Override
+    public void rollback() {
+        CommitState currentState = state();
+        if (currentState == CommitState.COMMITTED
+                || currentState == CommitState.COMMITTING
+                || currentState == CommitState.OUTCOME_UNKNOWN) {
+            return;
+        }
+        List<byte[]> payloads = snapshotPayloads();
+        if (payloads.isEmpty()) {
+            return;
+        }
+        try {
+            PaimonWriteBinding writeBinding = requireBinding();
+            List<CommitMessage> messages = deserializePayloads(payloads);
+            executeAuthenticated(() -> {
+                // Abort the files produced against the bound table generation. Reloading the
+                // current table would make a schema-generation fence block cleanup after a
+                // concurrent ALTER, which is exactly when these staged files must be removed.
+                InnerTableCommit committer = writeBinding.getTable().newCommit(commitUser);
+                try {
+                    committer.abort(messages);
+                    return null;
+                } finally {
+                    committer.close();
+                }
+            });
+        } catch (Exception e) {
+            LOG.warn("Failed to roll back Paimon transaction {}, table={}",
+                    transactionId, binding == null ? "unbound" : binding.tableName(), e);
+        }
+    }
+
+    @Override
+    public void close() {
+        // Paimon's commit and writer objects are closed at their respective operation boundaries.
+    }
+
+    private FileStoreTable loadCurrentTable(PaimonWriteBinding writeBinding) throws Exception {
+        return executeAuthenticated(() -> loadCurrentTableUnauthenticated(writeBinding));
+    }
+
+    private FileStoreTable loadCurrentTableUnauthenticated(PaimonWriteBinding writeBinding)
+            throws Catalog.TableNotExistException {
+        Table current = catalogOps.getTable(writeBinding.getIdentifier());
+        if (!(current instanceof FileStoreTable)) {
+            throw new DorisConnectorException(
+                    "Paimon write target is no longer a file store table: " + writeBinding.tableName());
+        }
+        FileStoreTable fileStoreTable = (FileStoreTable) current;
+        String currentIdentity = PaimonWritePlanProvider.writeMetadataIdentity(fileStoreTable);
+        if (!writeBinding.getMetadataIdentity().equals(currentIdentity)) {
+            throw new DorisConnectorException(
+                    "Paimon write metadata changed after the write was bound; retry the statement");
+        }
+        return PaimonWriteBinding.configureTableForWrite(
+                fileStoreTable, writeBinding.isOverwrite(), writeBinding.getStaticPartition());
+    }
+
+    private <T> T executeAuthenticated(java.util.concurrent.Callable<T> callable) throws Exception {
+        return context == null ? callable.call() : context.executeAuthenticated(callable);
+    }
+
+    private synchronized PaimonWriteBinding requireBinding() {
+        if (binding == null) {
+            throw new DorisConnectorException(
+                    "Missing Paimon write binding for transaction " + transactionId);
+        }
+        return binding;
+    }
+
+    private synchronized CommitState state() {
+        return state;
+    }
+
+    private synchronized void markCommitting() {
+        if (state != CommitState.PREPARED && state != CommitState.COMMITTING) {
+            throw new IllegalStateException("Cannot enter Paimon commit from state " + state);
+        }
+        state = CommitState.COMMITTING;
+    }
+
+    private synchronized void markCommitted() {
+        if (state != CommitState.COMMITTING) {
+            throw new IllegalStateException("Only a committing Paimon transaction can be committed");
+        }
+        state = CommitState.COMMITTED;
+    }
+
+    private synchronized List<byte[]> snapshotPayloads() {
+        return new ArrayList<>(commitPayloads);
+    }
+
+    static List<CommitMessage> deserializePayloads(List<byte[]> payloads) throws IOException {
+        List<CommitMessage> messages = new ArrayList<>();
+        for (byte[] payload : payloads) {
+            messages.addAll(deserializePayload(payload));
+        }
+        return messages;
+    }
+
+    static List<CommitMessage> deserializePayload(byte[] payload) throws IOException {
+        if (payload == null || payload.length < COMMIT_HEADER_SIZE || !hasMagic(payload)) {
+            throw new IOException("Invalid Paimon commit message payload header");
+        }
+        int version = readInt(payload, 4);
+        int length = readInt(payload, 8);
+        if (length < 0 || payload.length != COMMIT_HEADER_SIZE + length) {
+            throw new IOException("Invalid Paimon commit message payload length");
+        }
+        byte[] raw = Arrays.copyOfRange(payload, COMMIT_HEADER_SIZE, payload.length);
+        List<CommitMessage> messages = new CommitMessageSerializer()
+                .deserializeList(version, new DataInputDeserializer(raw));
+        if (messages == null) {
+            throw new IOException("Paimon commit message payload deserialized to null");
+        }
+        return messages;
+    }
+
+    private static boolean hasMagic(byte[] payload) {
+        for (int i = 0; i < COMMIT_MAGIC.length; i++) {
+            if (payload[i] != COMMIT_MAGIC[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static int readInt(byte[] payload, int offset) {
+        return ((payload[offset] & 0xff) << 24)
+                | ((payload[offset + 1] & 0xff) << 16)
+                | ((payload[offset + 2] & 0xff) << 8)
+                | (payload[offset + 3] & 0xff);
+    }
+
+    private static final class CommitPayloadKey {
+        private final byte[] payload;
+        private final int hashCode;
+
+        private CommitPayloadKey(byte[] payload) {
+            this.payload = payload;
+            this.hashCode = Arrays.hashCode(payload);
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            return other instanceof CommitPayloadKey
+                    && Arrays.equals(payload, ((CommitPayloadKey) other).payload);
+        }
+
+        @Override
+        public int hashCode() {
+            return hashCode;
+        }
+    }
+}
diff --git a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java
index 265345c7091b22..56a006738b863e 100644
--- a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java
+++ b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java
@@ -2231,7 +2231,7 @@ static String encodeSplit(Split split) {
     }
 
     @SuppressWarnings("unchecked")
-    private static <T> String encodeObjectToString(T obj) {
+    static <T> String encodeObjectToString(T obj) {
         try {
             byte[] bytes = InstantiationUtil.serializeObject(obj);
             return new String(BASE64_ENCODER.encode(bytes), StandardCharsets.UTF_8);
diff --git a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonTypeMapping.java b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonTypeMapping.java
index 1f29ccd1194df7..046356072dbbf6 100644
--- a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonTypeMapping.java
+++ b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonTypeMapping.java
@@ -39,6 +39,7 @@
 import org.apache.paimon.types.VarBinaryType;
 import org.apache.paimon.types.VarCharType;
 import org.apache.paimon.types.VariantType;
+import org.apache.paimon.types.VectorType;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -89,6 +90,12 @@ public static ConnectorType toConnectorType(DataType dataType, Options options)
                 return toBinaryType((BinaryType) dataType, options);
             case VARBINARY:
                 return toVarbinaryType((VarBinaryType) dataType, options);
+            case BLOB:
+                return ConnectorType.of("VARBINARY");
+            case VARIANT:
+                return ConnectorType.of("VARIANT");
+            case VECTOR:
+                return toVectorType((VectorType) dataType, options);
             case DECIMAL:
                 return toDecimalType((DecimalType) dataType);
             case DATE:
@@ -171,7 +178,13 @@ private static ConnectorType toTimestampTzType(DataType dataType, Options option
 
     private static ConnectorType toArrayType(ArrayType type, Options options) {
         ConnectorType elementType = toConnectorType(type.getElementType(), options);
-        return ConnectorType.arrayOf(elementType);
+        return ConnectorType.arrayOf(elementType, type.getElementType().isNullable());
+    }
+
+    private static ConnectorType toVectorType(VectorType type, Options options) {
+        ConnectorType elementType = toConnectorType(type.getElementType(), options);
+        // Paimon vectors are dense fixed-size arrays and reject null elements.
+        return ConnectorType.arrayOf(elementType, false);
     }
 
     private static ConnectorType toMapType(MapType type, Options options) {
diff --git a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonWriteBinding.java b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonWriteBinding.java
new file mode 100644
index 00000000000000..51a116aea4560f
--- /dev/null
+++ b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonWriteBinding.java
@@ -0,0 +1,98 @@
+// 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.doris.connector.paimon;
+
+import org.apache.paimon.CoreOptions;
+import org.apache.paimon.catalog.Identifier;
+import org.apache.paimon.table.FileStoreTable;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/** Immutable statement binding shared by the Paimon write plan and transaction. */
+final class PaimonWriteBinding {
+
+    private final Identifier identifier;
+    private final FileStoreTable table;
+    private final String serializedTable;
+    private final Map<String, String> hadoopConfig;
+    private final boolean overwrite;
+    private final Map<String, String> staticPartition;
+    private final String metadataIdentity;
+
+    PaimonWriteBinding(Identifier identifier, FileStoreTable table,
+            Map<String, String> hadoopConfig, boolean overwrite,
+            Map<String, String> staticPartition, String metadataIdentity) {
+        this.identifier = identifier;
+        this.table = table;
+        this.serializedTable = PaimonScanPlanProvider.encodeObjectToString(
+                PaimonScanPlanProvider.dropCatalogLoader(table));
+        this.hadoopConfig = Collections.unmodifiableMap(new LinkedHashMap<>(hadoopConfig));
+        this.overwrite = overwrite;
+        this.staticPartition = Collections.unmodifiableMap(new LinkedHashMap<>(staticPartition));
+        this.metadataIdentity = metadataIdentity;
+    }
+
+    Identifier getIdentifier() {
+        return identifier;
+    }
+
+    FileStoreTable getTable() {
+        return table;
+    }
+
+    String getSerializedTable() {
+        return serializedTable;
+    }
+
+    Map<String, String> getHadoopConfig() {
+        return hadoopConfig;
+    }
+
+    boolean isOverwrite() {
+        return overwrite;
+    }
+
+    Map<String, String> getStaticPartition() {
+        return staticPartition;
+    }
+
+    String getMetadataIdentity() {
+        return metadataIdentity;
+    }
+
+    String tableName() {
+        return identifier.getFullName();
+    }
+
+    static FileStoreTable configureTableForWrite(FileStoreTable table, boolean overwrite,
+            Map<String, String> staticPartition) {
+        if (!overwrite) {
+            return table;
+        }
+        String option = CoreOptions.DYNAMIC_PARTITION_OVERWRITE.key();
+        boolean explicitlyDynamic = staticPartition.isEmpty()
+                && Boolean.parseBoolean(table.options().get(option));
+        if (explicitlyDynamic) {
+            return table;
+        }
+        // Doris OVERWRITE without PARTITION means whole-table replacement by default.
+        return table.copy(Collections.singletonMap(option, Boolean.FALSE.toString()));
+    }
+}
diff --git a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonWritePlanProvider.java b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonWritePlanProvider.java
new file mode 100644
index 00000000000000..41226cc25120ce
--- /dev/null
+++ b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonWritePlanProvider.java
@@ -0,0 +1,312 @@
+// 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.doris.connector.paimon;
+
+import org.apache.doris.connector.spi.ConnectorColumn;
+import org.apache.doris.connector.spi.ConnectorContext;
+import org.apache.doris.connector.spi.ConnectorSession;
+import org.apache.doris.connector.spi.ConnectorStorageContext;
+import org.apache.doris.connector.spi.ConnectorType;
+import org.apache.doris.connector.spi.DorisConnectorException;
+import org.apache.doris.connector.spi.handle.ConnectorTableHandle;
+import org.apache.doris.connector.spi.handle.ConnectorTransaction;
+import org.apache.doris.connector.spi.handle.ConnectorWriteHandle;
+import org.apache.doris.connector.spi.handle.WriteOperation;
+import org.apache.doris.connector.spi.write.ConnectorSinkPlan;
+import org.apache.doris.connector.spi.write.ConnectorWritePlanProvider;
+import org.apache.doris.filesystem.properties.StorageProperties;
+import org.apache.doris.thrift.TDataSink;
+import org.apache.doris.thrift.TDataSinkType;
+import org.apache.doris.thrift.TPaimonTableSink;
+import org.apache.doris.thrift.TPaimonWriteMode;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.paimon.catalog.Identifier;
+import org.apache.paimon.table.FileStoreTable;
+import org.apache.paimon.table.Table;
+import org.apache.paimon.types.DataField;
+import org.apache.paimon.types.DataTypeRoot;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeMap;
+
+/** Plans Paimon INSERT and INSERT OVERWRITE writes for the plugin-driven sink. */
+public class PaimonWritePlanProvider implements ConnectorWritePlanProvider {
+
+    private final PaimonCatalogProperties catalogProperties;
+    private final PaimonCatalogOps catalogOps;
+    private final ConnectorContext context;
+    private final PaimonTypeMapping.Options typeMappingOptions;
+
+    public PaimonWritePlanProvider(PaimonCatalogProperties catalogProperties,
+            PaimonCatalogOps catalogOps, ConnectorContext context) {
+        this.catalogProperties = catalogProperties;
+        this.catalogOps = catalogOps;
+        this.context = context;
+        this.typeMappingOptions = new PaimonTypeMapping.Options(
+                catalogProperties.isEnableMappingVarbinary(),
+                catalogProperties.isEnableMappingTimestampTz());
+    }
+
+    @Override
+    public ConnectorSinkPlan planWrite(ConnectorSession session, ConnectorWriteHandle handle) {
+        WriteOperation operation = handle.isOverwrite()
+                ? WriteOperation.OVERWRITE : handle.getWriteOperation();
+        if (operation != WriteOperation.INSERT && operation != WriteOperation.OVERWRITE) {
+            throw new DorisConnectorException("Unsupported Paimon write operation: " + operation);
+        }
+
+        PaimonTableHandle tableHandle = (PaimonTableHandle) handle.getTableHandle();
+        Optional<String> branchName = handle.getBranchName();
+        FileStoreTable resolved = resolveWriteTable(session, tableHandle, branchName);
+        List<ConnectorColumn> currentColumns = mapWriteColumns(resolved);
+        validateBoundColumns(handle.getBoundTargetColumns(), currentColumns);
+        validateWriteColumns(handle.getColumns(), currentColumns);
+
+        Map<String, String> staticPartition = canonicalStaticPartition(
+                resolved, handle.getStaticPartitionSpec());
+        FileStoreTable writeTable = PaimonWriteBinding.configureTableForWrite(
+                resolved, handle.isOverwrite(), staticPartition);
+        Identifier identifier = identifier(tableHandle, branchName);
+        PaimonWriteBinding binding = new PaimonWriteBinding(
+                identifier, writeTable, buildHadoopConfig(), handle.isOverwrite(),
+                staticPartition, writeMetadataIdentity(writeTable));
+
+        PaimonConnectorTransaction transaction = currentTransaction(session);
+        transaction.bind(binding);
+
+        TPaimonTableSink sink = new TPaimonTableSink();
+        sink.setSerializedTable(binding.getSerializedTable());
+        sink.setHadoopConfig(binding.getHadoopConfig());
+        List<String> columnNames = new ArrayList<>(handle.getColumns().size());
+        for (ConnectorColumn column : handle.getColumns()) {
+            columnNames.add(column.getName());
+        }
+        sink.setColumnNames(columnNames);
+        sink.setWriteMode(handle.isOverwrite()
+                ? TPaimonWriteMode.OVERWRITE : TPaimonWriteMode.APPEND);
+        sink.setTransactionId(transaction.getTransactionId());
+        sink.setCommitUser(transaction.getCommitUser());
+
+        TDataSink dataSink = new TDataSink(TDataSinkType.PAIMON_TABLE_SINK);
+        dataSink.setPaimonTableSink(sink);
+        return new ConnectorSinkPlan(dataSink);
+    }
+
+    @Override
+    public Optional<List<ConnectorColumn>> getWriteColumns(ConnectorSession session,
+            ConnectorTableHandle tableHandle, Optional<String> branchName) {
+        return Optional.of(mapWriteColumns(resolveWriteTable(
+                session, (PaimonTableHandle) tableHandle, branchName)));
+    }
+
+    @Override
+    public String getWriteMetadataIdentity(ConnectorSession session,
+            ConnectorTableHandle tableHandle) {
+        return writeMetadataIdentity(resolveWriteTable(
+                session, (PaimonTableHandle) tableHandle, Optional.empty()));
+    }
+
+    @Override
+    public void appendExplainInfo(StringBuilder output, String prefix,
+            ConnectorSession session, ConnectorWriteHandle handle) {
+        PaimonTableHandle table = (PaimonTableHandle) handle.getTableHandle();
+        output.append(prefix).append("  PAIMON TABLE: ")
+                .append(table.getDatabaseName()).append(".").append(table.getTableName())
+                .append("\n");
+    }
+
+    @Override
+    public Set<WriteOperation> supportedOperations() {
+        return EnumSet.of(WriteOperation.INSERT, WriteOperation.OVERWRITE);
+    }
+
+    @Override
+    public boolean supportsWriteBranch() {
+        return true;
+    }
+
+    @Override
+    public boolean requiresMaterializeStaticPartitionValues() {
+        // Paimon's SDK derives the target partition from the complete row.
+        return true;
+    }
+
+    @Override
+    public boolean requiresParallelWrite() {
+        // Dynamic-bucket assigners must observe one ordered key stream. Keep every Paimon table on
+        // the GATHER path until Doris can shuffle by Paimon's effective bucket-assignment key.
+        return false;
+    }
+
+    private FileStoreTable resolveWriteTable(ConnectorSession session,
+            PaimonTableHandle handle, Optional<String> branchName) {
+        String branch = branchName.orElse("");
+        String key = "paimon:write:" + session.getCatalogId() + ":"
+                + handle.getDatabaseName() + ":" + handle.getTableName() + ":" + branch;
+        return session.getStatementScope().computeIfAbsent(key, () -> {
+            try {
+                Table table = executeAuthenticated(
+                        () -> catalogOps.getTable(identifier(handle, branchName)));
+                if (!(table instanceof FileStoreTable)) {
+                    throw new DorisConnectorException(
+                            "Paimon write requires a file store table: " + handle);
+                }
+                // A caching catalog can retain a Table object after schema evolution. Pin the latest
+                // schema once for the statement, then use this same object through sink binding.
+                return ((FileStoreTable) table).copyWithLatestSchema();
+            } catch (DorisConnectorException e) {
+                throw e;
+            } catch (Exception e) {
+                throw new DorisConnectorException(
+                        "Failed to load Paimon write target " + handle + ": " + e.getMessage(), e);
+            }
+        });
+    }
+
+    private List<ConnectorColumn> mapWriteColumns(FileStoreTable table) {
+        Set<String> primaryKeys = new HashSet<>();
+        for (String key : table.primaryKeys()) {
+            primaryKeys.add(key.toLowerCase(Locale.ROOT));
+        }
+        List<ConnectorColumn> columns = new ArrayList<>();
+        for (DataField field : table.rowType().getFields()) {
+            ConnectorType type = PaimonTypeMapping.toConnectorType(field.type(), typeMappingOptions);
+            ConnectorColumn column = new ConnectorColumn(
+                    field.name(), type, field.description(), field.type().isNullable(), null,
+                    primaryKeys.contains(field.name().toLowerCase(Locale.ROOT)))
+                    .withUniqueId(field.id());
+            if (field.defaultValue() != null) {
+                // Paimon stores column defaults as SQL literal text and validates that the
+                // literal can be cast from STRING to the field type. Preserve that literal so
+                // Doris expands omitted columns before the sink instead of materializing NULL.
+                column = column.withDefaultValueSql(field.defaultValue());
+            }
+            if (field.type().getTypeRoot() == DataTypeRoot.TIMESTAMP_WITH_LOCAL_TIME_ZONE) {
+                column = column.withTimeZone();
+            }
+            columns.add(column);
+        }
+        return Collections.unmodifiableList(columns);
+    }
+
+    private static void validateBoundColumns(List<ConnectorColumn> bound,
+            List<ConnectorColumn> current) {
+        if (!bound.isEmpty() && !bound.equals(current)) {
+            throw new DorisConnectorException(
+                    "Paimon write metadata changed after the write was bound; retry the statement");
+        }
+    }
+
+    private static void validateWriteColumns(List<ConnectorColumn> writeColumns,
+            List<ConnectorColumn> currentColumns) {
+        Map<String, ConnectorColumn> current = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+        for (ConnectorColumn column : currentColumns) {
+            current.put(column.getName(), column);
+        }
+        Set<String> seen = new HashSet<>();
+        for (ConnectorColumn column : writeColumns) {
+            ConnectorColumn target = current.get(column.getName());
+            if (target == null || !target.getType().equals(column.getType())) {
+                throw new DorisConnectorException(
+                        "Paimon write column no longer matches the target schema: " + column.getName());
+            }
+            if (!seen.add(column.getName().toLowerCase(Locale.ROOT))) {
+                throw new DorisConnectorException("Duplicate Paimon write column: " + column.getName());
+            }
+        }
+    }
+
+    static String writeMetadataIdentity(FileStoreTable table) {
+        String uuid = table.catalogEnvironment() == null
+                ? null : table.catalogEnvironment().uuid();
+        return String.valueOf(uuid) + "|" + table.location() + "|" + table.schema().id();
+    }
+
+    private static Identifier identifier(PaimonTableHandle handle,
+            Optional<String> branchName) {
+        return branchName.isPresent()
+                ? new Identifier(handle.getDatabaseName(), handle.getTableName(), branchName.get())
+                : Identifier.create(handle.getDatabaseName(), handle.getTableName());
+    }
+
+    private static Map<String, String> canonicalStaticPartition(FileStoreTable table,
+            Map<String, String> requested) {
+        if (requested == null || requested.isEmpty()) {
+            return Collections.emptyMap();
+        }
+        Map<String, String> canonical = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
+        for (String partitionKey : table.partitionKeys()) {
+            canonical.put(partitionKey, partitionKey);
+        }
+        Map<String, String> result = new LinkedHashMap<>();
+        for (Map.Entry<String, String> entry : requested.entrySet()) {
+            String name = canonical.get(entry.getKey());
+            if (name == null) {
+                throw new DorisConnectorException("Column '" + entry.getKey()
+                        + "' is not a partition column of Paimon table");
+            }
+            result.put(name, entry.getValue());
+        }
+        return result;
+    }
+
+    private Map<String, String> buildHadoopConfig() {
+        Map<String, String> storageConfig = new HashMap<>();
+        if (context != null) {
+            for (StorageProperties properties : storage().getStorageProperties()) {
+                properties.toHadoopProperties().ifPresent(hadoop ->
+                        storageConfig.putAll(hadoop.toHadoopConfigurationMap()));
+            }
+        }
+        Configuration configuration = PaimonCatalogFactory.buildHadoopConfiguration(
+                catalogProperties.getRaw(), storageConfig);
+        Map<String, String> result = new LinkedHashMap<>();
+        for (Map.Entry<String, String> entry : configuration) {
+            result.put(entry.getKey(), entry.getValue());
+        }
+        return result;
+    }
+
+    private PaimonConnectorTransaction currentTransaction(ConnectorSession session) {
+        Optional<ConnectorTransaction> transaction = session.getCurrentTransaction();
+        if (!transaction.isPresent() || !(transaction.get() instanceof PaimonConnectorTransaction)) {
+            throw new DorisConnectorException(
+                    "Paimon write requires an active Paimon connector transaction");
+        }
+        return (PaimonConnectorTransaction) transaction.get();
+    }
+
+    private <T> T executeAuthenticated(java.util.concurrent.Callable<T> callable) throws Exception {
+        return context == null ? callable.call() : context.executeAuthenticated(callable);
+    }
+
+    private ConnectorStorageContext storage() {
+        return context.getStorageContext();
+    }
+}
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorTransactionTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorTransactionTest.java
new file mode 100644
index 00000000000000..da0951986a9944
--- /dev/null
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorTransactionTest.java
@@ -0,0 +1,185 @@
+// 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.doris.connector.paimon;
+
+import org.apache.doris.connector.spi.DorisConnectorException;
+import org.apache.doris.thrift.TPaimonCommitMessage;
+
+import org.apache.paimon.catalog.Catalog;
+import org.apache.paimon.catalog.FileSystemCatalog;
+import org.apache.paimon.catalog.Identifier;
+import org.apache.paimon.data.GenericRow;
+import org.apache.paimon.data.InternalRow;
+import org.apache.paimon.fs.local.LocalFileIO;
+import org.apache.paimon.io.DataOutputViewStreamWrapper;
+import org.apache.paimon.reader.RecordReader;
+import org.apache.paimon.schema.Schema;
+import org.apache.paimon.schema.SchemaChange;
+import org.apache.paimon.table.FileStoreTable;
+import org.apache.paimon.table.sink.CommitMessage;
+import org.apache.paimon.table.sink.CommitMessageSerializer;
+import org.apache.paimon.table.sink.TableWriteImpl;
+import org.apache.paimon.table.source.ReadBuilder;
+import org.apache.paimon.types.DataTypes;
+import org.apache.thrift.TSerializer;
+import org.apache.thrift.protocol.TBinaryProtocol;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.ByteBuffer;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class PaimonConnectorTransactionTest {
+
+    private static final Identifier TABLE = Identifier.create("db", "t");
+
+    @TempDir
+    Path warehouse;
+
+    @Test
+    public void appendCommitsRealPaimonMessagesAndDeduplicatesReports() throws Exception {
+        Catalog catalog = createCatalog();
+        PaimonConnectorTransaction transaction = transaction(catalog, 101L, false);
+        byte[] report = prepareReport(catalog, transaction, GenericRow.of(1, 10L), 2L);
+
+        transaction.addCommitData(report);
+        transaction.addCommitData(report);
+        transaction.commit();
+
+        Assertions.assertEquals(2L, transaction.getUpdateCnt());
+        Assertions.assertEquals(Collections.singletonList("1:10"), read(catalog));
+    }
+
+    @Test
+    public void emptyOverwriteRemovesExistingRows() throws Exception {
+        Catalog catalog = createCatalog();
+        PaimonConnectorTransaction append = transaction(catalog, 102L, false);
+        append.addCommitData(prepareReport(catalog, append, GenericRow.of(1, 10L), 1L));
+        append.commit();
+
+        PaimonConnectorTransaction overwrite = transaction(catalog, 103L, true);
+        overwrite.commit();
+
+        Assertions.assertTrue(read(catalog).isEmpty());
+    }
+
+    @Test
+    public void rollbackAbortsPreparedFiles() throws Exception {
+        Catalog catalog = createCatalog();
+        PaimonConnectorTransaction transaction = transaction(catalog, 104L, false);
+        transaction.addCommitData(prepareReport(catalog, transaction, GenericRow.of(1, 10L), 1L));
+
+        transaction.rollback();
+
+        Assertions.assertTrue(read(catalog).isEmpty());
+    }
+
+    @Test
+    public void rollbackStillWorksAfterConcurrentSchemaChange() throws Exception {
+        Catalog catalog = createCatalog();
+        PaimonConnectorTransaction transaction = transaction(catalog, 105L, false);
+        transaction.addCommitData(prepareReport(catalog, transaction, GenericRow.of(1, 10L), 1L));
+        catalog.alterTable(TABLE, SchemaChange.addColumn("extra", DataTypes.BIGINT()), false);
+
+        Assertions.assertThrows(DorisConnectorException.class, transaction::commit);
+        transaction.rollback();
+
+        Assertions.assertTrue(read(catalog).isEmpty());
+    }
+
+    @Test
+    public void rejectsMalformedCommitPayload() throws Exception {
+        Catalog catalog = createCatalog();
+        PaimonConnectorTransaction transaction = transaction(catalog, 106L, false);
+        TPaimonCommitMessage message = new TPaimonCommitMessage().setPayload(new byte[] {1, 2, 3});
+        transaction.addCommitData(new TSerializer(new TBinaryProtocol.Factory()).serialize(message));
+
+        Assertions.assertThrows(DorisConnectorException.class, transaction::commit);
+    }
+
+    private Catalog createCatalog() throws Exception {
+        Catalog catalog = new FileSystemCatalog(
+                LocalFileIO.create(), new org.apache.paimon.fs.Path(warehouse.toUri()));
+        catalog.createDatabase("db", false);
+        catalog.createTable(TABLE, Schema.newBuilder()
+                .column("id", DataTypes.INT())
+                .column("value", DataTypes.BIGINT())
+                .build(), false);
+        return catalog;
+    }
+
+    private static PaimonConnectorTransaction transaction(
+            Catalog catalog, long transactionId, boolean overwrite) throws Exception {
+        PaimonCatalogOps ops = new PaimonCatalogOps.CatalogBackedPaimonCatalogOps(catalog);
+        FileStoreTable table = (FileStoreTable) catalog.getTable(TABLE);
+        FileStoreTable writeTable = PaimonWriteBinding.configureTableForWrite(
+                table, overwrite, Collections.emptyMap());
+        PaimonConnectorTransaction transaction = new PaimonConnectorTransaction(
+                transactionId, ops, new RecordingConnectorContext());
+        transaction.bind(new PaimonWriteBinding(
+                TABLE, writeTable, Collections.emptyMap(), overwrite,
+                Collections.emptyMap(), PaimonWritePlanProvider.writeMetadataIdentity(writeTable)));
+        return transaction;
+    }
+
+    private static byte[] prepareReport(Catalog catalog, PaimonConnectorTransaction transaction,
+            InternalRow row, long rowCount) throws Exception {
+        FileStoreTable table = (FileStoreTable) catalog.getTable(TABLE);
+        TableWriteImpl<?> writer = table.newWrite(transaction.getCommitUser());
+        try {
+            writer.write(row);
+            List<CommitMessage> messages = writer.prepareCommit(true, transaction.getTransactionId());
+            byte[] payload = frame(messages);
+            TPaimonCommitMessage report = new TPaimonCommitMessage()
+                    .setPayload(payload)
+                    .setRowCount(rowCount);
+            return new TSerializer(new TBinaryProtocol.Factory()).serialize(report);
+        } finally {
+            writer.close();
+        }
+    }
+
+    private static byte[] frame(List<CommitMessage> messages) throws Exception {
+        CommitMessageSerializer serializer = new CommitMessageSerializer();
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        serializer.serializeList(messages, new DataOutputViewStreamWrapper(output));
+        byte[] serialized = output.toByteArray();
+        ByteBuffer framed = ByteBuffer.allocate(12 + serialized.length);
+        framed.put(new byte[] {'D', 'P', 'C', 'M'});
+        framed.putInt(serializer.getVersion());
+        framed.putInt(serialized.length);
+        framed.put(serialized);
+        return framed.array();
+    }
+
+    private static List<String> read(Catalog catalog) throws Exception {
+        ReadBuilder builder = catalog.getTable(TABLE).newReadBuilder();
+        List<String> rows = new ArrayList<>();
+        try (RecordReader<InternalRow> reader =
+                builder.newRead().createReader(builder.newScan().plan())) {
+            reader.forEachRemaining(row -> rows.add(row.getInt(0) + ":" + row.getLong(1)));
+        }
+        Collections.sort(rows);
+        return rows;
+    }
+}
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonSchemaBuilderTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonSchemaBuilderTest.java
index 7fce566a689180..8fc82211fdcbff 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonSchemaBuilderTest.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonSchemaBuilderTest.java
@@ -25,10 +25,14 @@
 import org.apache.doris.connector.spi.ddl.ConnectorPartitionSpec;
 
 import org.apache.paimon.CoreOptions;
+import org.apache.paimon.schema.ColumnDirectiveUtils;
 import org.apache.paimon.schema.Schema;
+import org.apache.paimon.types.BlobType;
 import org.apache.paimon.types.DataField;
+import org.apache.paimon.types.FloatType;
 import org.apache.paimon.types.IntType;
 import org.apache.paimon.types.VarCharType;
+import org.apache.paimon.types.VectorType;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
@@ -225,4 +229,29 @@ public void commentFallsBackToClauseWhenPropertyAbsent() {
         // property is absent (ignoring request.getComment()) turns this red.
         Assertions.assertEquals("from clause", schema.comment());
     }
+
+    @Test
+    public void paimon20BlobAndVectorDirectivesCreatePhysicalTypes() {
+        ConnectorColumn blob = new ConnectorColumn(
+                "payload", ConnectorType.of("VARBINARY"),
+                "__BLOB_FIELD; payload bytes", true, null);
+        ConnectorColumn vector = new ConnectorColumn(
+                "embedding", ConnectorType.arrayOf(ConnectorType.of("FLOAT"), false),
+                "__VECTOR_FIELD;3; search embedding", true, null);
+        Schema source = PaimonSchemaBuilder.build(ConnectorCreateTableRequest.builder()
+                .dbName("db")
+                .tableName("paimon20")
+                .columns(Arrays.asList(blob, vector))
+                .build());
+
+        Schema converted = ColumnDirectiveUtils.applyDirectives(source);
+        DataField blobField = converted.fields().get(0);
+        DataField vectorField = converted.fields().get(1);
+        Assertions.assertEquals(new BlobType(), blobField.type());
+        Assertions.assertEquals("payload bytes", blobField.description());
+        Assertions.assertEquals(new VectorType(3, new FloatType(false)), vectorField.type());
+        Assertions.assertEquals("search embedding", vectorField.description());
+        Assertions.assertEquals("payload", converted.options().get(CoreOptions.BLOB_FIELD.key()));
+        Assertions.assertEquals("embedding", converted.options().get(CoreOptions.VECTOR_FIELD.key()));
+    }
 }
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonTypeMappingReadTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonTypeMappingReadTest.java
index 81d5e305f841e1..7b810ad9ed0fde 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonTypeMappingReadTest.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonTypeMappingReadTest.java
@@ -19,10 +19,14 @@
 
 import org.apache.doris.connector.spi.ConnectorType;
 
+import org.apache.paimon.types.BlobType;
 import org.apache.paimon.types.DataField;
+import org.apache.paimon.types.FloatType;
 import org.apache.paimon.types.IntType;
 import org.apache.paimon.types.RowType;
 import org.apache.paimon.types.VarCharType;
+import org.apache.paimon.types.VariantType;
+import org.apache.paimon.types.VectorType;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
@@ -81,4 +85,22 @@ public void nestedStructFieldCommentAndNullabilityCarried() {
         Assertions.assertTrue(struct.isChildNullable(1),
                 "a nullable nested struct field stays nullable");
     }
+
+    @Test
+    public void paimon20TypesMapToLosslessDorisTypes() {
+        ConnectorType blob = PaimonTypeMapping.toConnectorType(
+                new BlobType(), PaimonTypeMapping.Options.DEFAULT);
+        Assertions.assertEquals("VARBINARY", blob.getTypeName());
+
+        ConnectorType variant = PaimonTypeMapping.toConnectorType(
+                new VariantType(), PaimonTypeMapping.Options.DEFAULT);
+        Assertions.assertEquals("VARIANT", variant.getTypeName());
+
+        ConnectorType vector = PaimonTypeMapping.toConnectorType(
+                new VectorType(3, new FloatType(false)), PaimonTypeMapping.Options.DEFAULT);
+        Assertions.assertEquals("ARRAY", vector.getTypeName());
+        Assertions.assertEquals("FLOAT", vector.getChildren().get(0).getTypeName());
+        Assertions.assertFalse(vector.isChildNullable(0),
+                "Paimon VECTOR elements are dense and must remain non-null");
+    }
 }
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonWritePlanProviderTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonWritePlanProviderTest.java
new file mode 100644
index 00000000000000..4191b76874f0f4
--- /dev/null
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonWritePlanProviderTest.java
@@ -0,0 +1,310 @@
+// 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.doris.connector.paimon;
+
+import org.apache.doris.connector.spi.ConnectorColumn;
+import org.apache.doris.connector.spi.ConnectorSession;
+import org.apache.doris.connector.spi.DorisConnectorException;
+import org.apache.doris.connector.spi.handle.ConnectorTableHandle;
+import org.apache.doris.connector.spi.handle.ConnectorTransaction;
+import org.apache.doris.connector.spi.handle.ConnectorWriteHandle;
+import org.apache.doris.connector.spi.handle.WriteOperation;
+import org.apache.doris.connector.spi.write.ConnectorSinkPlan;
+import org.apache.doris.thrift.TDataSinkType;
+import org.apache.doris.thrift.TPaimonTableSink;
+import org.apache.doris.thrift.TPaimonWriteMode;
+
+import org.apache.paimon.catalog.Catalog;
+import org.apache.paimon.catalog.FileSystemCatalog;
+import org.apache.paimon.catalog.Identifier;
+import org.apache.paimon.fs.local.LocalFileIO;
+import org.apache.paimon.schema.Schema;
+import org.apache.paimon.schema.SchemaChange;
+import org.apache.paimon.types.DataTypes;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class PaimonWritePlanProviderTest {
+
+    private static final Identifier TABLE = Identifier.create("db", "t");
+
+    @TempDir
+    Path warehouse;
+
+    @Test
+    public void keepsWritesOnSingleWriterDistribution() throws Exception {
+        Assertions.assertFalse(fixture().provider.requiresParallelWrite());
+    }
+
+    @Test
+    public void plansJniAppendSinkThroughConnectorSpi() throws Exception {
+        Fixture fixture = fixture();
+        List<ConnectorColumn> columns = fixture.provider.getWriteColumns(
+                fixture.session, fixture.tableHandle, Optional.empty()).get();
+
+        ConnectorSinkPlan plan = fixture.provider.planWrite(
+                fixture.session, new WriteHandle(fixture.tableHandle, columns));
+        TPaimonTableSink sink = plan.getDataSink().getPaimonTableSink();
+
+        Assertions.assertEquals(TDataSinkType.PAIMON_TABLE_SINK, plan.getDataSink().getType());
+        Assertions.assertEquals(TPaimonWriteMode.APPEND, sink.getWriteMode());
+        Assertions.assertEquals(201L, sink.getTransactionId());
+        Assertions.assertEquals(fixture.transaction.getCommitUser(), sink.getCommitUser());
+        Assertions.assertEquals(java.util.Arrays.asList("id", "pt"), sink.getColumnNames());
+        Assertions.assertFalse(sink.getSerializedTable().isEmpty());
+    }
+
+    @Test
+    public void plansOverwriteAndCanonicalizesStaticPartitionName() throws Exception {
+        Fixture fixture = fixture();
+        List<ConnectorColumn> columns = fixture.provider.getWriteColumns(
+                fixture.session, fixture.tableHandle, Optional.empty()).get();
+        Map<String, String> partition = new LinkedHashMap<>();
+        partition.put("PT", "2026-08-14");
+
+        ConnectorSinkPlan plan = fixture.provider.planWrite(
+                fixture.session, new WriteHandle(fixture.tableHandle, columns)
+                        .overwrite(true).staticPartition(partition));
+
+        Assertions.assertEquals(
+                TPaimonWriteMode.OVERWRITE,
+                plan.getDataSink().getPaimonTableSink().getWriteMode());
+    }
+
+    @Test
+    public void rejectsNonPartitionStaticColumn() throws Exception {
+        Fixture fixture = fixture();
+        List<ConnectorColumn> columns = fixture.provider.getWriteColumns(
+                fixture.session, fixture.tableHandle, Optional.empty()).get();
+
+        DorisConnectorException exception = Assertions.assertThrows(
+                DorisConnectorException.class,
+                () -> fixture.provider.planWrite(
+                        fixture.session, new WriteHandle(fixture.tableHandle, columns)
+                                .staticPartition(Collections.singletonMap("id", "1"))));
+
+        Assertions.assertTrue(exception.getMessage().contains("not a partition column"));
+    }
+
+    @Test
+    public void rejectsSchemaDriftAfterTargetBinding() throws Exception {
+        Fixture fixture = fixture();
+        List<ConnectorColumn> boundColumns = fixture.provider.getWriteColumns(
+                fixture.session, fixture.tableHandle, Optional.empty()).get();
+        fixture.catalog.alterTable(
+                TABLE, SchemaChange.addColumn("extra", DataTypes.BIGINT()), false);
+
+        DorisConnectorException exception = Assertions.assertThrows(
+                DorisConnectorException.class,
+                () -> fixture.provider.planWrite(
+                        fixture.session, new WriteHandle(fixture.tableHandle, boundColumns)));
+
+        Assertions.assertTrue(exception.getMessage().contains("metadata changed"));
+    }
+
+    @Test
+    public void rejectsUnsupportedWriteOperation() throws Exception {
+        Fixture fixture = fixture();
+        List<ConnectorColumn> columns = fixture.provider.getWriteColumns(
+                fixture.session, fixture.tableHandle, Optional.empty()).get();
+
+        Assertions.assertThrows(
+                DorisConnectorException.class,
+                () -> fixture.provider.planWrite(
+                        fixture.session, new WriteHandle(fixture.tableHandle, columns)
+                                .operation(WriteOperation.DELETE)));
+    }
+
+    @Test
+    public void exposesPinnedWriteNullabilityAndDefaults() throws Exception {
+        Catalog catalog = new FileSystemCatalog(
+                LocalFileIO.create(), new org.apache.paimon.fs.Path(warehouse.toUri()));
+        catalog.createDatabase("db", false);
+        catalog.createTable(TABLE, Schema.newBuilder()
+                .column("required_col", DataTypes.INT().notNull())
+                .column("default_col", DataTypes.STRING(), null, "'fallback'")
+                .build(), false);
+        PaimonCatalogOps ops = new PaimonCatalogOps.CatalogBackedPaimonCatalogOps(catalog);
+        PaimonWritePlanProvider provider = new PaimonWritePlanProvider(
+                PaimonCatalogProperties.of(Collections.emptyMap()),
+                ops,
+                new RecordingConnectorContext());
+        List<ConnectorColumn> columns = provider.getWriteColumns(
+                new WriteSession(new PaimonConnectorTransaction(
+                        202L, ops, new RecordingConnectorContext())),
+                new PaimonTableHandle("db", "t", Collections.emptyList(), Collections.emptyList()),
+                Optional.empty()).get();
+
+        Assertions.assertFalse(columns.get(0).isNullable());
+        Assertions.assertNull(columns.get(0).getDefaultValueSql());
+        Assertions.assertTrue(columns.get(1).isNullable());
+        Assertions.assertEquals("'fallback'", columns.get(1).getDefaultValueSql());
+    }
+
+    private Fixture fixture() throws Exception {
+        Catalog catalog = new FileSystemCatalog(
+                LocalFileIO.create(), new org.apache.paimon.fs.Path(warehouse.toUri()));
+        catalog.createDatabase("db", false);
+        catalog.createTable(TABLE, Schema.newBuilder()
+                .column("id", DataTypes.INT())
+                .column("pt", DataTypes.STRING())
+                .partitionKeys("pt")
+                .build(), false);
+        PaimonCatalogOps ops = new PaimonCatalogOps.CatalogBackedPaimonCatalogOps(catalog);
+        RecordingConnectorContext context = new RecordingConnectorContext();
+        PaimonConnectorTransaction transaction = new PaimonConnectorTransaction(201L, ops, context);
+        WriteSession session = new WriteSession(transaction);
+        PaimonWritePlanProvider provider = new PaimonWritePlanProvider(
+                PaimonCatalogProperties.of(Collections.emptyMap()), ops, context);
+        PaimonTableHandle tableHandle = new PaimonTableHandle(
+                "db", "t", Collections.singletonList("pt"), Collections.emptyList());
+        return new Fixture(catalog, provider, transaction, session, tableHandle);
+    }
+
+    private static final class Fixture {
+        private final Catalog catalog;
+        private final PaimonWritePlanProvider provider;
+        private final PaimonConnectorTransaction transaction;
+        private final WriteSession session;
+        private final PaimonTableHandle tableHandle;
+
+        private Fixture(Catalog catalog, PaimonWritePlanProvider provider,
+                PaimonConnectorTransaction transaction, WriteSession session,
+                PaimonTableHandle tableHandle) {
+            this.catalog = catalog;
+            this.provider = provider;
+            this.transaction = transaction;
+            this.session = session;
+            this.tableHandle = tableHandle;
+        }
+    }
+
+    private static final class WriteHandle implements ConnectorWriteHandle {
+        private final ConnectorTableHandle tableHandle;
+        private final List<ConnectorColumn> columns;
+        private boolean overwrite;
+        private Map<String, String> staticPartition = Collections.emptyMap();
+        private WriteOperation operation = WriteOperation.INSERT;
+
+        private WriteHandle(ConnectorTableHandle tableHandle, List<ConnectorColumn> columns) {
+            this.tableHandle = tableHandle;
+            this.columns = columns;
+        }
+
+        private WriteHandle overwrite(boolean value) {
+            overwrite = value;
+            return this;
+        }
+
+        private WriteHandle staticPartition(Map<String, String> value) {
+            staticPartition = value;
+            return this;
+        }
+
+        private WriteHandle operation(WriteOperation value) {
+            operation = value;
+            return this;
+        }
+
+        @Override
+        public ConnectorTableHandle getTableHandle() {
+            return tableHandle;
+        }
+
+        @Override
+        public List<ConnectorColumn> getColumns() {
+            return columns;
+        }
+
+        @Override
+        public boolean isOverwrite() {
+            return overwrite;
+        }
+
+        @Override
+        public Map<String, String> getStaticPartitionSpec() {
+            return staticPartition;
+        }
+
+        @Override
+        public WriteOperation getWriteOperation() {
+            return operation;
+        }
+    }
+
+    private static final class WriteSession implements ConnectorSession {
+        private final ConnectorTransaction transaction;
+
+        private WriteSession(ConnectorTransaction transaction) {
+            this.transaction = transaction;
+        }
+
+        @Override
+        public Optional<ConnectorTransaction> getCurrentTransaction() {
+            return Optional.of(transaction);
+        }
+
+        @Override
+        public String getQueryId() {
+            return "q";
+        }
+
+        @Override
+        public String getUser() {
+            return "u";
+        }
+
+        @Override
+        public String getTimeZone() {
+            return "UTC";
+        }
+
+        @Override
+        public String getLocale() {
+            return "en_US";
+        }
+
+        @Override
+        public <T> T getProperty(String name, Class<T> type) {
+            return null;
+        }
+
+        @Override
+        public long getCatalogId() {
+            return 1L;
+        }
+
+        @Override
+        public String getCatalogName() {
+            return "test";
+        }
+
+        @Override
+        public Map<String, String> getCatalogProperties() {
+            return Collections.emptyMap();
+        }
+    }
+}
diff --git a/fe/fe-core/src/main/java/org/apache/doris/qe/AbstractJobProcessor.java b/fe/fe-core/src/main/java/org/apache/doris/qe/AbstractJobProcessor.java
index 991f839a511bf4..a0106559575807 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/qe/AbstractJobProcessor.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/qe/AbstractJobProcessor.java
@@ -92,7 +92,7 @@ public final boolean updateFragmentExecStatus(TReportExecStatusParams params) {
                 new BackendFragmentId(params.getBackendId(), params.getFragmentId()));
         if (fragmentTask == null) {
             if (params.isSetHivePartitionUpdates() || params.isSetIcebergCommitDatas()
-                    || params.isSetMcCommitDatas()) {
+                    || params.isSetMcCommitDatas() || params.isSetPaimonCommitMessages()) {
                 throw new IllegalStateException("Missing fragment handler for external-file report");
             }
             return false;
@@ -122,7 +122,8 @@ public final boolean updateFragmentExecStatus(TReportExecStatusParams params) {
         }
         doProcessReportExecStatus(params, fragmentTask);
         return !params.isSetHivePartitionUpdates() && !params.isSetIcebergCommitDatas()
-                && !params.isSetMcCommitDatas() || fragmentTask.isDone();
+                && !params.isSetMcCommitDatas() && !params.isSetPaimonCommitMessages()
+                || fragmentTask.isDone();
     }
 
     private Map<BackendFragmentId, SingleFragmentPipelineTask> buildBackendFragmentTasks(
diff --git a/fe/fe-core/src/main/java/org/apache/doris/qe/Coordinator.java b/fe/fe-core/src/main/java/org/apache/doris/qe/Coordinator.java
index 06006086d4dfaa..dbbdb51ccd4e44 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/qe/Coordinator.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/qe/Coordinator.java
@@ -2580,7 +2580,8 @@ public boolean updateFragmentExecStatus(TReportExecStatusParams params) {
 
         PipelineExecContext ctx = pipelineExecContexts.get(Pair.of(params.getFragmentId(), params.getBackendId()));
         boolean hasExternalCommitData = params.isSetHivePartitionUpdates()
-                || params.isSetIcebergCommitDatas() || params.isSetMcCommitDatas();
+                || params.isSetIcebergCommitDatas() || params.isSetMcCommitDatas()
+                || params.isSetPaimonCommitMessages();
         if (ctx == null) {
             if (hasExternalCommitData) {
                 throw new IllegalStateException("Missing fragment handler for external-file report");
@@ -2651,7 +2652,7 @@ public boolean updateFragmentExecStatus(TReportExecStatusParams params) {
                 updateErrorTabletInfos(params.getErrorTabletInfos());
             }
             if (params.isSetHivePartitionUpdates() || params.isSetIcebergCommitDatas()
-                    || params.isSetMcCommitDatas()) {
+                    || params.isSetMcCommitDatas() || params.isSetPaimonCommitMessages()) {
                 Transaction txn = Env.getCurrentEnv().getGlobalExternalTransactionInfoMgr().getTxnById(reportTxnId);
                 if (params.isSetHivePartitionUpdates()) {
                     CommitDataSerializer.feed(txn, params.getHivePartitionUpdates());
@@ -2662,6 +2663,9 @@ public boolean updateFragmentExecStatus(TReportExecStatusParams params) {
                 if (params.isSetMcCommitDatas()) {
                     CommitDataSerializer.feed(txn, params.getMcCommitDatas());
                 }
+                if (params.isSetPaimonCommitMessages()) {
+                    CommitDataSerializer.feed(txn, params.getPaimonCommitMessages());
+                }
             }
 
             accepted = true;
diff --git a/fe/fe-core/src/main/java/org/apache/doris/qe/QeProcessorImpl.java b/fe/fe-core/src/main/java/org/apache/doris/qe/QeProcessorImpl.java
index eafbb23dfc704e..a3eae6fd7094a5 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/qe/QeProcessorImpl.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/qe/QeProcessorImpl.java
@@ -335,7 +335,8 @@ public TReportExecStatusResult reportExecStatus(TReportExecStatusParams params,
     }
 
     private static boolean hasExternalCommitData(TReportExecStatusParams params) {
-        return params.isSetHivePartitionUpdates() || params.isSetIcebergCommitDatas() || params.isSetMcCommitDatas();
+        return params.isSetHivePartitionUpdates() || params.isSetIcebergCommitDatas()
+                || params.isSetMcCommitDatas() || params.isSetPaimonCommitMessages();
     }
 
     private static String externalFileReportKey(TReportExecStatusParams params) {
diff --git a/fe/fe-core/src/main/java/org/apache/doris/qe/runtime/LoadProcessor.java b/fe/fe-core/src/main/java/org/apache/doris/qe/runtime/LoadProcessor.java
index d4878ff99a3d6c..4da0db11e5651f 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/qe/runtime/LoadProcessor.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/qe/runtime/LoadProcessor.java
@@ -188,7 +188,8 @@ protected void doProcessReportExecStatus(TReportExecStatusParams params, SingleF
 
         if (!fragmentTask.processReportExecStatus(params, () -> acceptFinalReport(params))) {
             if ((params.isSetHivePartitionUpdates() || params.isSetIcebergCommitDatas()
-                    || params.isSetMcCommitDatas()) && !fragmentTask.isDone()) {
+                    || params.isSetMcCommitDatas() || params.isSetPaimonCommitMessages())
+                    && !fragmentTask.isDone()) {
                 throw new IllegalStateException("External-file report was not a completed fragment report");
             }
             LOG.debug("Fragment {} is not done, ignore report status: {}",
@@ -246,7 +247,8 @@ private void acceptFinalReport(TReportExecStatusParams params) {
             loadContext.updateErrorTabletInfos(params.getErrorTabletInfos());
         }
         long txnId = loadContext.getTransactionId();
-        if (params.isSetHivePartitionUpdates() || params.isSetIcebergCommitDatas() || params.isSetMcCommitDatas()) {
+        if (params.isSetHivePartitionUpdates() || params.isSetIcebergCommitDatas()
+                || params.isSetMcCommitDatas() || params.isSetPaimonCommitMessages()) {
             Transaction txn = Env.getCurrentEnv().getGlobalExternalTransactionInfoMgr().getTxnById(txnId);
             if (params.isSetHivePartitionUpdates()) {
                 CommitDataSerializer.feed(txn, params.getHivePartitionUpdates());
@@ -257,6 +259,9 @@ private void acceptFinalReport(TReportExecStatusParams params) {
             if (params.isSetMcCommitDatas()) {
                 CommitDataSerializer.feed(txn, params.getMcCommitDatas());
             }
+            if (params.isSetPaimonCommitMessages()) {
+                CommitDataSerializer.feed(txn, params.getPaimonCommitMessages());
+            }
         }
     }
 
diff --git a/fe/fe-core/src/test/java/org/apache/doris/qe/QeProcessorImplReportAckTest.java b/fe/fe-core/src/test/java/org/apache/doris/qe/QeProcessorImplReportAckTest.java
index 2e15875c73ffd0..3c8b7f99c3a0b7 100644
--- a/fe/fe-core/src/test/java/org/apache/doris/qe/QeProcessorImplReportAckTest.java
+++ b/fe/fe-core/src/test/java/org/apache/doris/qe/QeProcessorImplReportAckTest.java
@@ -22,6 +22,7 @@
 import org.apache.doris.system.Backend;
 import org.apache.doris.thrift.TIcebergCommitData;
 import org.apache.doris.thrift.TNetworkAddress;
+import org.apache.doris.thrift.TPaimonCommitMessage;
 import org.apache.doris.thrift.TQueryOptions;
 import org.apache.doris.thrift.TReportExecStatusParams;
 import org.apache.doris.thrift.TReportExecStatusResult;
@@ -57,6 +58,14 @@ void rejectsExternalReportWithoutCoordinator() {
         Assertions.assertFalse(result.isExternalFileCommitDataAccepted());
     }
 
+    @Test
+    void rejectsPaimonReportWithoutCoordinator() {
+        TReportExecStatusResult result = report(paimonParams(new TUniqueId(12345, 6)));
+
+        Assertions.assertEquals(TStatusCode.INTERNAL_ERROR, result.getStatus().getStatusCode());
+        Assertions.assertFalse(result.isExternalFileCommitDataAccepted());
+    }
+
     @Test
     void rejectsExternalReportWhenHandlerThrows() throws Exception {
         TUniqueId queryId = new TUniqueId(12345, 2);
@@ -152,13 +161,22 @@ private Coordinator register(TUniqueId queryId) throws Exception {
     }
 
     private static TReportExecStatusParams params(TUniqueId queryId) {
+        return baseParams(queryId)
+                .setIcebergCommitDatas(Collections.<TIcebergCommitData>emptyList());
+    }
+
+    private static TReportExecStatusParams paimonParams(TUniqueId queryId) {
+        return baseParams(queryId)
+                .setPaimonCommitMessages(Collections.<TPaimonCommitMessage>emptyList());
+    }
+
+    private static TReportExecStatusParams baseParams(TUniqueId queryId) {
         return new TReportExecStatusParams()
                 .setQueryId(queryId)
                 .setFragmentId(7)
                 .setBackendId(9)
                 .setDone(true)
-                .setStatus(new TStatus(TStatusCode.OK))
-                .setIcebergCommitDatas(Collections.<TIcebergCommitData>emptyList());
+                .setStatus(new TStatus(TStatusCode.OK));
     }
 
     private static TReportExecStatusResult report(TReportExecStatusParams params) {
diff --git a/fe/fe-core/src/test/java/org/apache/doris/transaction/CommitDataSerializerTest.java b/fe/fe-core/src/test/java/org/apache/doris/transaction/CommitDataSerializerTest.java
index da2f9767847984..069622d2fce3ba 100644
--- a/fe/fe-core/src/test/java/org/apache/doris/transaction/CommitDataSerializerTest.java
+++ b/fe/fe-core/src/test/java/org/apache/doris/transaction/CommitDataSerializerTest.java
@@ -21,6 +21,7 @@
 import org.apache.doris.thrift.THivePartitionUpdate;
 import org.apache.doris.thrift.TIcebergCommitData;
 import org.apache.doris.thrift.TMCCommitData;
+import org.apache.doris.thrift.TPaimonCommitMessage;
 import org.apache.doris.thrift.TUpdateMode;
 
 import org.apache.thrift.TBase;
@@ -77,6 +78,10 @@ private static TIcebergCommitData icebergData(String filePath, long rowCount) {
                 .setPartitionValues(Arrays.asList("2026", "06"));
     }
 
+    private static TPaimonCommitMessage paimonData(byte[] payload, long rowCount) {
+        return new TPaimonCommitMessage().setPayload(payload).setRowCount(rowCount);
+    }
+
     private static void assertBinaryRoundTrip(TBase<?, ?> original, TBase<?, ?> target)
             throws Exception {
         byte[] bytes = new TSerializer(new TBinaryProtocol.Factory()).serialize(original);
@@ -94,6 +99,7 @@ public void binaryProtocolRoundTripIsLossless() throws Exception {
         assertBinaryRoundTrip(mcData("session-1", 42L, "bWMtcGF5bG9hZA=="), new TMCCommitData());
         assertBinaryRoundTrip(hiveData("dt=2026-06-06", 7L, "f1", "f2"), new THivePartitionUpdate());
         assertBinaryRoundTrip(icebergData("s3://b/data/0.parquet", 11L), new TIcebergCommitData());
+        assertBinaryRoundTrip(paimonData(new byte[] {1, 2, 3}, 13L), new TPaimonCommitMessage());
     }
 
     /**
@@ -137,4 +143,37 @@ public void addCommitData(byte[] commitFragment) {
         }
     }
 
+    @Test
+    public void paimonFeedDeliversEachFragmentLosslessly() throws Exception {
+        List<TPaimonCommitMessage> input = Arrays.asList(
+                paimonData(new byte[] {1, 2, 3}, 11L),
+                paimonData(new byte[] {4, 5, 6}, 13L));
+        List<byte[]> payloads = new ArrayList<>();
+        Transaction collector = new Transaction() {
+            @Override
+            public void commit() {
+                throw new UnsupportedOperationException("commit not expected in this test");
+            }
+
+            @Override
+            public void rollback() {
+                throw new UnsupportedOperationException("rollback not expected in this test");
+            }
+
+            @Override
+            public void addCommitData(byte[] commitFragment) {
+                payloads.add(commitFragment);
+            }
+        };
+
+        CommitDataSerializer.feed(collector, input);
+
+        Assert.assertEquals(input.size(), payloads.size());
+        for (int i = 0; i < input.size(); i++) {
+            TPaimonCommitMessage roundTripped = new TPaimonCommitMessage();
+            new TDeserializer(new TBinaryProtocol.Factory()).deserialize(roundTripped, payloads.get(i));
+            Assert.assertEquals(input.get(i), roundTripped);
+        }
+    }
+
 }
diff --git a/gensrc/thrift/DataSinks.thrift b/gensrc/thrift/DataSinks.thrift
index d2cb4d534bb49b..97764d92193a84 100644
--- a/gensrc/thrift/DataSinks.thrift
+++ b/gensrc/thrift/DataSinks.thrift
@@ -46,6 +46,7 @@ enum TDataSinkType {
     MAXCOMPUTE_TABLE_SINK = 18,
     ICEBERG_DELETE_SINK = 19,
     ICEBERG_MERGE_SINK = 20,
+    PAIMON_TABLE_SINK = 21,
 }
 
 enum TResultSinkType {
@@ -625,6 +626,25 @@ struct TMaxComputeTableSink {
     18: optional i64 txn_id                       // FE external transaction ID for runtime block_id allocation
 }
 
+enum TPaimonWriteMode {
+    APPEND = 0,
+    OVERWRITE = 1,
+}
+
+struct TPaimonCommitMessage {
+    1: optional binary payload          // Paimon CommitMessageSerializer bytes (DPCM-framed)
+    2: optional i64 row_count            // set once per BE writer, on its first payload
+}
+
+struct TPaimonTableSink {
+    1: optional string serialized_table // serialized Paimon FileStoreTable object (base64)
+    2: optional map<string, string> hadoop_config
+    3: optional list<string> column_names
+    4: optional TPaimonWriteMode write_mode
+    5: optional i64 transaction_id
+    6: optional string commit_user
+}
+
 struct TDataSink {
   1: required TDataSinkType type
   2: optional TDataStreamSink stream_sink
@@ -645,4 +665,5 @@ struct TDataSink {
   18: optional TMaxComputeTableSink max_compute_table_sink
   19: optional TIcebergDeleteSink iceberg_delete_sink
   20: optional TIcebergMergeSink iceberg_merge_sink
+  21: optional TPaimonTableSink paimon_table_sink
 }
diff --git a/gensrc/thrift/FrontendService.thrift b/gensrc/thrift/FrontendService.thrift
index 38452f0b1d78a0..106ae649ab879f 100644
--- a/gensrc/thrift/FrontendService.thrift
+++ b/gensrc/thrift/FrontendService.thrift
@@ -338,6 +338,8 @@ struct TReportExecStatusParams {
   32: optional list<DataSinks.TMCCommitData> mc_commit_datas
 
   33: optional string first_error_msg
+
+  34: optional list<DataSinks.TPaimonCommitMessage> paimon_commit_messages
 }
 
 struct TFeResult {
diff --git a/regression-test/data/external_table_p0/paimon/test_paimon_ctas_atomicity_negative.out b/regression-test/data/external_table_p0/paimon/test_paimon_ctas_atomicity_negative.out
new file mode 100644
index 00000000000000..baa7292a4f8f80
--- /dev/null
+++ b/regression-test/data/external_table_p0/paimon/test_paimon_ctas_atomicity_negative.out
@@ -0,0 +1,9 @@
+-- This file is automatically generated. You should know what you did if you want to edit this
+-- !ctas_rows --
+1	candidate
+
+-- !after_if_not_exists --
+1	candidate
+
+-- !after_existing_target_error --
+1	candidate
diff --git a/regression-test/data/external_table_p0/paimon/test_paimon_write_boundary.out b/regression-test/data/external_table_p0/paimon/test_paimon_write_boundary.out
index f1118d0bd7069e..1694d2c41d00f1 100644
--- a/regression-test/data/external_table_p0/paimon/test_paimon_write_boundary.out
+++ b/regression-test/data/external_table_p0/paimon/test_paimon_write_boundary.out
@@ -6,10 +6,22 @@
 -- !before_snapshots --
 1
 
--- !after_rows --
+-- !after_insert_values --
 1	10	base-1
 2	20	base-2
+3	30	insert-values
 
--- !after_snapshots --
-1
+-- !after_insert_select --
+1	10	base-1
+2	20	base-2
+3	30	insert-values
+4	40	insert-select
 
+-- !after_overwrite --
+5	50	overwrite
+
+-- !after_rows --
+5	50	overwrite
+
+-- !after_snapshots --
+4
diff --git a/regression-test/suites/external_table_p0/paimon/test_paimon_ctas_atomicity_negative.groovy b/regression-test/suites/external_table_p0/paimon/test_paimon_ctas_atomicity_negative.groovy
index 034bb9581a322f..e359b298b3b404 100644
--- a/regression-test/suites/external_table_p0/paimon/test_paimon_ctas_atomicity_negative.groovy
+++ b/regression-test/suites/external_table_p0/paimon/test_paimon_ctas_atomicity_negative.groovy
@@ -50,32 +50,22 @@ suite("test_paimon_ctas_atomicity_negative",
         sql """switch ${catalogName}"""
         sql """use ${dbName}"""
 
-        // A failed CTAS must not leave metadata that makes a retry fail with TABLE ALREADY EXISTS.
-        // On the connector-SPI path the sink rejection is worded by the connector's declared write
-        // capabilities (the paimon connector declares none) rather than by the legacy fe-core
-        // "Load data to PaimonExternalCatalog is not supported"; the CTAS still fails at the same point.
-        test {
-            sql """
-                create table ctas_target engine=paimon
-                as select cast(1 as int) as id, cast('candidate' as string) as payload
-            """
-            exception "does not support INSERT operations"
-        }
-        assertEquals(0, (sql """show tables like 'ctas_target'""").size())
-
-        spark_paimon """
-            create table paimon.${dbName}.ctas_target (id int, payload string)
-            using paimon
+        sql """
+            create table ctas_target engine=paimon
+            as select cast(1 as int) as id, cast('candidate' as string) as payload
         """
-        // IF NOT EXISTS must remain a no-op even though Paimon does not support the CTAS sink.
+        assertEquals(1, (sql """show tables like 'ctas_target'""").size())
+        order_qt_ctas_rows """select id, payload from ctas_target"""
+
+        // IF NOT EXISTS remains a no-op and must not append the SELECT result.
         sql """
             create table if not exists ctas_target engine=paimon
-            as select cast(1 as int) as id, cast('candidate' as string) as payload
+            as select cast(2 as int) as id, cast('ignored' as string) as payload
         """
         assertEquals(1, (sql """show tables like 'ctas_target'""").size())
-        assertEquals(0, (sql """select * from ctas_target""").size())
+        order_qt_after_if_not_exists """select id, payload from ctas_target"""
 
-        // An existing non-idempotent target must keep catalog error precedence; no sink can own it.
+        // An existing non-idempotent target keeps catalog error precedence and existing data.
         test {
             sql """
                 create table ctas_target engine=paimon
@@ -83,7 +73,7 @@ suite("test_paimon_ctas_atomicity_negative",
             """
             exception "already exists"
         }
-        assertEquals(0, (sql """select * from ctas_target""").size())
+        order_qt_after_existing_target_error """select id, payload from ctas_target"""
     } finally {
         spark_paimon """drop table if exists paimon.${dbName}.ctas_target"""
         sql """drop catalog if exists ${catalogName}"""
diff --git a/regression-test/suites/external_table_p0/paimon/test_paimon_write_boundary.groovy b/regression-test/suites/external_table_p0/paimon/test_paimon_write_boundary.groovy
index 84fd84ce342699..cd12cfe31c03e4 100644
--- a/regression-test/suites/external_table_p0/paimon/test_paimon_write_boundary.groovy
+++ b/regression-test/suites/external_table_p0/paimon/test_paimon_write_boundary.groovy
@@ -64,28 +64,17 @@ suite("test_paimon_write_boundary",
         qt_before_rows """select id, score, note from write_boundary order by id"""
         qt_before_snapshots """select count(*) from write_boundary\$snapshots"""
 
-        // WB01-WB06 preserve the documented data-write boundary at analysis time. The source table
-        // and its snapshot list must stay unchanged after every rejected write shape.
-        //
-        // The INSERT-family rejections are worded by the connector-SPI path, not by the legacy fe-core
-        // one: a paimon catalog is a PluginDrivenExternalCatalog, so UnboundTableSinkCreator builds an
-        // UnboundConnectorTableSink instead of throwing "Load data to PaimonExternalCatalog is not
-        // supported", and the rejection lands on the connector's declared write capabilities (the paimon
-        // connector declares none). The boundary asserted here is identical -- every write shape is still
-        // rejected at analysis time and the table is untouched -- only the message differs.
-        test {
-            sql """insert into write_boundary values (3, 30, 'insert-values')"""
-            exception "does not support INSERT operations"
-        }
-        test {
-            sql """insert into write_boundary select 3, 30, 'insert-select'"""
-            exception "does not support INSERT operations"
-        }
-        test {
-            // INSERT OVERWRITE is gated earlier, by InsertOverwriteTableCommand's allowInsertOverwrite.
-            sql """insert overwrite table write_boundary values (3, 30, 'overwrite')"""
-            exception "insert into overwrite only support"
-        }
+        sql """insert into write_boundary values (3, 30, 'insert-values')"""
+        order_qt_after_insert_values """select id, score, note from write_boundary"""
+
+        sql """insert into write_boundary select 4, 40, 'insert-select'"""
+        order_qt_after_insert_select """select id, score, note from write_boundary"""
+
+        sql """insert overwrite table write_boundary values (5, 50, 'overwrite')"""
+        order_qt_after_overwrite """select id, score, note from write_boundary"""
+
+        // Row-level mutation remains an OLAP-table-only command. Paimon upserts are performed
+        // through INSERT statements against primary-key tables.
         test {
             sql """update write_boundary set score = score + 1 where id = 1"""
             exception "target table in update command should be an olapTable"

From 4bf87856d4d6a6a482b6471760b8102be208ba20 Mon Sep 17 00:00:00 2001
From: moke-HU <25567926679@qq.com>
Date: Sat, 15 Aug 2026 00:33:07 +0800
Subject: [PATCH 3/7] fix(paimon): package file format factories

---
 fe/fe-connector/fe-connector-paimon/pom.xml | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/fe/fe-connector/fe-connector-paimon/pom.xml b/fe/fe-connector/fe-connector-paimon/pom.xml
index c8a1d100bf7772..6f81ba6e121c93 100644
--- a/fe/fe-connector/fe-connector-paimon/pom.xml
+++ b/fe/fe-connector/fe-connector-paimon/pom.xml
@@ -288,17 +288,15 @@ under the License.
             <scope>test</scope>
         </dependency>
 
-        <!-- TEST ONLY: the offline FE->BE serde round-trip smoke
-             (PaimonTableSerdeRoundTripTest) builds a REAL local-filesystem catalog and
-             createTable()'s a table; paimon's table writer/validator resolves the default
-             'parquet' FileFormatFactory, which ships in paimon-format. This is already on the FE
-             runtime classpath in fe-core and on BE's paimon-scanner classpath, so it is not a new
-             runtime dependency for the connector — only the offline smoke needs it at test time.
-             Version comes from dependencyManagement (${paimon.version}, R-007). -->
+        <!-- Paimon resolves parquet/orc/blob formats through FileFormatFactory's ServiceLoader.
+             Connector plugins run child-first and cannot rely on fe-core's flat classpath, so the
+             format implementation and its META-INF/services entry must ship in the plugin ZIP.
+             Without this runtime dependency, catalog listing works but loading any parquet-backed
+             table fails with "Could not find any factory for identifier 'parquet'". Version comes
+             from dependencyManagement (${paimon.version}, R-007). -->
         <dependency>
             <groupId>org.apache.paimon</groupId>
             <artifactId>paimon-format</artifactId>
-            <scope>test</scope>
         </dependency>
 
         <!-- TEST ONLY: the buildRealDataSplit-based tests (count-pushdown / native sub-split /

From da65d9f70750ed5aa8e53b76d01412c5c38385a7 Mon Sep 17 00:00:00 2001
From: moke-HU <25567926679@qq.com>
Date: Sat, 15 Aug 2026 01:07:30 +0800
Subject: [PATCH 4/7] fix(paimon): allow varbinary in external table DDL

---
 .../plans/commands/CreateTableCommand.java    |  3 --
 .../plans/commands/info/CreateTableInfo.java  |  2 +-
 .../CreateTableInfoEngineCatalogTest.java     | 34 +++++++++++++++++++
 3 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/CreateTableCommand.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/CreateTableCommand.java
index 3031e67be7d9c2..446c4380437d5d 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/CreateTableCommand.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/CreateTableCommand.java
@@ -170,9 +170,6 @@ public void validateCreateTableAsSelect(ConnectContext ctx, LogicalPlan query) {
         for (int i = 0; i < slots.size(); i++) {
             Slot s = slots.get(i);
             DataType dataType = s.getDataType().conversion();
-            if (dataType.isVarBinaryType()) {
-                throw new AnalysisException("doris do not support varbinary create table, could use it by catalog");
-            }
             if (i == 0 && dataType.isStringType()) {
                 // first column of olap table can not be string type.
                 // So change it to varchar type.
diff --git a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/info/CreateTableInfo.java b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/info/CreateTableInfo.java
index b806a6b6ee8cb8..ebd5d5876a4f51 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/info/CreateTableInfo.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/commands/info/CreateTableInfo.java
@@ -460,7 +460,7 @@ public void validate(ConnectContext ctx) {
                 throw new AnalysisException(
                         "Disable to create table column with name start with __DORIS_: " + columnNameUpperCase);
             }
-            if (columnDef.getType().isVarBinaryType()) {
+            if (targetIsInternalCatalog && columnDef.getType().isVarBinaryType()) {
                 throw new AnalysisException("doris do not support varbinary create table, could use it by catalog");
             }
             if (columnDef.getType().isVariantType()) {
diff --git a/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/plans/commands/info/CreateTableInfoEngineCatalogTest.java b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/plans/commands/info/CreateTableInfoEngineCatalogTest.java
index c1d42a12ddd973..dfe99d1f6d0085 100644
--- a/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/plans/commands/info/CreateTableInfoEngineCatalogTest.java
+++ b/fe/fe-core/src/test/java/org/apache/doris/nereids/trees/plans/commands/info/CreateTableInfoEngineCatalogTest.java
@@ -22,8 +22,12 @@
 import org.apache.doris.datasource.CatalogMgr;
 import org.apache.doris.datasource.InternalCatalog;
 import org.apache.doris.datasource.plugin.PluginDrivenExternalCatalog;
+import org.apache.doris.mysql.privilege.AccessControllerManager;
+import org.apache.doris.nereids.StatementContext;
 import org.apache.doris.nereids.exceptions.AnalysisException;
+import org.apache.doris.nereids.types.VarBinaryType;
 import org.apache.doris.qe.ConnectContext;
+import org.apache.doris.qe.OriginStatement;
 
 import com.google.common.collect.Lists;
 import org.junit.jupiter.api.AfterEach;
@@ -69,6 +73,11 @@ public void setUp() {
         Env mockEnv = Mockito.mock(Env.class);
         catalogMgr = Mockito.mock(CatalogMgr.class);
         Mockito.when(mockEnv.getCatalogMgr()).thenReturn(catalogMgr);
+        AccessControllerManager accessManager = Mockito.mock(AccessControllerManager.class);
+        Mockito.when(accessManager.checkTblPriv(Mockito.nullable(ConnectContext.class),
+                Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.any()))
+                .thenReturn(true);
+        Mockito.when(mockEnv.getAccessManager()).thenReturn(accessManager);
         mockedEnv = Mockito.mockStatic(Env.class);
         mockedEnv.when(Env::getCurrentEnv).thenReturn(mockEnv);
     }
@@ -145,6 +154,31 @@ public void noEngineOnExternalCatalogLeavesNoEngineName() throws Throwable {
                 "a no-ENGINE CREATE TABLE on an external catalog must not have an engine name invented for it");
     }
 
+    @Test
+    public void externalCatalogAllowsVarbinaryColumns() {
+        registerExternalCatalog("paimon_ctl", "paimon");
+        CreateTableInfo info = new CreateTableInfo(false, false, false,
+                "paimon_ctl", "db", "tbl",
+                Lists.newArrayList(new ColumnDefinition("payload", VarBinaryType.INSTANCE, true)),
+                new ArrayList<>(), "paimon", null,
+                new ArrayList<>(), null, PartitionTableInfo.EMPTY, null,
+                new ArrayList<>(), new HashMap<>(), new HashMap<>(), new ArrayList<>());
+
+        ConnectContext previousContext = ConnectContext.get();
+        ConnectContext context = new ConnectContext();
+        context.setStatementContext(new StatementContext(context, new OriginStatement("", 0)));
+        context.setThreadLocalInfo();
+        try {
+            Assertions.assertDoesNotThrow(() -> info.validate(context),
+                    "VARBINARY is unsupported only by internal Doris tables; external catalogs own their types");
+        } finally {
+            ConnectContext.remove();
+            if (previousContext != null) {
+                previousContext.setThreadLocalInfo();
+            }
+        }
+    }
+
     @Test
     public void noEngineOnTheInternalCatalogStillPadsOlap() throws Throwable {
         registerInternalCatalog("internal");

From 8ab3d8f2f6743f305328be64f8add5458e720b38 Mon Sep 17 00:00:00 2001
From: moke-HU <25567926679@qq.com>
Date: Sat, 15 Aug 2026 09:13:30 +0800
Subject: [PATCH 5/7] [fix](paimon) support Paimon 2.0 VARIANT and Vortex reads

Paimon 2.0 stores VARIANT as a physical value/metadata struct and ships the Vortex format in a separate module. Native Parquet reads expose the physical struct instead of the logical value.

Encode legacy Doris VARIANT columns into the Paimon binary struct, decode JNI reads into both VARIANT generations, route recursive VARIANT projections through JNI, and package the Vortex runtime. Preserve scalar, SQL NULL, encoded JSON null, row tracking, and native scalar-only read behavior.

Tests: connector reactor (551 tests); Paimon scanner reactor (85 tests); Paimon regression suite; focused C++ tests; clang-format; git diff --check.
---
 be/src/core/column/column_variant.cpp         |  49 ++++---
 .../data_type_variant_serde.cpp               |  80 ++++++++++-
 be/src/format/jni/jni_data_bridge.cpp         |  31 +++-
 .../data_type_serde_variant_test.cpp          | 132 ++++++++++++++++++
 .../format/table/paimon_jni_reader_test.cpp   | 125 +++++++++++++++++
 fe/be-java-extensions/paimon-scanner/pom.xml  |   5 +
 fe/fe-connector/fe-connector-paimon/pom.xml   |   8 ++
 .../paimon/PaimonScanPlanProvider.java        |  27 +++-
 .../paimon/PaimonScanPlanProviderTest.java    |  36 +++++
 fe/pom.xml                                    |   5 +
 .../paimon/test_paimon_write_boundary.out     |  14 ++
 .../paimon/test_paimon_write_boundary.groovy  |  78 +++++++++--
 12 files changed, 552 insertions(+), 38 deletions(-)

diff --git a/be/src/core/column/column_variant.cpp b/be/src/core/column/column_variant.cpp
index e00de8cd75bac1..2b8b54ded0a996 100644
--- a/be/src/core/column/column_variant.cpp
+++ b/be/src/core/column/column_variant.cpp
@@ -188,7 +188,7 @@ DataTypeSerDeSPtr ColumnVariant::Subcolumn::generate_data_serdes(DataTypePtr typ
 
 ColumnVariant::Subcolumn::Subcolumn(MutableColumnPtr&& data_, DataTypePtr type, bool is_nullable_,
                                     bool is_root_)
-        : least_common_type(type),
+        : least_common_type(type, is_root_),
           is_nullable(is_nullable_),
           is_root(is_root_),
           num_rows(data_->size()) {
@@ -463,6 +463,11 @@ void ColumnVariant::Subcolumn::insert_range_from(const Subcolumn& src, size_t st
         size_t part_end = end - processed_rows;
         insert_from_part(src.data[pos], src.data_types[pos], 0, part_end);
     }
+
+    const size_t trailing_defaults_start = std::max(start, src.num_rows);
+    if (end > trailing_defaults_start) {
+        data.back()->insert_many_defaults(end - trailing_defaults_start);
+    }
 }
 
 bool ColumnVariant::Subcolumn::is_finalized() const {
@@ -488,20 +493,29 @@ MutableColumnPtr ColumnVariant::apply_for_columns(Func&& func) const {
         auto& finalized_object = assert_cast<ColumnVariant&>(*finalized);
         return finalized_object.apply_for_columns(std::forward<Func>(func));
     }
-    auto new_root = std::move(*func(get_root())).mutate();
-    auto res = ColumnVariant::create(_max_subcolumns_count, _enable_doc_mode, get_root_type(),
-                                     std::move(new_root));
+    Subcolumns transformed_subcolumns;
     for (const auto& subcolumn : subcolumns) {
-        if (subcolumn->data.is_root) {
+        auto transformed = std::move(*func(subcolumn->data.get_finalized_column_ptr())).mutate();
+        Subcolumn transformed_subcolumn(std::move(transformed),
+                                        subcolumn->data.get_least_common_type(), is_nullable,
+                                        subcolumn->data.is_root);
+        if (subcolumn->data.is_root || subcolumn->path.empty()) {
+            transformed_subcolumns.create_root(std::move(transformed_subcolumn));
             continue;
         }
-        auto new_subcolumn = func(subcolumn->data.get_finalized_column_ptr());
-        if (!res->add_sub_column(subcolumn->path, std::move(*new_subcolumn).mutate(),
-                                 subcolumn->data.get_least_common_type())) {
+        if (!transformed_subcolumns.add(subcolumn->path, std::move(transformed_subcolumn))) {
             throw doris::Exception(ErrorCode::INTERNAL_ERROR, "add path {} is error",
                                    subcolumn->path.get_path());
         }
     }
+    if (transformed_subcolumns.get_root() == nullptr) {
+        throw doris::Exception(ErrorCode::INTERNAL_ERROR,
+                               "root is nullptr after transforming variant columns");
+    }
+    auto res = ColumnVariant::create(_max_subcolumns_count, _enable_doc_mode,
+                                     std::move(transformed_subcolumns));
+    res->typed_path_count = typed_path_count;
+    res->nested_path_count = nested_path_count;
     auto sparse_column = func(serialized_sparse_column);
     res->serialized_sparse_column = IColumn::mutate(std::move(sparse_column));
     auto doc_value_column = func(serialized_doc_value_column);
@@ -869,21 +883,10 @@ void ColumnVariant::insert_from(const IColumn& src, size_t n) {
     const auto* src_v = assert_cast<const ColumnVariant*>(&src);
     ENABLE_CHECK_CONSISTENCY(src_v);
     ENABLE_CHECK_CONSISTENCY(this);
-    // Preserve the original root-only copy path for ordinary variant columns.
-    // Reconstructing through try_insert() loses sparse/doc_value structure for
-    // mixed-shape rows and nested-group data.
-    if (src_v->get_subcolumns().size() == 1 && get_subcolumns().size() == 1) {
-        DCHECK(_enable_doc_mode == src_v->_enable_doc_mode)
-                << "root-only variant copy requires matching doc mode";
-        FieldWithDataType field;
-        src_v->subcolumns.get_root()->data.get(n, field);
-        subcolumns.get_mutable_root()->data.insert(field);
-        serialized_sparse_column->insert_from(*src_v->get_sparse_column(), n);
-        serialized_doc_value_column->insert_from(*src_v->get_doc_value_column(), n);
-        num_rows++;
-    } else {
-        try_insert((*src_v)[n]);
-    }
+    // Keep complex and materialized object paths in their native subcolumns. Reconstructing a
+    // single row as a Field can turn nested objects into TYPE_STRUCT, which is not a scalar type
+    // that Subcolumn::insert() can create through DataTypeFactory.
+    insert_range_from(*src_v, n, 1);
     ENABLE_CHECK_CONSISTENCY(this);
 }
 
diff --git a/be/src/core/data_type_serde/data_type_variant_serde.cpp b/be/src/core/data_type_serde/data_type_variant_serde.cpp
index 6cd0126291e7b1..a57aaaaacf0c20 100644
--- a/be/src/core/data_type_serde/data_type_variant_serde.cpp
+++ b/be/src/core/data_type_serde/data_type_variant_serde.cpp
@@ -18,6 +18,7 @@
 #include "core/data_type_serde/data_type_variant_serde.h"
 
 #include <arrow/array/builder_binary.h>
+#include <arrow/array/builder_nested.h>
 
 #include <cstdint>
 #include <string>
@@ -35,6 +36,7 @@
 #include "core/types.h"
 #include "core/value/jsonb_value.h"
 #include "exec/common/variant_util.h"
+#include "exprs/function/parse/variant_jsonb_parse.h"
 #include "util/json/json_parser.h"
 #include "util/jsonb_writer.h"
 
@@ -63,6 +65,77 @@ Status write_variant_column_to_arrow_impl(const IColumn& column, const ColumnVar
     return Status::OK();
 }
 
+Status write_variant_column_to_arrow_struct(const IColumn& column, const ColumnVariant& var,
+                                            const NullMap* null_map, arrow::StructBuilder& builder,
+                                            int64_t start, int64_t end,
+                                            const cctz::time_zone& ctz) {
+    const auto struct_type = std::dynamic_pointer_cast<arrow::StructType>(builder.type());
+    if (struct_type == nullptr || builder.num_fields() != 2 ||
+        struct_type->field(0)->name() != "value" || struct_type->field(1)->name() != "metadata") {
+        return Status::InvalidArgument(
+                "Variant Arrow output requires "
+                "struct<value: binary, metadata: binary>");
+    }
+    auto* value_builder = dynamic_cast<arrow::BinaryBuilder*>(builder.field_builder(0));
+    auto* metadata_builder = dynamic_cast<arrow::BinaryBuilder*>(builder.field_builder(1));
+    if (value_builder == nullptr || metadata_builder == nullptr) {
+        return Status::InvalidArgument(
+                "Variant Arrow output requires binary value and metadata children");
+    }
+
+    const auto* root = var.get_subcolumn(PathInData());
+    const bool string_root =
+            root != nullptr && is_string_type(root->get_least_common_base_type_id());
+    JsonbToVariantEncoder encoder(
+            VariantBatchBuilder::ReserveHint {.rows = cast_set<size_t>(end - start)});
+    DataTypeSerDe::FormatOptions options;
+    options.timezone = &ctz;
+    for (int64_t row = start; row < end; ++row) {
+        if (null_map != nullptr && (*null_map)[cast_set<size_t>(row)]) {
+            encoder.add_null();
+            continue;
+        }
+
+        std::string serialized_value;
+        var.serialize_one_row_to_string(row, &serialized_value, options);
+        if (string_root && !root->is_null_at(cast_set<size_t>(row))) {
+            JsonbWriter writer;
+            if (!writer.writeStartString() ||
+                (serialized_value.size() != 0 &&
+                 !writer.writeString(serialized_value.data(), serialized_value.size())) ||
+                !writer.writeEndString()) {
+                return Status::InternalError("Failed to encode legacy Variant string as JSONB");
+            }
+            encoder.add_jsonb({writer.getOutput()->getBuffer(),
+                               static_cast<size_t>(writer.getOutput()->getSize())});
+            continue;
+        }
+
+        JsonBinaryValue jsonb;
+        RETURN_IF_ERROR(jsonb.from_json_string(serialized_value));
+        encoder.add_jsonb({jsonb.value(), jsonb.size()});
+    }
+
+    VariantBatchBuilder batch = encoder.finish_batch();
+    for (size_t row = 0; row < batch.num_rows(); ++row) {
+        const size_t source_row = cast_set<size_t>(start) + row;
+        if (null_map != nullptr && (*null_map)[source_row]) {
+            RETURN_IF_ERROR(checkArrowStatus(builder.AppendNull(), column, builder));
+            continue;
+        }
+        const VariantRef value = batch.value_at(row);
+        RETURN_IF_ERROR(checkArrowStatus(builder.Append(), column, builder));
+        RETURN_IF_ERROR(checkArrowStatus(
+                value_builder->Append(value.value.data, cast_set<int32_t>(value.value.size)),
+                column, *value_builder));
+        RETURN_IF_ERROR(
+                checkArrowStatus(metadata_builder->Append(value.metadata.data,
+                                                          cast_set<int32_t>(value.metadata.size)),
+                                 column, *metadata_builder));
+    }
+    return Status::OK();
+}
+
 } // namespace
 
 Status DataTypeVariantSerDe::write_column_to_mysql_binary(const IColumn& column,
@@ -161,6 +234,10 @@ Status DataTypeVariantSerDe::write_column_to_arrow(const IColumn& column, const
     } else if (array_builder->type()->id() == arrow::Type::STRING) {
         auto& builder = assert_cast<arrow::StringBuilder&>(*array_builder);
         return write_variant_column_to_arrow_impl(column, *var, null_map, builder, start, end, ctz);
+    } else if (array_builder->type()->id() == arrow::Type::STRUCT) {
+        auto& builder = assert_cast<arrow::StructBuilder&>(*array_builder);
+        RETURN_IF_CATCH_EXCEPTION(return write_variant_column_to_arrow_struct(
+                column, *var, null_map, builder, start, end, ctz));
     } else {
         return Status::InvalidArgument("Unsupported arrow type for variant column: {}",
                                        array_builder->type()->name());
@@ -208,7 +285,8 @@ Status DataTypeVariantSerDe::write_column_to_orc(const std::string& timezone, co
         size_t len = serialized_value.length();
         if (offset + len > total_size) {
             return Status::InternalError(
-                    "Buffer overflow when writing column data to ORC file. offset {} with len {} "
+                    "Buffer overflow when writing column data "
+                    "to ORC file. offset {} with len {} "
                     "exceed total_size {} . ",
                     offset, len, total_size);
         }
diff --git a/be/src/format/jni/jni_data_bridge.cpp b/be/src/format/jni/jni_data_bridge.cpp
index 51b4d0e7089c01..67d2e2159c64db 100644
--- a/be/src/format/jni/jni_data_bridge.cpp
+++ b/be/src/format/jni/jni_data_bridge.cpp
@@ -22,6 +22,7 @@
 #include <sstream>
 #include <variant>
 
+#include "common/config.h"
 #include "core/block/block.h"
 #include "core/column/column_array.h"
 #include "core/column/column_map.h"
@@ -29,6 +30,7 @@
 #include "core/column/column_string.h"
 #include "core/column/column_struct.h"
 #include "core/column/column_varbinary.h"
+#include "core/column/column_variant.h"
 #include "core/column/variant_v2/column_variant_v2.h"
 #include "core/data_type/data_type_array.h"
 #include "core/data_type/data_type_map.h"
@@ -40,6 +42,8 @@
 #include "core/types.h"
 #include "core/value/decimalv2_value.h"
 #include "core/value/variant/variant_batch_builder.h"
+#include "exec/common/variant_util.h"
+#include "exprs/function/parse/variant_string_parse.h"
 #include "util/string_util.h"
 #include "util/url_coding.h"
 
@@ -211,7 +215,32 @@ Status JniDataBridge::_fill_variant_column(TableMetaAddress& address,
             row.finish();
         }
         VariantBatchBuilder batch = builder.finish_batch();
-        assert_cast<ColumnVariantV2&>(*doris_column).insert_encoded_batch(batch);
+        if (auto* variant_v2 = check_and_get_column<ColumnVariantV2>(doris_column.get())) {
+            variant_v2->insert_encoded_batch(batch);
+        } else {
+            auto* variant = check_and_get_column<ColumnVariant>(doris_column.get());
+            if (variant == nullptr) {
+                throw Exception(
+                        ErrorCode::INVALID_ARGUMENT,
+                        "JNI Variant destination requires ColumnVariant or ColumnVariantV2, got "
+                        "{}",
+                        doris_column->get_name());
+            }
+            struct StringWriter {
+                void write(const char* data, size_t size) { value.append(data, size); }
+                std::string value;
+            };
+            ParseConfig parse_config;
+            parse_config.check_duplicate_json_path =
+                    config::variant_enable_duplicate_json_path_check;
+            for (size_t row_index = 0; row_index < num_rows; ++row_index) {
+                StringWriter writer;
+                to_json(batch.value_at(row_index), writer);
+                variant_util::parse_json_to_variant(*variant,
+                                                    {writer.value.data(), writer.value.size()},
+                                                    nullptr, parse_config);
+            }
+        }
     });
     return Status::OK();
 }
diff --git a/be/test/core/data_type_serde/data_type_serde_variant_test.cpp b/be/test/core/data_type_serde/data_type_serde_variant_test.cpp
index 968062079d0094..ba9141661f07ff 100644
--- a/be/test/core/data_type_serde/data_type_serde_variant_test.cpp
+++ b/be/test/core/data_type_serde/data_type_serde_variant_test.cpp
@@ -15,13 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <arrow/array/array_nested.h>
 #include <arrow/array/builder_binary.h>
+#include <arrow/array/builder_nested.h>
 #include <arrow/array/builder_primitive.h>
 #include <gtest/gtest.h>
 
+#include <string>
+#include <string_view>
+#include <vector>
+
 #include "core/column/column_variant.h"
 #include "core/data_type_serde/data_type_variant_serde.h"
 #include "core/string_buffer.hpp"
+#include "exprs/function/parse/variant_string_parse.h"
 #include "gen_cpp/types.pb.h"
 #include "util/mysql_row_buffer.h"
 #include "util/slice.h"
@@ -64,4 +71,129 @@ TEST(VariantSerdeTest, BasicUnsupportedAndArrowPaths) {
                          .ok());
 }
 
+TEST(VariantSerdeTest, StructArrowEncodesLegacyVariantAndSqlNull) {
+    DataTypeVariantSerDe serde;
+    auto column = ColumnVariant::create(0, false);
+    DataTypeSerDe::FormatOptions options;
+    const std::string json = R"({"id":7,"tags":["doris"]})";
+    const std::vector<std::string> json_rows {json, "null", json};
+    for (const auto& json_row : json_rows) {
+        Slice slice(json_row.data(), json_row.size());
+        ASSERT_TRUE(serde.deserialize_one_cell_from_json(*column, slice, options).ok());
+    }
+    column->finalize(ColumnVariant::FinalizeMode::WRITE_MODE);
+
+    auto value_builder = std::make_shared<arrow::BinaryBuilder>();
+    auto metadata_builder = std::make_shared<arrow::BinaryBuilder>();
+    auto arrow_type = arrow::struct_({arrow::field("value", arrow::binary(), false),
+                                      arrow::field("metadata", arrow::binary(), false)});
+    arrow::StructBuilder builder(arrow_type, arrow::default_memory_pool(),
+                                 {value_builder, metadata_builder});
+    NullMap forced_nulls {0, 0, 1};
+    ASSERT_TRUE(serde.write_column_to_arrow(*column, &forced_nulls, &builder, 0, column->size(),
+                                            cctz::utc_time_zone())
+                        .ok());
+
+    std::shared_ptr<arrow::StructArray> output;
+    ASSERT_TRUE(builder.Finish(&output).ok());
+    ASSERT_EQ(output->length(), 3);
+    EXPECT_FALSE(output->IsNull(0));
+    EXPECT_FALSE(output->IsNull(1));
+    EXPECT_TRUE(output->IsNull(2));
+
+    JsonStringToVariantEncoder expected_encoder({.max_json_key_length = 1024,
+                                                 .throw_on_invalid_json = true,
+                                                 .check_duplicate_json_path = false});
+    expected_encoder.add_json({json.data(), json.size()});
+    // Legacy VARIANT V1 materializes a root JSON null as an empty object.
+    constexpr std::string_view legacy_json_null = "{}";
+    expected_encoder.add_json({legacy_json_null.data(), legacy_json_null.size()});
+    VariantBatchBuilder expected = expected_encoder.finish_batch();
+    const auto& values = assert_cast<const arrow::BinaryArray&>(*output->field(0));
+    const auto& metadatas = assert_cast<const arrow::BinaryArray&>(*output->field(1));
+    for (size_t row = 0; row < 2; ++row) {
+        const VariantRef expected_value = expected.value_at(row);
+        EXPECT_EQ(values.GetView(cast_set<int64_t>(row)),
+                  std::string_view(expected_value.value.data, expected_value.value.size));
+        EXPECT_EQ(metadatas.GetView(cast_set<int64_t>(row)),
+                  std::string_view(expected_value.metadata.data, expected_value.metadata.size));
+    }
+}
+
+TEST(VariantSerdeTest, StructArrowPreservesScalarStringSemantics) {
+    DataTypeVariantSerDe serde;
+    auto column = ColumnVariant::create(0, false);
+    DataTypeSerDe::FormatOptions options;
+    const std::string json = R"("123")";
+    Slice slice(json.data(), json.size());
+    ASSERT_TRUE(serde.deserialize_one_cell_from_json(*column, slice, options).ok());
+    column->finalize(ColumnVariant::FinalizeMode::WRITE_MODE);
+
+    auto value_builder = std::make_shared<arrow::BinaryBuilder>();
+    auto metadata_builder = std::make_shared<arrow::BinaryBuilder>();
+    auto arrow_type = arrow::struct_({arrow::field("value", arrow::binary(), false),
+                                      arrow::field("metadata", arrow::binary(), false)});
+    arrow::StructBuilder builder(arrow_type, arrow::default_memory_pool(),
+                                 {value_builder, metadata_builder});
+    ASSERT_TRUE(serde.write_column_to_arrow(*column, nullptr, &builder, 0, column->size(),
+                                            cctz::utc_time_zone())
+                        .ok());
+
+    std::shared_ptr<arrow::StructArray> output;
+    ASSERT_TRUE(builder.Finish(&output).ok());
+    JsonStringToVariantEncoder expected_encoder({.max_json_key_length = 1024,
+                                                 .throw_on_invalid_json = true,
+                                                 .check_duplicate_json_path = false});
+    expected_encoder.add_json({json.data(), json.size()});
+    VariantBatchBuilder expected = expected_encoder.finish_batch();
+    const VariantRef expected_value = expected.value_at(0);
+    const auto& values = assert_cast<const arrow::BinaryArray&>(*output->field(0));
+    const auto& metadatas = assert_cast<const arrow::BinaryArray&>(*output->field(1));
+    EXPECT_EQ(values.GetView(0),
+              std::string_view(expected_value.value.data, expected_value.value.size));
+    EXPECT_EQ(metadatas.GetView(0),
+              std::string_view(expected_value.metadata.data, expected_value.metadata.size));
+}
+
+TEST(VariantSerdeTest, StructArrowPreservesMixedObjectAndScalarStringSemantics) {
+    DataTypeVariantSerDe serde;
+    auto column = ColumnVariant::create(0, false);
+    DataTypeSerDe::FormatOptions options;
+    const std::vector<std::string> json_rows {R"({"id":7})", R"("123")"};
+    for (const auto& json : json_rows) {
+        Slice slice(json.data(), json.size());
+        ASSERT_TRUE(serde.deserialize_one_cell_from_json(*column, slice, options).ok());
+    }
+    column->finalize(ColumnVariant::FinalizeMode::WRITE_MODE);
+
+    auto value_builder = std::make_shared<arrow::BinaryBuilder>();
+    auto metadata_builder = std::make_shared<arrow::BinaryBuilder>();
+    auto arrow_type = arrow::struct_({arrow::field("value", arrow::binary(), false),
+                                      arrow::field("metadata", arrow::binary(), false)});
+    arrow::StructBuilder builder(arrow_type, arrow::default_memory_pool(),
+                                 {value_builder, metadata_builder});
+    ASSERT_TRUE(serde.write_column_to_arrow(*column, nullptr, &builder, 0, column->size(),
+                                            cctz::utc_time_zone())
+                        .ok());
+
+    std::shared_ptr<arrow::StructArray> output;
+    ASSERT_TRUE(builder.Finish(&output).ok());
+    JsonStringToVariantEncoder expected_encoder({.max_json_key_length = 1024,
+                                                 .throw_on_invalid_json = true,
+                                                 .check_duplicate_json_path = false});
+    for (const auto& json : json_rows) {
+        expected_encoder.add_json({json.data(), json.size()});
+    }
+    VariantBatchBuilder expected = expected_encoder.finish_batch();
+    const auto& values = assert_cast<const arrow::BinaryArray&>(*output->field(0));
+    const auto& metadatas = assert_cast<const arrow::BinaryArray&>(*output->field(1));
+    for (size_t row = 0; row < json_rows.size(); ++row) {
+        const VariantRef expected_value = expected.value_at(row);
+        EXPECT_EQ(values.GetView(cast_set<int64_t>(row)),
+                  std::string_view(expected_value.value.data, expected_value.value.size));
+        EXPECT_EQ(metadatas.GetView(cast_set<int64_t>(row)),
+                  std::string_view(expected_value.metadata.data, expected_value.metadata.size));
+    }
+}
+
 } // namespace doris
diff --git a/be/test/format/table/paimon_jni_reader_test.cpp b/be/test/format/table/paimon_jni_reader_test.cpp
index c2e5eb4224145a..0e583178caf8dc 100644
--- a/be/test/format/table/paimon_jni_reader_test.cpp
+++ b/be/test/format/table/paimon_jni_reader_test.cpp
@@ -28,10 +28,14 @@
 
 #include "core/assert_cast.h"
 #include "core/column/column_nullable.h"
+#include "core/column/column_variant.h"
 #include "core/column/variant_v2/column_variant_v2.h"
 #include "core/data_type/data_type_nullable.h"
+#include "core/data_type/data_type_variant.h"
 #include "core/data_type/data_type_variant_v2.h"
+#include "core/data_type_serde/data_type_serde.h"
 #include "core/value/variant/variant_batch_builder.h"
+#include "exec/common/variant_util.h"
 #include "exprs/function/parse/variant_string_parse.h"
 #include "format/jni/jni_data_bridge.h"
 #include "gen_cpp/PlanNodes_types.h"
@@ -126,5 +130,126 @@ TEST(LegacyPaimonJniReaderTest, DecodesVariantV2BinaryStructFromJavaMetadata) {
     EXPECT_TRUE(variants.get_value_ref(1).is_null());
 }
 
+TEST(LegacyPaimonJniReaderTest, DecodesLegacyVariantBinaryStructFromJavaMetadata) {
+    const std::vector<std::string> json_rows {
+            R"({"name":"alpha","score":12.5,"tags":["dts","fluss","paimon"]})",
+            R"({"active":true,"name":"beta","nested":{"version":"2.0"}})", "null", "null", "123"};
+    JsonStringToVariantEncoder encoder;
+    for (const auto& json : json_rows) {
+        encoder.add_json({json.data(), json.size()});
+    }
+    VariantBatchBuilder source = encoder.finish_batch();
+
+    std::array<uint8_t, 5> outer_nulls {0, 0, 0, 1, 0};
+    std::array<uint8_t, 5> child_nulls {0, 0, 0, 1, 0};
+    std::array<JavaVarbinaryEntry, 5> value_entries;
+    std::array<JavaVarbinaryEntry, 5> metadata_entries;
+    for (size_t row = 0; row < json_rows.size(); ++row) {
+        const VariantRef value = source.value_at(row);
+        value_entries[row] = {static_cast<int64_t>(value.value.size),
+                              reinterpret_cast<uint64_t>(value.value.data)};
+        metadata_entries[row] = {static_cast<int64_t>(value.metadata.size),
+                                 reinterpret_cast<uint64_t>(value.metadata.data)};
+    }
+    value_entries[3] = {0, 0};
+    metadata_entries[3] = {0, 0};
+    std::array<long, 5> metadata {reinterpret_cast<long>(outer_nulls.data()),
+                                  reinterpret_cast<long>(child_nulls.data()),
+                                  reinterpret_cast<long>(value_entries.data()),
+                                  reinterpret_cast<long>(child_nulls.data()),
+                                  reinterpret_cast<long>(metadata_entries.data())};
+
+    const DataTypePtr type = make_nullable(std::make_shared<DataTypeVariant>(0, false));
+    ColumnPtr result = type->create_column();
+    JniDataBridge::TableMetaAddress address(reinterpret_cast<long>(metadata.data()));
+    ASSERT_TRUE(JniDataBridge::fill_column(address, result, type, 5).ok());
+
+    const auto& nullable = assert_cast<const ColumnNullable&>(*result);
+    EXPECT_EQ(nullable.get_null_map_data(), (NullMap {0, 0, 0, 1, 0}));
+    const auto& variants = assert_cast<const ColumnVariant&>(nullable.get_nested_column());
+    ASSERT_EQ(variants.rows(), 5);
+    auto finalized = variants.clone_finalized();
+    const auto& decoded = assert_cast<const ColumnVariant&>(*finalized);
+    DataTypeSerDe::FormatOptions options;
+    std::string object_json;
+    decoded.serialize_one_row_to_string(0, &object_json, options);
+    const std::string expected_object_json =
+            R"({"name":"alpha","score":12.5,"tags":["dts", "fluss", "paimon"]})";
+    EXPECT_EQ(object_json, expected_object_json);
+    std::string nested_object_json;
+    decoded.serialize_one_row_to_string(1, &nested_object_json, options);
+    EXPECT_EQ(nested_object_json, R"({"active":1,"name":"beta","nested":{"version":"2.0"}})");
+    std::string encoded_json_null;
+    decoded.serialize_one_row_to_string(2, &encoded_json_null, options);
+    // Legacy VARIANT V1 materializes a root JSON null as an empty object.
+    EXPECT_EQ(encoded_json_null, "{}");
+    std::string scalar_number;
+    decoded.serialize_one_row_to_string(4, &scalar_number, options);
+    EXPECT_EQ(scalar_number, "123");
+
+    IColumn::Permutation permutation {0, 1, 2, 3, 4};
+    auto permuted_base = nullable.permute(permutation, 0);
+    const auto& permuted_nullable = assert_cast<const ColumnNullable&>(*permuted_base);
+    const auto& permuted_variants =
+            assert_cast<const ColumnVariant&>(permuted_nullable.get_nested_column());
+    auto finalized_permutation = permuted_variants.clone_finalized();
+    const auto& permuted = assert_cast<const ColumnVariant&>(*finalized_permutation);
+    std::string first_permuted;
+    permuted.serialize_one_row_to_string(0, &first_permuted, options);
+    EXPECT_EQ(first_permuted, expected_object_json);
+    std::string second_permuted;
+    permuted.serialize_one_row_to_string(1, &second_permuted, options);
+    EXPECT_EQ(second_permuted, R"({"active":1,"name":"beta","nested":{"version":"2.0"}})");
+    std::string encoded_null_permuted;
+    permuted.serialize_one_row_to_string(2, &encoded_null_permuted, options);
+    EXPECT_EQ(encoded_null_permuted, "{}");
+    std::string fifth_permuted;
+    permuted.serialize_one_row_to_string(4, &fifth_permuted, options);
+    EXPECT_EQ(fifth_permuted, "123");
+
+    auto copied_rows = type->create_column();
+    for (size_t row = 0; row < result->size(); ++row) {
+        copied_rows->insert_from(*result, row);
+    }
+    const auto& copied_nullable = assert_cast<const ColumnNullable&>(*copied_rows);
+    EXPECT_EQ(copied_nullable.get_null_map_data(), (NullMap {0, 0, 0, 1, 0}));
+    const auto& copied_variants =
+            assert_cast<const ColumnVariant&>(copied_nullable.get_nested_column());
+    auto finalized_copy = copied_variants.clone_finalized();
+    const auto& copied = assert_cast<const ColumnVariant&>(*finalized_copy);
+    std::string copied_nested_object;
+    copied.serialize_one_row_to_string(1, &copied_nested_object, options);
+    EXPECT_EQ(copied_nested_object, R"({"active":1,"name":"beta","nested":{"version":"2.0"}})");
+
+    auto merged = ColumnVariant::create(0, false);
+    ParseConfig parse_config;
+    for (size_t row = 0; row < json_rows.size(); ++row) {
+        auto source_column = ColumnVariant::create(0, false);
+        if (outer_nulls[row]) {
+            source_column->insert_default();
+        } else {
+            variant_util::parse_json_to_variant(*source_column,
+                                                {json_rows[row].data(), json_rows[row].size()},
+                                                nullptr, parse_config);
+        }
+        merged->insert_range_from(*source_column, 0, 1);
+    }
+    merged->finalize();
+    auto merged_permuted = merged->permute(permutation, 0);
+    const auto& merged_result = assert_cast<const ColumnVariant&>(*merged_permuted);
+    std::string merged_second_row;
+    merged_result.serialize_one_row_to_string(1, &merged_second_row, options);
+    EXPECT_EQ(merged_second_row, R"({"active":1,"name":"beta","nested":{"version":"2.0"}})");
+
+    auto merged_batch = ColumnVariant::create(0, false);
+    merged_batch->insert_range_from(variants, 0, variants.rows());
+    merged_batch->finalize();
+    auto merged_batch_permuted = merged_batch->permute(permutation, 0);
+    const auto& merged_batch_result = assert_cast<const ColumnVariant&>(*merged_batch_permuted);
+    std::string merged_batch_second_row;
+    merged_batch_result.serialize_one_row_to_string(1, &merged_batch_second_row, options);
+    EXPECT_EQ(merged_batch_second_row, R"({"active":1,"name":"beta","nested":{"version":"2.0"}})");
+}
+
 } // namespace
 } // namespace doris
diff --git a/fe/be-java-extensions/paimon-scanner/pom.xml b/fe/be-java-extensions/paimon-scanner/pom.xml
index 7f415dae329855..f492c85035d2d3 100644
--- a/fe/be-java-extensions/paimon-scanner/pom.xml
+++ b/fe/be-java-extensions/paimon-scanner/pom.xml
@@ -61,6 +61,11 @@ under the License.
             <artifactId>paimon-format</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>org.apache.paimon</groupId>
+            <artifactId>paimon-vortex-format</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-vector</artifactId>
diff --git a/fe/fe-connector/fe-connector-paimon/pom.xml b/fe/fe-connector/fe-connector-paimon/pom.xml
index 6f81ba6e121c93..857de4161da3c1 100644
--- a/fe/fe-connector/fe-connector-paimon/pom.xml
+++ b/fe/fe-connector/fe-connector-paimon/pom.xml
@@ -299,6 +299,14 @@ under the License.
             <artifactId>paimon-format</artifactId>
         </dependency>
 
+        <!-- Paimon 2.0 keeps the Vortex FileFormatFactory and its JNI runtime in a separate
+             module. Bundle it in the child-first connector classloader so Vortex tables can be
+             planned and their format factory is visible to Paimon's ServiceLoader. -->
+        <dependency>
+            <groupId>org.apache.paimon</groupId>
+            <artifactId>paimon-vortex-format</artifactId>
+        </dependency>
+
         <!-- TEST ONLY: the buildRealDataSplit-based tests (count-pushdown / native sub-split /
              cpp-reader serde) write a REAL local-filesystem paimon table to produce a real DataSplit;
              paimon's writer/commit path references org.apache.hadoop.mapreduce.lib.input.FileInputFormat
diff --git a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java
index 56a006738b863e..a492e436cd4209 100644
--- a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java
+++ b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonScanPlanProvider.java
@@ -82,6 +82,7 @@
 import org.apache.paimon.types.ArrayType;
 import org.apache.paimon.types.DataField;
 import org.apache.paimon.types.DataType;
+import org.apache.paimon.types.DataTypeRoot;
 import org.apache.paimon.types.MapType;
 import org.apache.paimon.types.RowType;
 import org.apache.paimon.utils.InstantiationUtil;
@@ -636,6 +637,8 @@ private List<ConnectorScanRange> planScanInternal(
             // and hand BE the wrong column. Fail loud instead.
             throw new DorisConnectorException("Paimon scan schema does not contain all bound Doris columns.");
         }
+        // Native Parquet exposes Paimon's physical struct<value,metadata> instead of logical VARIANT.
+        boolean forceJniForVariant = requiresJniForProjectedColumns(rowType, projected);
 
         // Call Paimon SDK
         ReadBuilder readBuilder = table.newReadBuilder();
@@ -745,7 +748,7 @@ private List<ConnectorScanRange> planScanInternal(
             Optional<List<RawFile>> optRawFiles = dataSplit.convertToRawFiles();
             Optional<List<DeletionFile>> optDeletionFiles = dataSplit.deletionFiles();
 
-            if (shouldUseNativeReader(paimonHandle.isForceJni(),
+            if (shouldUseNativeReader(paimonHandle.isForceJni() || forceJniForVariant,
                     isForceJniScannerEnabled(session), optRawFiles)) {
                 if (ignoreNative) {
                     // FIX-L14: ignore_split_type=IGNORE_NATIVE drops native splits (legacy getSplits:443).
@@ -1589,6 +1592,28 @@ static boolean shouldUseNativeReader(boolean forceJni, boolean forceJniScanner,
         return !forceJni && !forceJniScanner && supportNativeReader(optRawFiles);
     }
 
+    static boolean requiresJniForProjectedColumns(RowType rowType, int[] projected) {
+        return Arrays.stream(projected).anyMatch(index -> containsVariant(rowType.getTypeAt(index)));
+    }
+
+    private static boolean containsVariant(DataType type) {
+        if (type.getTypeRoot() == DataTypeRoot.VARIANT) {
+            return true;
+        }
+        if (type instanceof ArrayType) {
+            return containsVariant(((ArrayType) type).getElementType());
+        }
+        if (type instanceof MapType) {
+            MapType map = (MapType) type;
+            return containsVariant(map.getKeyType()) || containsVariant(map.getValueType());
+        }
+        if (type instanceof RowType) {
+            return ((RowType) type).getFieldTypes().stream()
+                    .anyMatch(PaimonScanPlanProvider::containsVariant);
+        }
+        return false;
+    }
+
     private static boolean supportNativeReader(Optional<List<RawFile>> optRawFiles) {
         if (!optRawFiles.isPresent() || optRawFiles.get().isEmpty()) {
             return false;
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanPlanProviderTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanPlanProviderTest.java
index edc51c86139e58..ed7345efc0256d 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanPlanProviderTest.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonScanPlanProviderTest.java
@@ -44,8 +44,10 @@
 import org.apache.paimon.catalog.Identifier;
 import org.apache.paimon.data.BinaryString;
 import org.apache.paimon.data.GenericRow;
+import org.apache.paimon.format.FileFormat;
 import org.apache.paimon.fs.local.LocalFileIO;
 import org.apache.paimon.io.DataInputViewStreamWrapper;
+import org.apache.paimon.options.Options;
 import org.apache.paimon.schema.Schema;
 import org.apache.paimon.schema.SchemaChange;
 import org.apache.paimon.schema.SchemaManager;
@@ -340,6 +342,40 @@ public void forceJniScannerRoutesNativeEligibleSplitToJni() {
                 "force_jni_scanner=true must route even native-eligible ORC/Parquet splits to JNI");
     }
 
+    @Test
+    public void projectedVariantRoutesToJniWithoutDisablingOtherNativeReads() {
+        RowType rowType = RowType.builder()
+                .field("id", DataTypes.INT())
+                .field("doc", DataTypes.VARIANT())
+                .field("nested_doc", DataTypes.ARRAY(DataTypes.VARIANT()))
+                .field("mapped_doc", DataTypes.MAP(DataTypes.STRING(), DataTypes.VARIANT()))
+                .field("row_doc", DataTypes.ROW(
+                        DataTypes.FIELD(10, "payload", DataTypes.VARIANT())))
+                .build();
+
+        Assertions.assertFalse(
+                PaimonScanPlanProvider.requiresJniForProjectedColumns(rowType, new int[] {0}),
+                "a projection without VARIANT must keep the native reader fast path");
+        Assertions.assertTrue(
+                PaimonScanPlanProvider.requiresJniForProjectedColumns(rowType, new int[] {0, 1}),
+                "Paimon VARIANT needs JNI to decode its value/metadata physical struct");
+        Assertions.assertTrue(
+                PaimonScanPlanProvider.requiresJniForProjectedColumns(rowType, new int[] {2}),
+                "nested Paimon VARIANT must use the same lossless JNI decoder");
+        Assertions.assertTrue(
+                PaimonScanPlanProvider.requiresJniForProjectedColumns(rowType, new int[] {3}),
+                "map values containing Paimon VARIANT must use JNI");
+        Assertions.assertTrue(
+                PaimonScanPlanProvider.requiresJniForProjectedColumns(rowType, new int[] {4}),
+                "row fields containing Paimon VARIANT must use JNI");
+    }
+
+    @Test
+    public void vortexFormatFactoryIsAvailable() {
+        FileFormat format = FileFormat.fromIdentifier("vortex", new Options());
+        Assertions.assertEquals("vortex", format.getFormatIdentifier());
+    }
+
     // ---- FIX-URI-NORMALIZE (B-7DF data file + B-7DV deletion vector) ----
 
     @Test
diff --git a/fe/pom.xml b/fe/pom.xml
index 99f5e26b22341a..10403343105534 100644
--- a/fe/pom.xml
+++ b/fe/pom.xml
@@ -1515,6 +1515,11 @@ under the License.
                 <artifactId>paimon-format</artifactId>
                 <version>${paimon.version}</version>
             </dependency>
+            <dependency>
+                <groupId>org.apache.paimon</groupId>
+                <artifactId>paimon-vortex-format</artifactId>
+                <version>${paimon.version}</version>
+            </dependency>
             <dependency>
                 <groupId>org.apache.paimon</groupId>
                 <artifactId>paimon-s3</artifactId>
diff --git a/regression-test/data/external_table_p0/paimon/test_paimon_write_boundary.out b/regression-test/data/external_table_p0/paimon/test_paimon_write_boundary.out
index 1694d2c41d00f1..067287d5d4556b 100644
--- a/regression-test/data/external_table_p0/paimon/test_paimon_write_boundary.out
+++ b/regression-test/data/external_table_p0/paimon/test_paimon_write_boundary.out
@@ -25,3 +25,17 @@
 
 -- !after_snapshots --
 4
+
+-- !variant_rows --
+1	{"name":"alpha","score":12.5,"tags":["dts", "paimon"]}
+2	{"active":1,"nested":{"version":"2.0"}}
+3	\N
+4	123
+5	{}
+
+-- !variant_row_tracking --
+1	{"name":"alpha","score":12.5,"tags":["dts", "paimon"]}	0	1
+2	{"active":1,"nested":{"version":"2.0"}}	1	2
+3	\N	2	2
+4	123	3	2
+5	{}	4	2
diff --git a/regression-test/suites/external_table_p0/paimon/test_paimon_write_boundary.groovy b/regression-test/suites/external_table_p0/paimon/test_paimon_write_boundary.groovy
index cd12cfe31c03e4..8f445ba2e862ba 100644
--- a/regression-test/suites/external_table_p0/paimon/test_paimon_write_boundary.groovy
+++ b/regression-test/suites/external_table_p0/paimon/test_paimon_write_boundary.groovy
@@ -41,26 +41,27 @@ suite("test_paimon_write_boundary",
     """
 
     try {
-        spark_paimon_multi """
-            create database if not exists paimon.${dbName};
-            drop table if exists paimon.${dbName}.write_boundary;
-            create table paimon.${dbName}.write_boundary (
-                id int,
+        sql """switch ${catalogName}"""
+        sql """create database if not exists ${dbName}"""
+        sql """use ${dbName}"""
+        sql """drop table if exists write_boundary"""
+        sql """
+            create table write_boundary (
+                id int not null,
                 score int,
                 note string
-            ) using paimon tblproperties (
+            ) engine=paimon properties (
                 'primary-key'='id',
                 'bucket'='1',
                 'file.format'='parquet'
-            );
-            insert into paimon.${dbName}.write_boundary values
+            )
+        """
+        sql """
+            insert into write_boundary values
                 (1, 10, 'base-1'),
-                (2, 20, 'base-2');
+                (2, 20, 'base-2')
         """
 
-        sql """switch ${catalogName}"""
-        sql """use ${dbName}"""
-
         qt_before_rows """select id, score, note from write_boundary order by id"""
         qt_before_snapshots """select count(*) from write_boundary\$snapshots"""
 
@@ -98,6 +99,59 @@ suite("test_paimon_write_boundary",
         sql """refresh table write_boundary"""
         qt_after_rows """select id, score, note from write_boundary order by id"""
         qt_after_snapshots """select count(*) from write_boundary\$snapshots"""
+
+        sql """drop table if exists variant_row_tracking"""
+        sql """
+            create table variant_row_tracking (
+                id int,
+                doc variant
+            ) engine=paimon properties (
+                'bucket'='-1',
+                'file.format'='parquet',
+                'row-tracking.enabled'='true',
+                'data-evolution.enabled'='true'
+            )
+        """
+        sql """
+            insert into variant_row_tracking values
+                (1, parse_to_variant('{"name":"alpha","score":12.5,"tags":["dts","paimon"]}'))
+        """
+        // Legacy VARIANT V1 materializes a root JSON null as an empty object.
+        sql """
+            insert into variant_row_tracking values
+                (2, parse_to_variant('{"active":true,"nested":{"version":"2.0"}}')),
+                (3, null),
+                (4, parse_to_variant('"123"')),
+                (5, parse_to_variant('null'))
+        """
+
+        sql """set force_jni_scanner=false"""
+        sql """set enable_paimon_cpp_reader=true"""
+        String variantExplain = sql("""
+            explain verbose select id, doc from variant_row_tracking
+        """).collect { row -> row[0].toString() }.join("\n")
+        def variantSplits = (variantExplain =~ /paimonNativeReadSplits=(\d+)\/(\d+)/)
+        assertTrue(variantSplits.find(), "Expected Paimon split counts for VARIANT projection")
+        assertTrue(Long.parseLong(variantSplits.group(2)) > 0
+                        && Long.parseLong(variantSplits.group(1)) == 0,
+                "VARIANT projection must use JNI-only splits: ${variantExplain}")
+
+        String scalarExplain = sql("""
+            explain verbose select id from variant_row_tracking
+        """).collect { row -> row[0].toString() }.join("\n")
+        def scalarSplits = (scalarExplain =~ /paimonNativeReadSplits=(\d+)\/(\d+)/)
+        assertTrue(scalarSplits.find(), "Expected Paimon split counts for scalar projection")
+        assertTrue(Long.parseLong(scalarSplits.group(2)) > 0
+                        && scalarSplits.group(1) == scalarSplits.group(2),
+                "Scalar-only projection must retain native splits: ${scalarExplain}")
+
+        order_qt_variant_rows """select id, doc from variant_row_tracking order by id"""
+        order_qt_variant_row_tracking """
+            select id, doc, _ROW_ID, _SEQUENCE_NUMBER
+            from variant_row_tracking\$row_tracking
+            order by _SEQUENCE_NUMBER, _ROW_ID
+        """
+
     } finally {
         sql """drop catalog if exists ${catalogName}"""
     }

From c87039fb6cef7abcad49675aed47af9e29ffcfa2 Mon Sep 17 00:00:00 2001
From: moke-HU <25567926679@qq.com>
Date: Sat, 15 Aug 2026 09:42:21 +0800
Subject: [PATCH 6/7] fix(paimon): validate Vortex schemas before create

---
 .../paimon/PaimonConnectorMetadata.java       | 11 +++++++
 .../PaimonConnectorMetadataDdlTest.java       | 29 +++++++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorMetadata.java b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorMetadata.java
index 685d1ffc91a493..57a9cd6c2853ee 100644
--- a/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorMetadata.java
+++ b/fe/fe-connector/fe-connector-paimon/src/main/java/org/apache/doris/connector/paimon/PaimonConnectorMetadata.java
@@ -47,6 +47,8 @@
 import org.apache.paimon.catalog.Identifier;
 import org.apache.paimon.partition.Partition;
 import org.apache.paimon.schema.Schema;
+import org.apache.paimon.schema.SchemaValidation;
+import org.apache.paimon.schema.TableSchema;
 import org.apache.paimon.table.DataTable;
 import org.apache.paimon.table.FileStoreTable;
 import org.apache.paimon.table.Table;
@@ -1005,6 +1007,15 @@ public void createTable(ConnectorSession session, ConnectorCreateTableRequest re
         rejectDistribution(request);
         Identifier id = Identifier.create(request.getDbName(), request.getTableName());
         Schema schema = PaimonSchemaBuilder.build(request);
+        // REST catalogs can persist the schema before a client loads and validates the Vortex table.
+        if ("vortex".equalsIgnoreCase(schema.options().get(CoreOptions.FILE_FORMAT.key()))) {
+            try {
+                SchemaValidation.validateTableSchema(TableSchema.create(0, schema));
+            } catch (RuntimeException e) {
+                throw new DorisConnectorException(
+                        "Invalid Paimon table schema for " + id + ": " + e.getMessage(), e);
+            }
+        }
         try {
             context.executeAuthenticated(() -> {
                 catalogOps.createTable(id, schema, false);
diff --git a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataDdlTest.java b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataDdlTest.java
index e3c545f550a347..abf18d31d6395a 100644
--- a/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataDdlTest.java
+++ b/fe/fe-connector/fe-connector-paimon/src/test/java/org/apache/doris/connector/paimon/PaimonConnectorMetadataDdlTest.java
@@ -91,6 +91,19 @@ private static ConnectorCreateTableRequest requestWithNonIdentityPartition() {
                 .build();
     }
 
+    private static ConnectorCreateTableRequest requestWithVortexVariant() {
+        List<ConnectorColumn> columns = Arrays.asList(
+                new ConnectorColumn("id", ConnectorType.of("INT"), null, false, null),
+                new ConnectorColumn("doc", ConnectorType.of("VARIANT"), null, true, null));
+        return ConnectorCreateTableRequest.builder()
+                .dbName("db1")
+                .tableName("vortex_variant")
+                .columns(columns)
+                .properties(Collections.singletonMap("file.format", "vortex"))
+                .ifNotExists(false)
+                .build();
+    }
+
     private static PaimonTableHandle handle() {
         return new PaimonTableHandle("db1", "t1",
                 Collections.singletonList("id"), Collections.singletonList("id"));
@@ -234,6 +247,22 @@ public void createTableBuildsSchemaOutsideAuthenticatorSoSchemaFailureIsRaw() {
                 "schema build failure must never reach the remote catalog seam");
     }
 
+    @Test
+    public void createTableRejectsVortexVariantBeforeRemoteCatalogCall() {
+        RecordingPaimonCatalogOps ops = new RecordingPaimonCatalogOps();
+        RecordingConnectorContext ctx = new RecordingConnectorContext();
+
+        DorisConnectorException ex = Assertions.assertThrows(DorisConnectorException.class,
+                () -> metadata(ops, ctx).createTable(null, requestWithVortexVariant()));
+
+        Assertions.assertTrue(ex.getMessage().contains(
+                "Vortex file format does not support type VARIANT"));
+        Assertions.assertEquals(0, ctx.authCount,
+                "schema validation must fail before entering the authenticator");
+        Assertions.assertTrue(ops.log.isEmpty(),
+                "an invalid Vortex schema must not leave a table in a remote REST catalog");
+    }
+
     // ==================== dropTable ====================
 
     @Test

From 01d75c27da14f502139c9e5bd814b9d3ea6b7bb0 Mon Sep 17 00:00:00 2001
From: moke-HU <25567926679@qq.com>
Date: Sat, 15 Aug 2026 15:23:54 +0800
Subject: [PATCH 7/7] fix(paimon): satisfy variant static checks

---
 .../data_type_variant_serde.cpp               |  2 +-
 .../format/table/paimon_jni_reader_test.cpp   | 27 ++++++++++---------
 2 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/be/src/core/data_type_serde/data_type_variant_serde.cpp b/be/src/core/data_type_serde/data_type_variant_serde.cpp
index a57aaaaacf0c20..e7fab23c251933 100644
--- a/be/src/core/data_type_serde/data_type_variant_serde.cpp
+++ b/be/src/core/data_type_serde/data_type_variant_serde.cpp
@@ -101,7 +101,7 @@ Status write_variant_column_to_arrow_struct(const IColumn& column, const ColumnV
         if (string_root && !root->is_null_at(cast_set<size_t>(row))) {
             JsonbWriter writer;
             if (!writer.writeStartString() ||
-                (serialized_value.size() != 0 &&
+                (!serialized_value.empty() &&
                  !writer.writeString(serialized_value.data(), serialized_value.size())) ||
                 !writer.writeEndString()) {
                 return Status::InternalError("Failed to encode legacy Variant string as JSONB");
diff --git a/be/test/format/table/paimon_jni_reader_test.cpp b/be/test/format/table/paimon_jni_reader_test.cpp
index 0e583178caf8dc..506bb46dd6e2f6 100644
--- a/be/test/format/table/paimon_jni_reader_test.cpp
+++ b/be/test/format/table/paimon_jni_reader_test.cpp
@@ -101,13 +101,13 @@ TEST(LegacyPaimonJniReaderTest, DecodesVariantV2BinaryStructFromJavaMetadata) {
     std::array<uint8_t, 2> outer_nulls {0, 1};
     std::array<uint8_t, 2> child_nulls {0, 1};
     std::array<JavaVarbinaryEntry, 2> value_entries {
-            JavaVarbinaryEntry {static_cast<int64_t>(expected.value.size),
-                                reinterpret_cast<uint64_t>(expected.value.data)},
-            JavaVarbinaryEntry {0, 0}};
+            JavaVarbinaryEntry {.length = static_cast<int64_t>(expected.value.size),
+                                .address = reinterpret_cast<uint64_t>(expected.value.data)},
+            JavaVarbinaryEntry {.length = 0, .address = 0}};
     std::array<JavaVarbinaryEntry, 2> metadata_entries {
-            JavaVarbinaryEntry {static_cast<int64_t>(expected.metadata.size),
-                                reinterpret_cast<uint64_t>(expected.metadata.data)},
-            JavaVarbinaryEntry {0, 0}};
+            JavaVarbinaryEntry {.length = static_cast<int64_t>(expected.metadata.size),
+                                .address = reinterpret_cast<uint64_t>(expected.metadata.data)},
+            JavaVarbinaryEntry {.length = 0, .address = 0}};
     std::array<long, 5> metadata {reinterpret_cast<long>(outer_nulls.data()),
                                   reinterpret_cast<long>(child_nulls.data()),
                                   reinterpret_cast<long>(value_entries.data()),
@@ -130,7 +130,8 @@ TEST(LegacyPaimonJniReaderTest, DecodesVariantV2BinaryStructFromJavaMetadata) {
     EXPECT_TRUE(variants.get_value_ref(1).is_null());
 }
 
-TEST(LegacyPaimonJniReaderTest, DecodesLegacyVariantBinaryStructFromJavaMetadata) {
+TEST(LegacyPaimonJniReaderTest, // NOLINT(readability-function-cognitive-complexity)
+     DecodesLegacyVariantBinaryStructFromJavaMetadata) {
     const std::vector<std::string> json_rows {
             R"({"name":"alpha","score":12.5,"tags":["dts","fluss","paimon"]})",
             R"({"active":true,"name":"beta","nested":{"version":"2.0"}})", "null", "null", "123"};
@@ -146,13 +147,13 @@ TEST(LegacyPaimonJniReaderTest, DecodesLegacyVariantBinaryStructFromJavaMetadata
     std::array<JavaVarbinaryEntry, 5> metadata_entries;
     for (size_t row = 0; row < json_rows.size(); ++row) {
         const VariantRef value = source.value_at(row);
-        value_entries[row] = {static_cast<int64_t>(value.value.size),
-                              reinterpret_cast<uint64_t>(value.value.data)};
-        metadata_entries[row] = {static_cast<int64_t>(value.metadata.size),
-                                 reinterpret_cast<uint64_t>(value.metadata.data)};
+        value_entries[row] = {.length = static_cast<int64_t>(value.value.size),
+                              .address = reinterpret_cast<uint64_t>(value.value.data)};
+        metadata_entries[row] = {.length = static_cast<int64_t>(value.metadata.size),
+                                 .address = reinterpret_cast<uint64_t>(value.metadata.data)};
     }
-    value_entries[3] = {0, 0};
-    metadata_entries[3] = {0, 0};
+    value_entries[3] = {.length = 0, .address = 0};
+    metadata_entries[3] = {.length = 0, .address = 0};
     std::array<long, 5> metadata {reinterpret_cast<long>(outer_nulls.data()),
                                   reinterpret_cast<long>(child_nulls.data()),
                                   reinterpret_cast<long>(value_entries.data()),