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

Caideyipi pushed a commit to branch fix/table-ttl-default-propagation
in repository https://gitbox.apache.org/repos/asf/iotdb.git

commit db29ce595388b6c3c1bc2780ed16717a56524234
Author: Caideyipi <[email protected]>
AuthorDate: Tue Nov 3 15:56:12 2026 +0800

    Fix table TTL reset propagation to DataNodes
---
 .../iotdb/relational/it/schema/IoTDBTableIT.java   |  89 ++++++++++++++++++
 .../manager/schema/ClusterSchemaManager.java       |  13 +++
 .../manager/ClusterSchemaManagerTest.java          | 101 +++++++++++++++++++++
 3 files changed, 203 insertions(+)

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..877955ca115 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
@@ -1994,6 +1994,19 @@ 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);
+        if (schema.isSetTTL() && schema.getTTL() != Long.MAX_VALUE) {
+          updatedProperties.put(TsTable.TTL_PROPERTY, 
String.valueOf(schema.getTTL()));
+        }
+      } catch (final DatabaseNotExistsException e) {
+        throw new MetadataException(e);
+      }
+    }
+
     updatedProperties
         .keySet()
         .removeIf(
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..532dbdfa4b0 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,104 @@ 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;
+    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).setTTL(day)));
+      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());
+      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));
+      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 {
+    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.assertFalse(result.getRight().getPropValue(TsTable.TTL_PROPERTY).isPresent());
+      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));
+    }
+  }
 }

Reply via email to