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 e92ecf1d5d6 Fix table TTL reset propagation to DataNodes (#19110)
e92ecf1d5d6 is described below

commit e92ecf1d5d62de0c67a52e80ff6cb7e307ab6583
Author: Caideyipi <[email protected]>
AuthorDate: Thu Nov 5 12:16:44 2026 +0800

    Fix table TTL reset propagation to DataNodes (#19110)
    
    * Fix table TTL reset propagation to DataNodes
    
    * Fix table TTL default reset consistency
---
 .../manual/enhanced/IoTDBPipeMetaIT.java           |   9 +-
 .../iotdb/relational/it/schema/IoTDBTableIT.java   |  89 ++++++++++
 .../manager/schema/ClusterSchemaManager.java       |  30 +++-
 .../schema/table/SetTablePropertiesProcedure.java  |  16 +-
 .../manager/ClusterSchemaManagerTest.java          | 179 +++++++++++++++++++++
 .../table/SetTablePropertiesProcedureTest.java     |  78 +++++++++
 6 files changed, 392 insertions(+), 9 deletions(-)

diff --git 
a/integration-test/src/test/java/org/apache/iotdb/pipe/it/dual/tablemodel/manual/enhanced/IoTDBPipeMetaIT.java
 
b/integration-test/src/test/java/org/apache/iotdb/pipe/it/dual/tablemodel/manual/enhanced/IoTDBPipeMetaIT.java
index f513a3e4f3a..5d0d59609e8 100644
--- 
a/integration-test/src/test/java/org/apache/iotdb/pipe/it/dual/tablemodel/manual/enhanced/IoTDBPipeMetaIT.java
+++ 
b/integration-test/src/test/java/org/apache/iotdb/pipe/it/dual/tablemodel/manual/enhanced/IoTDBPipeMetaIT.java
@@ -46,6 +46,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
@@ -94,7 +95,9 @@ public class IoTDBPipeMetaIT extends 
AbstractPipeTableModelDualManualIT {
       Assert.assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), 
status.getCode());
 
       final String dbName = "test";
-      TableModelUtils.createDatabase(senderEnv, dbName, 300);
+      // Keep rows alive while asynchronous metadata and data synchronization 
finish.
+      final long databaseTtl = TimeUnit.DAYS.toMillis(1);
+      TableModelUtils.createDatabase(senderEnv, dbName, databaseTtl);
 
       TestUtils.executeNonQueries(
           dbName,
@@ -115,7 +118,7 @@ public class IoTDBPipeMetaIT extends 
AbstractPipeTableModelDualManualIT {
           receiverEnv,
           "show tables from test",
           "TableName,TTL(ms),",
-          Collections.singleton("table1,300,"),
+          Collections.singleton("table1," + databaseTtl + ","),
           dbName);
 
       // Test devices
@@ -159,7 +162,7 @@ public class IoTDBPipeMetaIT extends 
AbstractPipeTableModelDualManualIT {
           receiverEnv,
           "show tables from test",
           "TableName,TTL(ms),",
-          Collections.singleton("table1,300,"),
+          Collections.singleton("table1," + databaseTtl + ","),
           dbName);
 
       TestUtils.assertDataEventuallyOnEnv(
diff --git 
a/integration-test/src/test/java/org/apache/iotdb/relational/it/schema/IoTDBTableIT.java
 
b/integration-test/src/test/java/org/apache/iotdb/relational/it/schema/IoTDBTableIT.java
index 037ac00cd1f..078a6a71a71 100644
--- 
a/integration-test/src/test/java/org/apache/iotdb/relational/it/schema/IoTDBTableIT.java
+++ 
b/integration-test/src/test/java/org/apache/iotdb/relational/it/schema/IoTDBTableIT.java
@@ -21,13 +21,16 @@ package org.apache.iotdb.relational.it.schema;
 
 import org.apache.iotdb.db.it.utils.TestUtils;
 import org.apache.iotdb.isession.ITableSession;
+import org.apache.iotdb.isession.SessionConfig;
 import org.apache.iotdb.it.env.EnvFactory;
+import org.apache.iotdb.it.env.cluster.node.DataNodeWrapper;
 import org.apache.iotdb.it.framework.IoTDBTestRunner;
 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.rpc.IoTDBConnectionException;
 import org.apache.iotdb.rpc.StatementExecutionException;
+import org.apache.iotdb.rpc.TSStatusCode;
 
 import org.apache.tsfile.enums.ColumnCategory;
 import org.apache.tsfile.enums.TSDataType;
@@ -52,6 +55,7 @@ import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.concurrent.TimeUnit;
 
 import static 
org.apache.iotdb.commons.schema.column.ColumnHeaderConstant.describeTableColumnHeaders;
 import static 
org.apache.iotdb.commons.schema.column.ColumnHeaderConstant.describeTableDetailsColumnHeaders;
@@ -79,6 +83,91 @@ public class IoTDBTableIT {
     EnvFactory.getEnv().cleanClusterEnvironment();
   }
 
+  @Test
+  public void testResetTableTtlUsesDatabaseDefault() throws Exception {
+    final String database = "ttl_default_reset";
+    final long day = TimeUnit.DAYS.toMillis(1);
+    final long old = System.currentTimeMillis() - 2 * day;
+    final long recent = System.currentTimeMillis() - 
TimeUnit.MINUTES.toMillis(1);
+    try (final Connection connection =
+            EnvFactory.getEnv().getConnection(BaseEnv.TABLE_SQL_DIALECT);
+        final Statement statement = connection.createStatement()) {
+      try {
+        statement.execute("CREATE DATABASE " + database + " WITH (ttl=" + 7 * 
day + ")");
+        statement.execute("USE " + database);
+        statement.execute("CREATE TABLE inherited(dev STRING TAG,v INT32 
FIELD)");
+        statement.execute(
+            "CREATE TABLE overridden(dev STRING TAG,v INT32 FIELD) WITH (ttl=" 
+ 30 * day + ")");
+        for (final String table : new String[] {"inherited", "overridden"}) {
+          statement.execute(
+              "INSERT INTO "
+                  + table
+                  + "(time,dev,v) VALUES("
+                  + old
+                  + ",'d',1),("
+                  + recent
+                  + ",'d',2)");
+          TestUtils.assertDataEventuallyOnEnv(
+              EnvFactory.getEnv(),
+              "SELECT v FROM " + table + " ORDER BY time",
+              "v,",
+              new HashSet<>(Arrays.asList("1,", "2,")),
+              30,
+              database,
+              null);
+        }
+
+        statement.execute("ALTER DATABASE " + database + " SET PROPERTIES 
ttl=" + day);
+        statement.execute("ALTER TABLE inherited SET PROPERTIES ttl=DEFAULT");
+        TestUtils.tableResultSetEqualTestUnordered(
+            "SHOW TABLES",
+            new String[] {"TableName", "TTL(ms)"},
+            new String[] {"inherited," + day + ",", "overridden," + 30 * day + 
","},
+            database);
+        TestUtils.tableResultSetEqualTestUnordered(
+            "SELECT v FROM inherited", new String[] {"v"}, new String[] 
{"2,"}, database);
+        TestUtils.tableResultSetEqualTestUnordered(
+            "SELECT v FROM overridden", new String[] {"v"}, new String[] 
{"1,", "2,"}, database);
+        for (final DataNodeWrapper node : 
EnvFactory.getEnv().getDataNodeWrapperList()) {
+          try (final Connection writer =
+                  EnvFactory.getEnv()
+                      .getConnection(
+                          node,
+                          SessionConfig.DEFAULT_USER,
+                          SessionConfig.DEFAULT_PASSWORD,
+                          BaseEnv.TABLE_SQL_DIALECT);
+              final Statement write = writer.createStatement()) {
+            final SQLException exception =
+                Assert.assertThrows(
+                    SQLException.class,
+                    () ->
+                        write.execute(
+                            "INSERT INTO "
+                                + database
+                                + ".inherited(time,dev,v) VALUES("
+                                + (old + 1)
+                                + ",'d',3)"));
+            assertEquals(TSStatusCode.OUT_OF_TTL.getStatusCode(), 
exception.getErrorCode());
+          }
+        }
+
+        statement.execute("ALTER DATABASE " + database + " SET PROPERTIES 
ttl='INF'");
+        statement.execute("ALTER TABLE inherited SET PROPERTIES ttl=DEFAULT");
+        statement.execute("INSERT INTO inherited(time,dev,v) VALUES(" + (old + 
1) + ",'d',3)");
+        TestUtils.assertDataEventuallyOnEnv(
+            EnvFactory.getEnv(),
+            "SELECT v FROM inherited WHERE v=3",
+            "v,",
+            Collections.singleton("3,"),
+            30,
+            database,
+            null);
+      } finally {
+        statement.execute("DROP DATABASE IF EXISTS " + database);
+      }
+    }
+  }
+
   @Test
   public void testManageTable() {
     try (final Connection connection =
diff --git 
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/schema/ClusterSchemaManager.java
 
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/schema/ClusterSchemaManager.java
index c38c559ae29..f6988828f40 100644
--- 
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/schema/ClusterSchemaManager.java
+++ 
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/schema/ClusterSchemaManager.java
@@ -23,6 +23,7 @@ import org.apache.iotdb.common.rpc.thrift.TConsensusGroupType;
 import org.apache.iotdb.common.rpc.thrift.TDataNodeLocation;
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
 import org.apache.iotdb.commons.conf.CommonDescriptor;
+import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.exception.MetadataException;
 import org.apache.iotdb.commons.exception.table.ColumnInAlterException;
 import org.apache.iotdb.commons.exception.table.ColumnInDeletionException;
@@ -1968,7 +1969,8 @@ public class ClusterSchemaManager {
       final Map<String, String> updatedProperties,
       final boolean isTableView)
       throws MetadataException {
-    final TsTable originalTable = getTableWithUsingStatusIfExists(database, 
tableName).orElse(null);
+    final TsTable originalTable =
+        getTableWithUsingStatusIfExists(database, 
tableName).map(TsTable::new).orElse(null);
 
     if (Objects.isNull(originalTable)) {
       return new Pair<>(
@@ -1994,12 +1996,32 @@ public class ClusterSchemaManager {
           null);
     }
 
+    // Resolve DEFAULT before comparing properties and preparing the table 
sent to DataNodes.
+    if (updatedProperties.containsKey(TsTable.TTL_PROPERTY)
+        && Objects.isNull(updatedProperties.get(TsTable.TTL_PROPERTY))) {
+      try {
+        final TDatabaseSchema schema = getDatabaseSchemaByName(database);
+        updatedProperties.put(
+            TsTable.TTL_PROPERTY,
+            schema.isSetTTL() && schema.getTTL() != Long.MAX_VALUE
+                ? String.valueOf(schema.getTTL())
+                : IoTDBConstant.TTL_INFINITE);
+      } catch (final DatabaseNotExistsException e) {
+        throw new MetadataException(e);
+      }
+    }
+
     updatedProperties
         .keySet()
         .removeIf(
-            key ->
-                Objects.equals(
-                    updatedProperties.get(key), 
originalTable.getPropValue(key).orElse(null)));
+            key -> {
+              if (TsTable.TTL_PROPERTY.equals(key)
+                  && 
IoTDBConstant.TTL_INFINITE.equalsIgnoreCase(updatedProperties.get(key))) {
+                return originalTable.getTableTTL() == Long.MAX_VALUE;
+              }
+              return Objects.equals(
+                  updatedProperties.get(key), 
originalTable.getPropValue(key).orElse(null));
+            });
     if (updatedProperties.isEmpty()) {
       return new Pair<>(RpcUtils.SUCCESS_STATUS, null);
     }
diff --git 
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/SetTablePropertiesProcedure.java
 
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/SetTablePropertiesProcedure.java
index 56a033d0110..d48d857f5c2 100644
--- 
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/SetTablePropertiesProcedure.java
+++ 
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/procedure/impl/schema/table/SetTablePropertiesProcedure.java
@@ -20,6 +20,7 @@
 package org.apache.iotdb.confignode.procedure.impl.schema.table;
 
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.exception.MetadataException;
 import org.apache.iotdb.commons.schema.table.TsTable;
 import org.apache.iotdb.confignode.consensus.request.ConfigPhysicalPlan;
@@ -35,7 +36,9 @@ import org.apache.tsfile.utils.Pair;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 
 public class SetTablePropertiesProcedure extends 
AbstractSetPropertiesProcedure {
 
@@ -68,9 +71,18 @@ public class SetTablePropertiesProcedure extends 
AbstractSetPropertiesProcedure
   @Override
   protected ConfigPhysicalPlan createSetPropertiesPlan(
       final Map<String, String> properties, final boolean isRollback) {
+    final Map<String, String> propertiesToSet =
+        isRollback
+                && properties.containsKey(TsTable.TTL_PROPERTY)
+                && Objects.isNull(properties.get(TsTable.TTL_PROPERTY))
+            ? new HashMap<>(properties)
+            : properties;
+    if (propertiesToSet != properties) {
+      propertiesToSet.put(TsTable.TTL_PROPERTY, IoTDBConstant.TTL_INFINITE);
+    }
     return this instanceof SetViewPropertiesProcedure
-        ? new SetViewPropertiesPlan(database, tableName, properties)
-        : new SetTablePropertiesPlan(database, tableName, properties);
+        ? new SetViewPropertiesPlan(database, tableName, propertiesToSet)
+        : new SetTablePropertiesPlan(database, tableName, propertiesToSet);
   }
 
   @Override
diff --git 
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/ClusterSchemaManagerTest.java
 
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/ClusterSchemaManagerTest.java
index ce6d7df577e..bc66d5e2b94 100644
--- 
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/ClusterSchemaManagerTest.java
+++ 
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/ClusterSchemaManagerTest.java
@@ -41,6 +41,7 @@ import 
org.apache.iotdb.confignode.consensus.request.write.table.PreAlterColumnD
 import 
org.apache.iotdb.confignode.consensus.request.write.table.PreCreateTablePlan;
 import 
org.apache.iotdb.confignode.consensus.request.write.table.PreDeleteColumnPlan;
 import 
org.apache.iotdb.confignode.consensus.request.write.table.PreDeleteTablePlan;
+import 
org.apache.iotdb.confignode.consensus.request.write.table.SetTablePropertiesPlan;
 import 
org.apache.iotdb.confignode.consensus.request.write.table.view.PreCreateTableViewPlan;
 import org.apache.iotdb.confignode.manager.consensus.ConsensusManager;
 import org.apache.iotdb.confignode.manager.node.NodeManager;
@@ -412,4 +413,182 @@ public class ClusterSchemaManagerTest {
         clusterSchemaInfo,
         Mockito.mock(ClusterSchemaQuotaStatistics.class));
   }
+
+  private static ClusterSchemaManager managerOf(
+      final ClusterSchemaInfo clusterSchemaInfo, final String 
existingDatabase) {
+    final IManager configManager = Mockito.mock(IManager.class);
+    final PartitionManager partitionManager = 
Mockito.mock(PartitionManager.class);
+    
Mockito.when(configManager.getPartitionManager()).thenReturn(partitionManager);
+    
Mockito.when(partitionManager.isDatabaseExist(existingDatabase)).thenReturn(true);
+    return new ClusterSchemaManager(
+        configManager, clusterSchemaInfo, 
Mockito.mock(ClusterSchemaQuotaStatistics.class));
+  }
+
+  @Test
+  public void testResetTableTtlUsesFiniteDatabaseDefault() throws Exception {
+    final long day = 86400000L;
+    final String database = "ttl_default_finite_test";
+    for (final String initialTtl :
+        new String[] {null, String.valueOf(7 * day), String.valueOf(day)}) {
+      final ClusterSchemaInfo schemaInfo = new ClusterSchemaInfo();
+      schemaInfo.createDatabase(
+          new DatabaseSchemaPlan(
+              ConfigPhysicalPlanType.CreateDatabase,
+              new TDatabaseSchema(database).setIsTableModel(true)));
+      final TsTable table = new TsTable(TABLE);
+      if (initialTtl != null) {
+        table.addProp(TsTable.TTL_PROPERTY, initialTtl);
+      }
+      schemaInfo.preCreateTable(new PreCreateTablePlan(database, table));
+      schemaInfo.commitCreateTable(new CommitCreateTablePlan(database, TABLE));
+      Assert.assertEquals(
+          TSStatusCode.SUCCESS_STATUS.getStatusCode(),
+          schemaInfo
+              .alterDatabase(
+                  new DatabaseSchemaPlan(
+                      ConfigPhysicalPlanType.AlterDatabase,
+                      new 
TDatabaseSchema(database).setIsTableModel(true).setTTL(day)))
+              .getCode());
+      final ClusterSchemaManager manager = managerOf(schemaInfo, database);
+      final Map<String, String> originalProperties = new HashMap<>();
+      final Map<String, String> updatedProperties = new HashMap<>();
+      updatedProperties.put(TsTable.TTL_PROPERTY, null);
+
+      final Pair<TSStatus, TsTable> result =
+          manager.updateTableProperties(
+              database, TABLE, originalProperties, updatedProperties, false);
+      Assert.assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), 
result.getLeft().getCode());
+      if (String.valueOf(day).equals(initialTtl)) {
+        Assert.assertNull(result.getRight());
+        Assert.assertTrue(updatedProperties.isEmpty());
+        continue;
+      }
+      Assert.assertNotNull(result.getRight());
+      Assert.assertEquals(String.valueOf(day), 
updatedProperties.get(TsTable.TTL_PROPERTY));
+      Assert.assertEquals(initialTtl, 
originalProperties.get(TsTable.TTL_PROPERTY));
+      Assert.assertEquals(day, result.getRight().getTableTTL());
+      Assert.assertEquals(
+          initialTtl,
+          manager
+              .getTableIfExists(database, TABLE)
+              .get()
+              .getPropValue(TsTable.TTL_PROPERTY)
+              .orElse(null));
+      // A concurrent database update must not change the TTL already sent to 
DataNodes.
+      schemaInfo.alterDatabase(
+          new DatabaseSchemaPlan(
+              ConfigPhysicalPlanType.AlterDatabase,
+              new TDatabaseSchema(database).setIsTableModel(true).setTTL(2 * 
day)));
+      Assert.assertEquals(
+          TSStatusCode.SUCCESS_STATUS.getStatusCode(),
+          schemaInfo
+              .setTableProperties(new SetTablePropertiesPlan(database, TABLE, 
updatedProperties))
+              .getCode());
+      Assert.assertEquals(
+          manager.getTableIfExists(database, 
TABLE).get().getPropValue(TsTable.TTL_PROPERTY),
+          result.getRight().getPropValue(TsTable.TTL_PROPERTY));
+    }
+  }
+
+  @Test
+  public void testResetTableTtlUsesInfiniteDatabaseDefault() throws Exception {
+    final String database = "ttl_default_infinite_test";
+    for (final boolean explicitInfinite : new boolean[] {false, true}) {
+      final ClusterSchemaInfo schemaInfo = new ClusterSchemaInfo();
+      final TDatabaseSchema schema = new 
TDatabaseSchema(database).setIsTableModel(true);
+      if (explicitInfinite) {
+        schema.setTTL(Long.MAX_VALUE);
+      }
+      schemaInfo.createDatabase(
+          new DatabaseSchemaPlan(ConfigPhysicalPlanType.CreateDatabase, 
schema));
+      final TsTable table = new TsTable(TABLE);
+      table.addProp(TsTable.TTL_PROPERTY, "86400000");
+      schemaInfo.preCreateTable(new PreCreateTablePlan(database, table));
+      schemaInfo.commitCreateTable(new CommitCreateTablePlan(database, TABLE));
+      final ClusterSchemaManager manager = managerOf(schemaInfo, database);
+      final Map<String, String> originalProperties = new HashMap<>();
+      final Map<String, String> updatedProperties = new HashMap<>();
+      updatedProperties.put(TsTable.TTL_PROPERTY, null);
+
+      final Pair<TSStatus, TsTable> result =
+          manager.updateTableProperties(
+              database, TABLE, originalProperties, updatedProperties, false);
+      Assert.assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), 
result.getLeft().getCode());
+      Assert.assertNotNull(result.getRight());
+      Assert.assertEquals("86400000", 
originalProperties.get(TsTable.TTL_PROPERTY));
+      Assert.assertEquals(Long.MAX_VALUE, result.getRight().getTableTTL());
+      Assert.assertEquals("INF", updatedProperties.get(TsTable.TTL_PROPERTY));
+      Assert.assertEquals(
+          "86400000",
+          manager
+              .getTableIfExists(database, TABLE)
+              .get()
+              .getPropValue(TsTable.TTL_PROPERTY)
+              .orElse(null));
+      // The validated infinite default must not change after a concurrent 
database update.
+      schemaInfo.alterDatabase(
+          new DatabaseSchemaPlan(
+              ConfigPhysicalPlanType.AlterDatabase,
+              new 
TDatabaseSchema(database).setIsTableModel(true).setTTL(172800000L)));
+      Assert.assertEquals(
+          TSStatusCode.SUCCESS_STATUS.getStatusCode(),
+          schemaInfo
+              .setTableProperties(new SetTablePropertiesPlan(database, TABLE, 
updatedProperties))
+              .getCode());
+      Assert.assertEquals(
+          Long.MAX_VALUE, manager.getTableIfExists(database, 
TABLE).get().getTableTTL());
+      Assert.assertEquals(
+          "INF",
+          manager
+              .getTableIfExists(database, TABLE)
+              .get()
+              .getPropValue(TsTable.TTL_PROPERTY)
+              .orElse(null));
+      Assert.assertEquals(
+          manager.getTableIfExists(database, 
TABLE).get().getPropValue(TsTable.TTL_PROPERTY),
+          result.getRight().getPropValue(TsTable.TTL_PROPERTY));
+    }
+  }
+
+  @Test
+  public void testResetTableTtlWithInfiniteDefaultIsNoOp() throws Exception {
+    final String database = "ttl_default_no_op_test";
+    for (final boolean explicitInfinite : new boolean[] {false, true}) {
+      for (final String initialTtl : new String[] {null, "INF", 
String.valueOf(Long.MAX_VALUE)}) {
+        final ClusterSchemaInfo schemaInfo = new ClusterSchemaInfo();
+        final TDatabaseSchema schema = new 
TDatabaseSchema(database).setIsTableModel(true);
+        if (explicitInfinite) {
+          schema.setTTL(Long.MAX_VALUE);
+        }
+        schemaInfo.createDatabase(
+            new DatabaseSchemaPlan(ConfigPhysicalPlanType.CreateDatabase, 
schema));
+        final TsTable table = new TsTable(TABLE);
+        if (initialTtl != null) {
+          table.addProp(TsTable.TTL_PROPERTY, initialTtl);
+        }
+        schemaInfo.preCreateTable(new PreCreateTablePlan(database, table));
+        schemaInfo.commitCreateTable(new CommitCreateTablePlan(database, 
TABLE));
+        final ClusterSchemaManager manager = managerOf(schemaInfo, database);
+        final Map<String, String> originalProperties = new HashMap<>();
+        final Map<String, String> updatedProperties = new HashMap<>();
+        updatedProperties.put(TsTable.TTL_PROPERTY, null);
+
+        final Pair<TSStatus, TsTable> result =
+            manager.updateTableProperties(
+                database, TABLE, originalProperties, updatedProperties, false);
+        Assert.assertEquals(
+            TSStatusCode.SUCCESS_STATUS.getStatusCode(), 
result.getLeft().getCode());
+        Assert.assertNull(result.getRight());
+        Assert.assertTrue(updatedProperties.isEmpty());
+        Assert.assertTrue(originalProperties.isEmpty());
+        Assert.assertEquals(
+            initialTtl,
+            manager
+                .getTableIfExists(database, TABLE)
+                .get()
+                .getPropValue(TsTable.TTL_PROPERTY)
+                .orElse(null));
+      }
+    }
+  }
 }
diff --git 
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/SetTablePropertiesProcedureTest.java
 
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/SetTablePropertiesProcedureTest.java
index d91174f0ac0..3704cb3fd02 100644
--- 
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/SetTablePropertiesProcedureTest.java
+++ 
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/procedure/impl/schema/table/SetTablePropertiesProcedureTest.java
@@ -19,19 +19,97 @@
 
 package org.apache.iotdb.confignode.procedure.impl.schema.table;
 
+import org.apache.iotdb.common.rpc.thrift.TSStatus;
 import org.apache.iotdb.commons.exception.IllegalPathException;
+import org.apache.iotdb.commons.schema.table.TsTable;
+import org.apache.iotdb.confignode.consensus.request.ConfigPhysicalPlanType;
+import 
org.apache.iotdb.confignode.consensus.request.write.database.DatabaseSchemaPlan;
+import 
org.apache.iotdb.confignode.consensus.request.write.table.CommitCreateTablePlan;
+import 
org.apache.iotdb.confignode.consensus.request.write.table.PreCreateTablePlan;
+import 
org.apache.iotdb.confignode.consensus.request.write.table.SetTablePropertiesPlan;
+import org.apache.iotdb.confignode.manager.ConfigManager;
+import org.apache.iotdb.confignode.manager.consensus.ConsensusManager;
+import org.apache.iotdb.confignode.manager.partition.PartitionManager;
+import org.apache.iotdb.confignode.manager.schema.ClusterSchemaManager;
+import org.apache.iotdb.confignode.manager.schema.ClusterSchemaQuotaStatistics;
+import org.apache.iotdb.confignode.persistence.schema.ClusterSchemaInfo;
+import org.apache.iotdb.confignode.procedure.env.ConfigNodeProcedureEnv;
 import org.apache.iotdb.confignode.procedure.store.ProcedureType;
+import org.apache.iotdb.confignode.rpc.thrift.TDatabaseSchema;
+import org.apache.iotdb.rpc.TSStatusCode;
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.mockito.Mockito;
 
 import java.io.ByteArrayOutputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.HashMap;
+import java.util.Map;
+
+import static 
org.apache.iotdb.confignode.procedure.state.schema.SetTablePropertiesState.SET_PROPERTIES;
 
 public class SetTablePropertiesProcedureTest {
+  @Test
+  public void testRollbackRestoresMissingTableTtlAfterDatabaseDefaultChanges() 
throws Exception {
+    final String database = "ttl_rollback_test";
+    final String tableName = "table1";
+    final ClusterSchemaInfo schemaInfo = new ClusterSchemaInfo();
+    schemaInfo.createDatabase(
+        new DatabaseSchemaPlan(
+            ConfigPhysicalPlanType.CreateDatabase,
+            new 
TDatabaseSchema(database).setIsTableModel(true).setTTL(86400000L)));
+    schemaInfo.preCreateTable(new PreCreateTablePlan(database, new 
TsTable(tableName)));
+    schemaInfo.commitCreateTable(new CommitCreateTablePlan(database, 
tableName));
+    final ConfigManager configManager = Mockito.mock(ConfigManager.class);
+    final PartitionManager partitionManager = 
Mockito.mock(PartitionManager.class);
+    final ConsensusManager consensusManager = 
Mockito.mock(ConsensusManager.class);
+    
Mockito.when(configManager.getPartitionManager()).thenReturn(partitionManager);
+    Mockito.when(partitionManager.isDatabaseExist(database)).thenReturn(true);
+    
Mockito.when(configManager.getConsensusManager()).thenReturn(consensusManager);
+    final ClusterSchemaManager manager =
+        new ClusterSchemaManager(
+            configManager, schemaInfo, 
Mockito.mock(ClusterSchemaQuotaStatistics.class));
+    Mockito.when(configManager.getClusterSchemaManager()).thenReturn(manager);
+    final ConfigNodeProcedureEnv env = 
Mockito.mock(ConfigNodeProcedureEnv.class);
+    Mockito.when(env.getConfigManager()).thenReturn(configManager);
+    final Map<String, String> properties = new HashMap<>();
+    properties.put(TsTable.TTL_PROPERTY, null);
+    final SetTablePropertiesProcedure procedure =
+        new SetTablePropertiesProcedure(database, tableName, "0", properties, 
false);
+    procedure.validateTable(env);
+    Assert.assertFalse(procedure.isFailed());
+    Assert.assertEquals(86400000L, procedure.table.getTableTTL());
+    
Assert.assertTrue(procedure.originalProperties.containsKey(TsTable.TTL_PROPERTY));
+    Assert.assertNull(procedure.originalProperties.get(TsTable.TTL_PROPERTY));
+    Assert.assertEquals(
+        Long.MAX_VALUE, manager.getTableIfExists(database, 
tableName).get().getTableTTL());
+
+    // Recover the captured original properties, then fail the write after the 
default changes.
+    final ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+    procedure.serialize(new DataOutputStream(bytes));
+    final ByteBuffer buffer = ByteBuffer.wrap(bytes.toByteArray());
+    buffer.getShort();
+    final SetTablePropertiesProcedure recovered = new 
SetTablePropertiesProcedure(false);
+    recovered.deserialize(buffer);
+    schemaInfo.alterDatabase(
+        new DatabaseSchemaPlan(
+            ConfigPhysicalPlanType.AlterDatabase,
+            new 
TDatabaseSchema(database).setIsTableModel(true).setTTL(172800000L)));
+    
Mockito.when(consensusManager.write(Mockito.any(SetTablePropertiesPlan.class)))
+        .thenReturn(new 
TSStatus(TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode()))
+        .thenAnswer(invocation -> 
schemaInfo.setTableProperties(invocation.getArgument(0)));
+    recovered.executeFromState(env, SET_PROPERTIES);
+    Assert.assertTrue(recovered.isFailed());
+    recovered.rollbackState(env, SET_PROPERTIES);
+    Assert.assertEquals(
+        Long.MAX_VALUE, manager.getTableIfExists(database, 
tableName).get().getTableTTL());
+    Mockito.verify(consensusManager, Mockito.times(2))
+        .write(Mockito.any(SetTablePropertiesPlan.class));
+  }
+
   @Test
   public void serializeDeserializeTest() throws IllegalPathException, 
IOException {
     final SetTablePropertiesProcedure setTablePropertiesProcedure =

Reply via email to