This is an automated email from the ASF dual-hosted git repository.

jt2594838 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git


The following commit(s) were added to refs/heads/master by this push:
     new 65ef92f60a0 Fix Prepared Table-Model INSERT VALUES Execution (#19078)
65ef92f60a0 is described below

commit 65ef92f60a0f23d2d98be55f9f921e463d5da707
Author: Caideyipi <[email protected]>
AuthorDate: Wed Nov 4 09:57:09 2026 +0800

    Fix Prepared Table-Model INSERT VALUES Execution (#19078)
    
    * Enforce SQL read-only checks before analysis
    
    * Narrow PR to prepared VALUES fixes
---
 .../it/db/it/IoTDBSetSystemStatusTableIT.java      |  35 +++++
 .../iotdb/db/queryengine/plan/Coordinator.java     |  10 +-
 .../plan/relational/sql/ast/InsertRows.java        |  45 ++++++
 .../plan/statement/crud/InsertBaseStatement.java   |  22 ++-
 .../plan/statement/crud/InsertRowsStatement.java   |   6 +-
 .../relational/sql/AstMemoryEstimatorTest.java     | 168 +++++++++++++++++++++
 6 files changed, 282 insertions(+), 4 deletions(-)

diff --git 
a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBSetSystemStatusTableIT.java
 
b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBSetSystemStatusTableIT.java
index 4dac5e9feb4..685610a6635 100644
--- 
a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBSetSystemStatusTableIT.java
+++ 
b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBSetSystemStatusTableIT.java
@@ -25,6 +25,7 @@ import org.apache.iotdb.itbase.category.TableClusterIT;
 import org.apache.iotdb.itbase.category.TableLocalStandaloneIT;
 import org.apache.iotdb.itbase.env.BaseEnv;
 import org.apache.iotdb.itbase.exception.InconsistentDataException;
+import org.apache.iotdb.itbase.runtime.ClusterTestConnection;
 
 import org.awaitility.Awaitility;
 import org.junit.AfterClass;
@@ -52,6 +53,40 @@ public class IoTDBSetSystemStatusTableIT {
     EnvFactory.getEnv().cleanClusterEnvironment();
   }
 
+  @Test
+  public void testPreparedInsertValuesExecution() throws Exception {
+    try (Connection tableConnection = 
EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+        Statement table = tableConnection.createStatement();
+        Statement prepared =
+            (tableConnection instanceof ClusterTestConnection
+                    ? ((ClusterTestConnection) tableConnection)
+                        .writeConnection.getUnderlyingConnection()
+                    : tableConnection)
+                .createStatement()) {
+      table.execute("create database prepared_insert_execution");
+      table.execute("use prepared_insert_execution");
+      table.execute("create table prepared_t(d STRING TAG,a STRING ATTRIBUTE,s 
INT32 FIELD)");
+      prepared.execute(
+          "prepare prepared_insert from insert into prepared_t(time,d,a,s) "
+              + "values(1,'p1','prepared',11),(2,'p2','prepared',12)");
+      prepared.execute("execute prepared_insert");
+      table.execute("update prepared_t set a='changed' where d='p1'");
+      prepared.execute("execute prepared_insert");
+      prepared.execute(
+          "execute immediate 'insert into prepared_t(time,d,a,s) "
+              + "values(3,''p3'',''immediate'',13)'");
+      try (ResultSet result = table.executeQuery("select d,a,s from prepared_t 
order by time")) {
+        for (int i = 1; i <= 3; i++) {
+          Assert.assertTrue(result.next());
+          Assert.assertEquals("p" + i, result.getString(1));
+          Assert.assertEquals(i == 3 ? "immediate" : "prepared", 
result.getString(2));
+          Assert.assertEquals(10 + i, result.getInt(3));
+        }
+        Assert.assertFalse(result.next());
+      }
+    }
+  }
+
   @Test
   public void setSystemStatus() {
     try (Connection connection = 
EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java
index 79e6e38d4fe..eb3d0e68698 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/Coordinator.java
@@ -103,6 +103,7 @@ import 
org.apache.iotdb.db.queryengine.plan.relational.sql.ast.ExplainAnalyze;
 import 
org.apache.iotdb.db.queryengine.plan.relational.sql.ast.ExplainOutputFormat;
 import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.ExtendRegion;
 import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Flush;
+import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.InsertRows;
 import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.KillQuery;
 import 
org.apache.iotdb.db.queryengine.plan.relational.sql.ast.LoadConfiguration;
 import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.LoadModel;
@@ -815,6 +816,10 @@ public class Coordinator {
 
       org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Statement 
resolvedSql =
           preparedInfo.getSql();
+      if (resolvedSql instanceof InsertRows) {
+        resolvedSql = ((InsertRows) resolvedSql).copyForPreparedExecution();
+      }
+      innerStatement = resolvedSql;
       parameterLookup =
           ParameterExtractor.bindParameters(resolvedSql, 
executeStatement.getParameters());
       parameters = new ArrayList<>(executeStatement.getParameters());
@@ -838,6 +843,7 @@ public class Coordinator {
 
       org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Statement 
resolvedSql =
           sqlParser.createStatement(sql, clientSession.getZoneId(), 
clientSession);
+      innerStatement = resolvedSql;
 
       if (!literalParameters.isEmpty()) {
         parameterLookup = ParameterExtractor.bindParameters(resolvedSql, 
literalParameters);
@@ -856,8 +862,8 @@ public class Coordinator {
       }
     }
 
-    if (statement instanceof WrappedInsertStatement) {
-      ((WrappedInsertStatement) statement).setContext(queryContext);
+    if (innerStatement instanceof WrappedInsertStatement) {
+      ((WrappedInsertStatement) innerStatement).setContext(queryContext);
     }
 
     // Create QueryExecution with TableModelPlanner
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InsertRows.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InsertRows.java
index 6b5804ba4eb..f40c8ca0350 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InsertRows.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/ast/InsertRows.java
@@ -20,6 +20,7 @@
 package org.apache.iotdb.db.queryengine.plan.relational.sql.ast;
 
 import org.apache.iotdb.calc.exception.QueryProcessException;
+import org.apache.iotdb.commons.path.PartialPath;
 import 
org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.IAstVisitor;
 import org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory;
 import org.apache.iotdb.db.queryengine.common.MPPQueryContext;
@@ -32,6 +33,7 @@ import 
org.apache.iotdb.db.queryengine.plan.statement.crud.InsertRowsStatement;
 
 import org.apache.tsfile.enums.TSDataType;
 import org.apache.tsfile.utils.Constants;
+import org.apache.tsfile.utils.RamUsageEstimator;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -44,6 +46,9 @@ import java.util.Objects;
 
 public class InsertRows extends WrappedInsertStatement {
 
+  private static final long INSTANCE_SIZE =
+      RamUsageEstimator.shallowSizeOfInstance(InsertRows.class);
+
   // Only InsertRows constructed by Pipe will be set to true
   private boolean allowCreateTable = false;
 
@@ -61,6 +66,46 @@ public class InsertRows extends WrappedInsertStatement {
     return ((InsertRowsStatement) super.getInnerTreeStatement());
   }
 
+  @Override
+  public long ramBytesUsed() {
+    return INSTANCE_SIZE + getInnerTreeStatement().ramBytesUsed();
+  }
+
+  /** Copy the parsed VALUES payload so analysis cannot mutate the prepared 
statement. */
+  public InsertRows copyForPreparedExecution() {
+    InsertRowsStatement original = getInnerTreeStatement();
+    List<InsertRowStatement> rows = new 
ArrayList<>(original.getInsertRowStatementList().size());
+    for (InsertRowStatement row : original.getInsertRowStatementList()) {
+      InsertRowStatement copy = new InsertRowStatement();
+      copy.setDevicePath(new 
PartialPath(row.getDevicePath().getNodes().clone()));
+      copy.setTime(row.getTime());
+      copy.setMeasurements(copyArray(row.getMeasurements()));
+      copy.setMeasurementSchemas(copyArray(row.getMeasurementSchemas()));
+      copy.setDataTypes(copyArray(row.getDataTypes()));
+      copy.setColumnCategories(copyArray(row.getColumnCategories()));
+      copy.setValues(copyArray(row.getValues()));
+      copy.setNeedInferType(row.isNeedInferType());
+      copy.setAligned(row.isAligned());
+      copy.setWriteToTable(row.isWriteToTable());
+      if (row.getFailedMeasurementInfoMap() != null) {
+        copy.setFailedMeasurementIndex2Info(new 
HashMap<>(row.getFailedMeasurementInfoMap()));
+      }
+      row.getDatabaseName().ifPresent(copy::setDatabaseName);
+      rows.add(copy);
+    }
+    InsertRowsStatement copy = new InsertRowsStatement();
+    copy.setInsertRowStatementList(rows);
+    copy.setUniformTargets(original.isUniformTargets());
+    copy.setWriteToTable(original.isWriteToTable());
+    InsertRows result = new InsertRows(copy, null);
+    result.setAllowCreateTable(allowCreateTable);
+    return result;
+  }
+
+  private static <T> T[] copyArray(T[] array) {
+    return array == null ? null : array.clone();
+  }
+
   @Override
   public void updateAfterSchemaValidation(MPPQueryContext context) throws 
QueryProcessException {
     getInnerTreeStatement().updateAfterSchemaValidation(context);
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertBaseStatement.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertBaseStatement.java
index e305a13fdbd..385605e6cad 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertBaseStatement.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertBaseStatement.java
@@ -53,6 +53,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -579,7 +580,10 @@ public abstract class InsertBaseStatement extends 
Statement implements Accountab
 
   protected abstract void subRemoveAttributeColumns(List<Integer> 
columnsToKeep);
 
-  public static class FailedMeasurementInfo {
+  public static class FailedMeasurementInfo implements Accountable {
+    private static final long INSTANCE_SIZE =
+        RamUsageEstimator.shallowSizeOfInstance(FailedMeasurementInfo.class);
+
     protected String measurement;
     protected TSDataType dataType;
     protected Object value;
@@ -604,6 +608,21 @@ public abstract class InsertBaseStatement extends 
Statement implements Accountab
     public Object getValue() {
       return value;
     }
+
+    @Override
+    public long ramBytesUsed() {
+      long size =
+          INSTANCE_SIZE
+              + RamUsageEstimator.sizeOf(measurement)
+              + RamUsageEstimator.sizeOfObject(value);
+      // Exceptions can retain additional copies of the failed input in their 
messages.
+      Set<Throwable> visited = Collections.newSetFromMap(new 
IdentityHashMap<>());
+      for (Throwable error = cause; error != null && visited.add(error); error 
= error.getCause()) {
+        size +=
+            RamUsageEstimator.sizeOfObject(error) + 
RamUsageEstimator.sizeOf(error.getMessage());
+      }
+      return size;
+    }
   }
 
   // endregion
@@ -1015,6 +1034,7 @@ public abstract class InsertBaseStatement extends 
Statement implements Accountab
             + RamUsageEstimator.sizeOf(measurements)
             + RamUsageEstimator.shallowSizeOf(dataTypes)
             + RamUsageEstimator.shallowSizeOf(columnCategories)
+            + RamUsageEstimator.sizeOfMap(failedMeasurementIndex2Info)
             // We assume that the integers are all cached by JVM
             + shallowSizeOfList(tagColumnIndices)
             + shallowSizeOfList(attrColumnIndices)
diff --git 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertRowsStatement.java
 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertRowsStatement.java
index 728831a7d44..e89d32231c5 100644
--- 
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertRowsStatement.java
+++ 
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertRowsStatement.java
@@ -233,8 +233,12 @@ public class InsertRowsStatement extends 
InsertBaseStatement {
     return INSTANCE_SIZE
         + (Objects.nonNull(insertRowStatementList)
             ? UpdateDetailContainer.LIST_SIZE
+                + RamUsageEstimator.alignObjectSize(
+                    RamUsageEstimator.NUM_BYTES_ARRAY_HEADER
+                        + (long) RamUsageEstimator.NUM_BYTES_OBJECT_REF
+                            * insertRowStatementList.size())
                 + insertRowStatementList.stream()
-                    .mapToLong(InsertRowStatement::calculateBytesUsed)
+                    .mapToLong(InsertRowStatement::ramBytesUsed)
                     .reduce(0L, Long::sum)
             : 0);
   }
diff --git 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/sql/AstMemoryEstimatorTest.java
 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/sql/AstMemoryEstimatorTest.java
index 0738b8cd27a..c107593c84f 100644
--- 
a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/sql/AstMemoryEstimatorTest.java
+++ 
b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/sql/AstMemoryEstimatorTest.java
@@ -19,17 +19,37 @@
 
 package org.apache.iotdb.db.queryengine.plan.relational.sql;
 
+import org.apache.iotdb.commons.memory.IMemoryBlock;
 import org.apache.iotdb.commons.queryengine.plan.relational.sql.ast.Statement;
+import org.apache.iotdb.commons.schema.table.TsTable;
+import org.apache.iotdb.commons.schema.table.column.FieldColumnSchema;
+import org.apache.iotdb.commons.schema.table.column.TagColumnSchema;
+import org.apache.iotdb.commons.schema.table.column.TimeColumnSchema;
+import org.apache.iotdb.db.conf.IoTDBConfig;
+import org.apache.iotdb.db.conf.IoTDBDescriptor;
+import org.apache.iotdb.db.protocol.session.ClientSession;
 import org.apache.iotdb.db.protocol.session.IClientSession;
 import org.apache.iotdb.db.protocol.session.InternalClientSession;
+import org.apache.iotdb.db.protocol.session.PreparedStatementInfo;
+import org.apache.iotdb.db.queryengine.plan.Coordinator;
+import 
org.apache.iotdb.db.queryengine.plan.execution.config.session.PreparedStatementHelper;
+import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.InsertRows;
+import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Prepare;
 import org.apache.iotdb.db.queryengine.plan.relational.sql.parser.SqlParser;
+import org.apache.iotdb.db.queryengine.plan.statement.crud.InsertRowStatement;
+import org.apache.iotdb.db.schemaengine.table.DataNodeTableCache;
+import org.apache.iotdb.db.schemaengine.table.ITableCache;
 
+import org.apache.tsfile.enums.TSDataType;
 import org.junit.Before;
 import org.junit.Test;
 
 import java.time.ZoneId;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
 public class AstMemoryEstimatorTest {
@@ -756,6 +776,154 @@ public class AstMemoryEstimatorTest {
     assertTrue("Memory size should be positive", memorySize > 0);
   }
 
+  @Test
+  public void testPreparedInsertValuesMemoryAccounting() {
+    TsTable table = new TsTable("insert_memory");
+    table.addColumnSchema(new TimeColumnSchema("time", TSDataType.TIMESTAMP));
+    table.addColumnSchema(new TagColumnSchema("device", TSDataType.STRING));
+    table.addColumnSchema(new FieldColumnSchema("value", TSDataType.STRING));
+    ITableCache cache = DataNodeTableCache.getInstance();
+    cache.preUpdateTable("testdb", table, null);
+    cache.commitUpdateTable("testdb", "insert_memory", null, null);
+    ClientSession session = new ClientSession(null);
+    IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+    int originalDataNodeId = config.getDataNodeId();
+    config.setDataNodeId(0);
+    try {
+      IMemoryBlock memory = Coordinator.getCoordinatorMemoryBlock();
+      long initialUsage = memory.getUsedMemoryInBytes();
+      Prepare prepare =
+          (Prepare)
+              parseSQL(
+                  "PREPARE insert_values FROM INSERT INTO 
insert_memory(time,device,value) "
+                      + "VALUES(1,'d1','small'),(2,'d2',null)");
+      InsertRows insert = (InsertRows) prepare.getSql();
+      long size = insert.ramBytesUsed();
+      long rowSizes =
+          insert.getInnerTreeStatement().getInsertRowStatementList().stream()
+              .mapToLong(row -> row.ramBytesUsed())
+              .sum();
+      assertTrue(size > rowSizes);
+      assertTrue(prepare.ramBytesUsed() > size);
+      assertEquals(size, insert.ramBytesUsed());
+
+      Statement singleRow =
+          parseSQL("INSERT INTO insert_memory(time,device,value) 
VALUES(1,'d1','small')");
+      Statement largeValue =
+          parseSQL(
+              "INSERT INTO insert_memory(time,device,value) VALUES(1,'d1','"
+                  + "x".repeat(4096)
+                  + "')");
+      assertTrue(size > singleRow.ramBytesUsed());
+      assertTrue(largeValue.ramBytesUsed() > singleRow.ramBytesUsed() + 4000);
+
+      PreparedStatementInfo info =
+          PreparedStatementHelper.register(session, "insert_values", insert);
+      assertSame(insert, info.getSql());
+      assertEquals(size, info.getMemorySizeInBytes());
+      assertEquals(initialUsage + size, memory.getUsedMemoryInBytes());
+      PreparedStatementHelper.unregister(session, "insert_values");
+      assertNull(session.getPreparedStatement("insert_values"));
+      assertEquals(initialUsage, memory.getUsedMemoryInBytes());
+    } finally {
+      if (session.getPreparedStatement("insert_values") != null) {
+        PreparedStatementHelper.unregister(session, "insert_values");
+      }
+      cache.invalid("testdb");
+      config.setDataNodeId(originalDataNodeId);
+    }
+  }
+
+  @Test
+  public void testPreparedInsertValuesParseFailureMemoryAccounting() {
+    TsTable table = new TsTable("insert_failure_memory");
+    table.addColumnSchema(new TimeColumnSchema("time", TSDataType.TIMESTAMP));
+    table.addColumnSchema(new TagColumnSchema("device", TSDataType.STRING));
+    table.addColumnSchema(new FieldColumnSchema("valid", TSDataType.INT32));
+    table.addColumnSchema(new FieldColumnSchema("invalid", TSDataType.INT32));
+    ITableCache cache = DataNodeTableCache.getInstance();
+    cache.preUpdateTable("testdb", table, null);
+    cache.commitUpdateTable("testdb", "insert_failure_memory", null, null);
+    ClientSession session = new ClientSession(null);
+    IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+    boolean originalPartialInsert = config.isEnablePartialInsert();
+    int originalDataNodeId = config.getDataNodeId();
+    config.setEnablePartialInsert(true);
+    config.setDataNodeId(0);
+    try {
+      InsertRows small =
+          (InsertRows) parseSQL("INSERT INTO insert_failure_memory 
VALUES(1,'d1',11,'bad')");
+      InsertRows large =
+          (InsertRows)
+              parseSQL(
+                  "INSERT INTO insert_failure_memory VALUES(1,'d1',11,'" + 
"x".repeat(4096) + "')");
+      InsertRowStatement row = 
large.getInnerTreeStatement().getInsertRowStatementList().get(0);
+      assertEquals(1, row.getFailedMeasurementNumber());
+      assertNull(row.getValues()[2]);
+      assertTrue(large.ramBytesUsed() > small.ramBytesUsed() + 4000);
+
+      IMemoryBlock memory = Coordinator.getCoordinatorMemoryBlock();
+      long initialUsage = memory.getUsedMemoryInBytes();
+      PreparedStatementInfo info =
+          PreparedStatementHelper.register(session, "insert_failure", large);
+      assertEquals(large.ramBytesUsed(), info.getMemorySizeInBytes());
+      assertEquals(initialUsage + large.ramBytesUsed(), 
memory.getUsedMemoryInBytes());
+      PreparedStatementHelper.unregister(session, "insert_failure");
+      assertEquals(initialUsage, memory.getUsedMemoryInBytes());
+    } finally {
+      if (session.getPreparedStatement("insert_failure") != null) {
+        PreparedStatementHelper.unregister(session, "insert_failure");
+      }
+      cache.invalid("testdb");
+      config.setEnablePartialInsert(originalPartialInsert);
+      config.setDataNodeId(originalDataNodeId);
+    }
+  }
+
+  @Test
+  public void testPreparedInsertValuesPreservesParseFailures() {
+    TsTable table = new TsTable("insert_partial");
+    table.addColumnSchema(new TimeColumnSchema("time", TSDataType.TIMESTAMP));
+    table.addColumnSchema(new TagColumnSchema("device", TSDataType.STRING));
+    table.addColumnSchema(new FieldColumnSchema("valid", TSDataType.INT32));
+    table.addColumnSchema(new FieldColumnSchema("invalid", TSDataType.INT32));
+    ITableCache cache = DataNodeTableCache.getInstance();
+    cache.preUpdateTable("testdb", table, null);
+    cache.commitUpdateTable("testdb", "insert_partial", null, null);
+    IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+    boolean originalPartialInsert = config.isEnablePartialInsert();
+    config.setEnablePartialInsert(true);
+    try {
+      Prepare prepare =
+          (Prepare)
+              parseSQL(
+                  "PREPARE insert_partial FROM INSERT INTO insert_partial "
+                      + "VALUES(1,'d1',11,'invalid integer')");
+      InsertRows original = (InsertRows) prepare.getSql();
+      InsertRowStatement originalRow =
+          original.getInnerTreeStatement().getInsertRowStatementList().get(0);
+      assertEquals(1, originalRow.getFailedMeasurementNumber());
+      for (int i = 0; i < 2; i++) {
+        InsertRows execution = original.copyForPreparedExecution();
+        InsertRowStatement executionRow =
+            
execution.getInnerTreeStatement().getInsertRowStatementList().get(0);
+        execution.getInnerTreeStatement().semanticCheck();
+        assertEquals(originalRow.getFailedMeasurements(), 
executionRow.getFailedMeasurements());
+        assertEquals(originalRow.getFailedMessages(), 
executionRow.getFailedMessages());
+        assertEquals(11, executionRow.getValues()[1]);
+        assertNotSame(
+            originalRow.getFailedMeasurementInfoMap(), 
executionRow.getFailedMeasurementInfoMap());
+        executionRow.removeAllFailedMeasurementMarks();
+        assertEquals(1, originalRow.getFailedMeasurementNumber());
+        assertNull(originalRow.getMeasurements()[2]);
+        assertNull(originalRow.getValues()[2]);
+      }
+    } finally {
+      cache.invalid("testdb");
+      config.setEnablePartialInsert(originalPartialInsert);
+    }
+  }
+
   @Test
   public void testExecute() {
     Statement statement = parseSQL("EXECUTE myquery");

Reply via email to