Avoided "table not exist" related NPEs (apache#16357)

Caideyipi · web-flow · commit 2ff8310ca2e6 · 2025-09-08T17:52:24.000+08:00
* fix

* fix

* Update IoTDBDeletionTableIT.java
diff --git a/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBDeletionTableIT.java b/integration-test/src/test/java/org/apache/iotdb/relational/it/db/it/IoTDBDeletionTableIT.java
@@ -280,7 +280,7 @@ public void testUnsupportedValueFilter() throws SQLException {
         statement.execute("DELETE FROM vehicleNonExist");
         fail("should not reach here!");
       } catch (SQLException e) {
-        assertEquals("701: Table vehiclenonexist not found", e.getMessage());
+        assertEquals("550: Table 'test.vehiclenonexist' does not exist.", e.getMessage());
       }
 
       try (ResultSet set = statement.executeQuery("SELECT s0 FROM vehicle1")) {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/consensus/statemachine/dataregion/DataExecutionVisitor.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/consensus/statemachine/dataregion/DataExecutionVisitor.java
@@ -28,7 +28,7 @@
 import org.apache.iotdb.db.exception.WriteProcessRejectException;
 import org.apache.iotdb.db.exception.query.OutOfTTLException;
 import org.apache.iotdb.db.exception.runtime.TableLostRuntimeException;
-import org.apache.iotdb.db.exception.runtime.TableNotExistsRuntimeException;
+import org.apache.iotdb.db.exception.sql.SemanticException;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanVisitor;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.pipe.PipeEnrichedDeleteDataNode;
@@ -162,7 +162,7 @@ public TSStatus visitInsertRows(InsertRowsNode node, DataRegion dataRegion) {
         }
       }
       return firstStatus;
-    } catch (TableNotExistsRuntimeException | TableLostRuntimeException e) {
+    } catch (SemanticException | TableLostRuntimeException e) {
       LOGGER.error("Error in executing plan node: {}, caused by {}", node, e.getMessage());
       return RpcUtils.getStatus(e.getErrorCode(), e.getMessage());
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/exception/runtime/TableNotExistsRuntimeException.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/exception/runtime/TableNotExistsRuntimeException.java
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeUtils.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/AnalyzeUtils.java
@@ -347,9 +347,6 @@ private static void validateSchema(final Delete node, final MPPQueryContext quer
     node.setDatabaseName(databaseName);
 
     final TsTable table = DataNodeTableCache.getInstance().getTable(databaseName, tableName);
-    if (table == null) {
-      throw new SemanticException("Table " + tableName + " not found");
-    }
 
     DataNodeTreeViewSchemaUtils.checkTableInWrite(databaseName, table);
     // Maybe set by pipe transfer
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/cache/schema/DataNodeTTLCache.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/analyze/cache/schema/DataNodeTTLCache.java
@@ -86,7 +86,7 @@ public long getTTLForTree(IDeviceID deviceID) {
   }
 
   public long getTTLForTable(final String database, final String table) {
-    final TsTable tsTable = DataNodeTableCache.getInstance().getTable(database, table);
+    final TsTable tsTable = DataNodeTableCache.getInstance().getTable(database, table, false);
     return tsTable == null ? Long.MAX_VALUE : tsTable.getCachedTableTTL();
   }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/StatementAnalyzer.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/StatementAnalyzer.java
@@ -564,9 +564,6 @@ protected Scope visitDeleteDevice(final DeleteDevice node, final Optional<Scope>
           new QualifiedObjectName(node.getDatabase(), node.getTableName()));
       final TsTable table =
           DataNodeTableCache.getInstance().getTable(node.getDatabase(), node.getTableName());
-      if (Objects.isNull(table)) {
-        TableMetadataImpl.throwTableNotExistsException(node.getDatabase(), node.getTableName());
-      }
       DataNodeTreeViewSchemaUtils.checkTableInWrite(node.getDatabase(), table);
       node.parseModEntries(table);
       analyzeTraverseDevice(node, context, node.getWhere().isPresent());
@@ -4448,10 +4445,8 @@ protected Scope visitCreateOrUpdateDevice(
       queryContext.setQueryType(QueryType.WRITE);
       DataNodeSchemaLockManager.getInstance()
           .takeReadLock(queryContext, SchemaLockType.VALIDATE_VS_DELETION_TABLE);
-      if (Objects.isNull(
-          DataNodeTableCache.getInstance().getTable(node.getDatabase(), node.getTable()))) {
-        TableMetadataImpl.throwTableNotExistsException(node.getDatabase(), node.getTable());
-      }
+      // Check if the table exists
+      DataNodeTableCache.getInstance().getTable(node.getDatabase(), node.getTable());
       return null;
     }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/TableMetadataImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/TableMetadataImpl.java
@@ -101,7 +101,7 @@ public class TableMetadataImpl implements Metadata {
 
   @Override
   public boolean tableExists(final QualifiedObjectName name) {
-    return tableCache.getTable(name.getDatabaseName(), name.getObjectName()) != null;
+    return tableCache.getTable(name.getDatabaseName(), name.getObjectName(), false) != null;
   }
 
   @Override
@@ -110,7 +110,7 @@ public Optional<TableSchema> getTableSchema(
     final String databaseName = name.getDatabaseName();
     final String tableName = name.getObjectName();
 
-    final TsTable table = tableCache.getTable(databaseName, tableName);
+    final TsTable table = tableCache.getTable(databaseName, tableName, false);
     if (table == null) {
       return Optional.empty();
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/fetcher/TableDeviceSchemaFetcher.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/fetcher/TableDeviceSchemaFetcher.java
@@ -38,7 +38,6 @@
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.AlignedDeviceEntry;
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.DeviceEntry;
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.NonAlignedDeviceEntry;
-import org.apache.iotdb.db.queryengine.plan.relational.metadata.TableMetadataImpl;
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.fetcher.cache.IDeviceSchema;
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.fetcher.cache.TableDeviceSchemaCache;
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.fetcher.cache.TreeDeviceNormalSchema;
@@ -188,9 +187,6 @@ public Map<String, List<DeviceEntry>> fetchDeviceSchemaForDataQuery(
     final Map<String, List<DeviceEntry>> deviceEntryMap = new HashMap<>();
     final TsTable tableInstance = DataNodeTableCache.getInstance().getTable(database, table);
     final AtomicBoolean mayContainDuplicateDevice = new AtomicBoolean(false);
-    if (tableInstance == null) {
-      TableMetadataImpl.throwTableNotExistsException(database, table);
-    }
     if (!TreeViewSchema.isTreeViewTable(tableInstance)) {
       deviceEntryMap.put(database, new ArrayList<>());
     }
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/fetcher/TableHeaderSchemaValidator.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/fetcher/TableHeaderSchemaValidator.java
@@ -116,13 +116,13 @@ public Optional<TableSchema> validateTableHeaderSchema(
         IoTDBDescriptor.getInstance().getConfig().isAutoCreateSchemaEnabled();
     // first round validate, check existing schema
     if (table == null) {
-      // TODO table metadata: authority check for table create
       // auto create missing table
       // it's ok that many write requests concurrently auto create same table, the thread safety
       // will be guaranteed by ProcedureManager.createTable in CN
       if (allowCreateTable && isAutoCreateSchemaEnabled) {
         autoCreateTable(context, database, tableSchema);
-        table = DataNodeTableCache.getInstance().getTable(database, tableSchema.getTableName());
+        table =
+            DataNodeTableCache.getInstance().getTable(database, tableSchema.getTableName(), false);
         if (table == null) {
           throw new IllegalStateException(
               "auto create table succeed, but cannot get table schema in current node's DataNodeTableCache, may be caused by concurrently auto creating table");
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/fetcher/cache/TableDeviceSchemaCache.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/metadata/fetcher/cache/TableDeviceSchemaCache.java
@@ -150,7 +150,7 @@ public void putAttributes(
     try {
       // Avoid stale table
       if (Objects.isNull(
-          DataNodeTableCache.getInstance().getTable(database, deviceId.getTableName()))) {
+          DataNodeTableCache.getInstance().getTable(database, deviceId.getTableName(), false))) {
         return;
       }
       dualKeyCache.update(
@@ -235,7 +235,7 @@ public void initOrInvalidateLastCache(
     try {
       // Avoid stale table
       if (Objects.isNull(
-          DataNodeTableCache.getInstance().getTable(database, deviceId.getTableName()))) {
+          DataNodeTableCache.getInstance().getTable(database, deviceId.getTableName(), false))) {
         return;
       }
       dualKeyCache.update(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/parser/AstBuilder.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/parser/AstBuilder.java
@@ -262,7 +262,6 @@
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.TerminalNode;
 import org.apache.tsfile.enums.TSDataType;
-import org.apache.tsfile.exception.write.NoTableException;
 import org.apache.tsfile.utils.TimeDuration;
 import org.apache.tsfile.write.schema.MeasurementSchema;
 
@@ -779,15 +778,12 @@ public Node visitInsertStatement(final RelationalSqlParser.InsertStatementContex
         return new Insert(new Table(qualifiedName), identifiers, query);
       }
     } else {
-      if (query.getQueryBody() instanceof Values) {
-        final TsTable table = DataNodeTableCache.getInstance().getTable(databaseName, tableName);
-        if (table == null) {
-          throw new SemanticException(new NoTableException(tableName));
-        }
-        return visitInsertValues(databaseName, table, ((Values) query.getQueryBody()));
-      } else {
-        return new Insert(new Table(qualifiedName), query);
-      }
+      return query.getQueryBody() instanceof Values
+          ? visitInsertValues(
+              databaseName,
+              DataNodeTableCache.getInstance().getTable(databaseName, tableName),
+              ((Values) query.getQueryBody()))
+          : new Insert(new Table(qualifiedName), query);
     }
   }
 
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/table/DataNodeTableCache.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/schemaengine/table/DataNodeTableCache.java
@@ -26,6 +26,7 @@
 import org.apache.iotdb.confignode.rpc.thrift.TFetchTableResp;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.queryengine.plan.execution.config.executor.ClusterConfigTaskExecutor;
+import org.apache.iotdb.db.queryengine.plan.relational.metadata.TableMetadataImpl;
 import org.apache.iotdb.rpc.TSStatusCode;
 
 import org.apache.tsfile.utils.Pair;
@@ -291,21 +292,29 @@ public long getVersion() {
 
   public TsTable getTableInWrite(final String database, final String tableName) {
     final TsTable result = getTableInCache(database, tableName);
-    return Objects.nonNull(result) ? result : getTable(database, tableName);
+    return Objects.nonNull(result) ? result : getTable(database, tableName, false);
+  }
+
+  public TsTable getTable(final String database, final String tableName) {
+    return getTable(database, tableName, true);
   }
 
   /**
    * The following logic can handle the cases when configNode failed to clear some table in {@link
    * #preUpdateTableMap}, due to the failure of "commit" or rollback of "pre-update".
    */
-  public TsTable getTable(String database, final String tableName) {
+  public TsTable getTable(String database, final String tableName, final boolean force) {
     database = PathUtils.unQualifyDatabaseName(database);
     final Map<String, Map<String, Long>> preUpdateTables =
         mayGetTableInPreUpdateMap(database, tableName);
     if (Objects.nonNull(preUpdateTables) && !preUpdateTables.isEmpty()) {
       updateTable(getTablesInConfigNode(preUpdateTables), preUpdateTables);
     }
-    return getTableInCache(database, tableName);
+    final TsTable table = getTableInCache(database, tableName);
+    if (Objects.isNull(table) && force) {
+      TableMetadataImpl.throwTableNotExistsException(database, tableName);
+    }
+    return table;
   }
 
   private Map<String, Map<String, Long>> mayGetTableInPreUpdateMap(
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/dataregion/DataRegion.java
@@ -59,7 +59,6 @@
 import org.apache.iotdb.db.exception.query.QueryProcessException;
 import org.apache.iotdb.db.exception.quota.ExceedQuotaException;
 import org.apache.iotdb.db.exception.runtime.TableLostRuntimeException;
-import org.apache.iotdb.db.exception.runtime.TableNotExistsRuntimeException;
 import org.apache.iotdb.db.pipe.consensus.deletion.DeletionResource;
 import org.apache.iotdb.db.pipe.consensus.deletion.DeletionResource.Status;
 import org.apache.iotdb.db.pipe.consensus.deletion.DeletionResourceManager;
@@ -82,6 +81,7 @@
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.write.InsertRowsOfOneDeviceNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.write.InsertTabletNode;
 import org.apache.iotdb.db.queryengine.plan.planner.plan.node.write.RelationalDeleteDataNode;
+import org.apache.iotdb.db.queryengine.plan.relational.metadata.TableMetadataImpl;
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.TableSchema;
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.fetcher.cache.LastCacheLoadStrategy;
 import org.apache.iotdb.db.queryengine.plan.relational.metadata.fetcher.cache.TableDeviceSchemaCache;
@@ -1414,7 +1414,8 @@ private void registerToTsFile(InsertNode node, TsFileProcessor tsFileProcessor)
       tsFileProcessor.registerToTsFile(
           tableName,
           t -> {
-            TsTable tsTable = DataNodeTableCache.getInstance().getTable(getDatabaseName(), t);
+            TsTable tsTable =
+                DataNodeTableCache.getInstance().getTable(getDatabaseName(), t, false);
             if (tsTable == null) {
               // There is a high probability that the leader node has been executed and is currently
               // located in the follower node.
@@ -1436,7 +1437,7 @@ private void registerToTsFile(InsertNode node, TsFileProcessor tsFileProcessor)
                       e.getMessage());
                 }
                 if (tsTable == null) {
-                  throw new TableNotExistsRuntimeException(getDatabaseName(), tableName);
+                  TableMetadataImpl.throwTableNotExistsException(getDatabaseName(), tableName);
                 }
               } else {
                 // Here may be invoked by leader node, the table is very unexpected not exist in the
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/LoadTsFileManager.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/storageengine/load/LoadTsFileManager.java
@@ -488,7 +488,7 @@ private void write(DataPartitionInfo partitionInfo, ChunkData chunkData)
         // If the table does not exist, it means that the table is all deleted by mods
         final TsTable table =
             DataNodeTableCache.getInstance()
-                .getTable(partitionInfo.getDataRegion().getDatabaseName(), tableName);
+                .getTable(partitionInfo.getDataRegion().getDatabaseName(), tableName, false);
         if (Objects.nonNull(table)) {
           writer
               .getSchema()

Original file line number	Diff line number	Diff line change
`@@ -280,7 +280,7 @@ public void testUnsupportedValueFilter() throws SQLException {`
`280`	`280`	`statement.execute("DELETE FROM vehicleNonExist");`
`281`	`281`	`fail("should not reach here!");`
`282`	`282`	`} catch (SQLException e) {`
`283`		`- assertEquals("701: Table vehiclenonexist not found", e.getMessage());`
	`283`	`+ assertEquals("550: Table 'test.vehiclenonexist' does not exist.", e.getMessage());`
`284`	`284`	`}`
`285`	`285`
`286`	`286`	`try (ResultSet set = statement.executeQuery("SELECT s0 FROM vehicle1")) {`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@`
`28`	`28`	`import org.apache.iotdb.db.exception.WriteProcessRejectException;`
`29`	`29`	`import org.apache.iotdb.db.exception.query.OutOfTTLException;`
`30`	`30`	`import org.apache.iotdb.db.exception.runtime.TableLostRuntimeException;`
`31`		`-import org.apache.iotdb.db.exception.runtime.TableNotExistsRuntimeException;`
	`31`	`+import org.apache.iotdb.db.exception.sql.SemanticException;`
`32`	`32`	`import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanNode;`
`33`	`33`	`import org.apache.iotdb.db.queryengine.plan.planner.plan.node.PlanVisitor;`
`34`	`34`	`import org.apache.iotdb.db.queryengine.plan.planner.plan.node.pipe.PipeEnrichedDeleteDataNode;`
`@@ -162,7 +162,7 @@ public TSStatus visitInsertRows(InsertRowsNode node, DataRegion dataRegion) {`
`162`	`162`	`}`
`163`	`163`	`}`
`164`	`164`	`return firstStatus;`
`165`		`- } catch (TableNotExistsRuntimeException \| TableLostRuntimeException e) {`
	`165`	`+ } catch (SemanticException \| TableLostRuntimeException e) {`
`166`	`166`	`LOGGER.error("Error in executing plan node: {}, caused by {}", node, e.getMessage());`
`167`	`167`	`return RpcUtils.getStatus(e.getErrorCode(), e.getMessage());`
`168`	`168`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ public long getTTLForTree(IDeviceID deviceID) {`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`public long getTTLForTable(final String database, final String table) {`
`89`		`- final TsTable tsTable = DataNodeTableCache.getInstance().getTable(database, table);`
	`89`	`+ final TsTable tsTable = DataNodeTableCache.getInstance().getTable(database, table, false);`
`90`	`90`	`return tsTable == null ? Long.MAX_VALUE : tsTable.getCachedTableTTL();`
`91`	`91`	`}`
`92`	`92`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ public class TableMetadataImpl implements Metadata {`
`101`	`101`
`102`	`102`	`@Override`
`103`	`103`	`public boolean tableExists(final QualifiedObjectName name) {`
`104`		`- return tableCache.getTable(name.getDatabaseName(), name.getObjectName()) != null;`
	`104`	`+ return tableCache.getTable(name.getDatabaseName(), name.getObjectName(), false) != null;`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`@Override`
`@@ -110,7 +110,7 @@ public Optional<TableSchema> getTableSchema(`
`110`	`110`	`final String databaseName = name.getDatabaseName();`
`111`	`111`	`final String tableName = name.getObjectName();`
`112`	`112`
`113`		`- final TsTable table = tableCache.getTable(databaseName, tableName);`
	`113`	`+ final TsTable table = tableCache.getTable(databaseName, tableName, false);`
`114`	`114`	`if (table == null) {`
`115`	`115`	`return Optional.empty();`
`116`	`116`	`}`