You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ji...@apache.org on 2024/12/04 07:51:35 UTC
(iotdb) branch insert_without_column_name created (now fd30833a98f)
This is an automated email from the ASF dual-hosted git repository.
jiangtian pushed a change to branch insert_without_column_name
in repository https://gitbox.apache.org/repos/asf/iotdb.git
at fd30833a98f Support table model sql insertion without column name
This branch includes the following new commits:
new fd30833a98f Support table model sql insertion without column name
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
(iotdb) 01/01: Support table model sql insertion without column name
Posted by ji...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
jiangtian pushed a commit to branch insert_without_column_name
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit fd30833a98f557e77733fa2938b2255935c84fb9
Author: Tian Jiang <jt...@163.com>
AuthorDate: Wed Dec 4 15:53:50 2024 +0800
Support table model sql insertion without column name
---
.../iotdb/session/it/IoTDBSessionRelationalIT.java | 62 ++++++++-
.../protocol/thrift/impl/ClientRPCServiceImpl.java | 5 +-
.../relational/analyzer/StatementAnalyzer.java | 3 +-
.../plan/relational/sql/parser/AstBuilder.java | 146 +++++++++++++++++++--
.../plan/relational/sql/parser/SqlParser.java | 28 ++--
.../plan/statement/crud/InsertRowStatement.java | 3 +-
.../plan/relational/analyzer/AnalyzerTest.java | 2 +-
.../plan/relational/analyzer/TestUtils.java | 2 +-
.../plan/relational/planner/PlanTester.java | 6 +-
9 files changed, 225 insertions(+), 32 deletions(-)
diff --git a/integration-test/src/test/java/org/apache/iotdb/session/it/IoTDBSessionRelationalIT.java b/integration-test/src/test/java/org/apache/iotdb/session/it/IoTDBSessionRelationalIT.java
index d3e4cc4a23e..438c5844ca5 100644
--- a/integration-test/src/test/java/org/apache/iotdb/session/it/IoTDBSessionRelationalIT.java
+++ b/integration-test/src/test/java/org/apache/iotdb/session/it/IoTDBSessionRelationalIT.java
@@ -237,6 +237,22 @@ public class IoTDBSessionRelationalIT {
row, "id:" + row, "attr:" + row, row * 1.0));
}
+ // without specifying column name
+ for (long row = 30; row < 40; row++) {
+ session.executeNonQueryStatement(
+ String.format(
+ "INSERT INTO table1 VALUES (%d, '%s', '%s', %f)",
+ row, "id:" + row, "attr:" + row, row * 1.0));
+ }
+
+ // auto data type conversion
+ for (long row = 40; row < 50; row++) {
+ session.executeNonQueryStatement(
+ String.format(
+ "INSERT INTO table1 VALUES (%d, '%s', '%s', %d)",
+ row, "id:" + row, "attr:" + row, row));
+ }
+
SessionDataSet dataSet = session.executeQueryStatement("select * from table1 order by time");
int cnt = 0;
while (dataSet.hasNext()) {
@@ -247,7 +263,7 @@ public class IoTDBSessionRelationalIT {
assertEquals(timestamp * 1.0, rowRecord.getFields().get(3).getDoubleV(), 0.0001);
cnt++;
}
- assertEquals(30, cnt);
+ assertEquals(50, cnt);
// sql cannot create column
assertThrows(
@@ -257,6 +273,50 @@ public class IoTDBSessionRelationalIT {
String.format(
"INSERT INTO table1 (id1, id2, attr1, m1) VALUES ('%s', '%s', '%s', %f)",
"id:" + 100, "id:" + 100, "attr:" + 100, 100 * 1.0)));
+
+ // fewer columns than defined
+ assertThrows(
+ StatementExecutionException.class,
+ () ->
+ session.executeNonQueryStatement(
+ String.format(
+ "INSERT INTO table1 VALUES ( '%s', %f)", "attr:" + 100, 100 * 1.0)));
+
+ // more columns than defined
+ assertThrows(
+ StatementExecutionException.class,
+ () ->
+ session.executeNonQueryStatement(
+ String.format(
+ "INSERT INTO table1 VALUES ('%s', '%s', '%s', '%s', %f)",
+ "id:" + 100, "id:" + 100, "id:" + 100, "attr:" + 100, 100 * 1.0)));
+
+ // invalid conversion - id column
+ assertThrows(
+ StatementExecutionException.class,
+ () ->
+ session.executeNonQueryStatement(
+ String.format(
+ "INSERT INTO table1 VALUES ('%d', '%s', '%s', %f)",
+ 100, 100, "attr:" + 100, 100 * 1.0)));
+
+ // invalid conversion - attr column
+ assertThrows(
+ StatementExecutionException.class,
+ () ->
+ session.executeNonQueryStatement(
+ String.format(
+ "INSERT INTO table1 VALUES ('%d', '%s', '%s', %f)",
+ 100, "id:" + 100, 100, 100 * 1.0)));
+
+ // invalid conversion - measurement column
+ assertThrows(
+ StatementExecutionException.class,
+ () ->
+ session.executeNonQueryStatement(
+ String.format(
+ "INSERT INTO table1 VALUES ('%d', '%s', '%s', %s)",
+ 100, "id:" + 100, "attr:" + 100, "measurement" + (100 * 1.0))));
}
}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java
index 0bb353bb2c6..d038c07cbe7 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/protocol/thrift/impl/ClientRPCServiceImpl.java
@@ -343,7 +343,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
req.getTimeout());
} else {
org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Statement s =
- relationSqlParser.createStatement(statement, clientSession.getZoneId());
+ relationSqlParser.createStatement(statement, clientSession.getZoneId(), clientSession);
if (s instanceof Use) {
useDatabase = true;
@@ -1672,7 +1672,8 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
} else {
org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Statement s =
- relationSqlParser.createStatement(statement, clientSession.getZoneId());
+ relationSqlParser.createStatement(
+ statement, clientSession.getZoneId(), clientSession);
if (s instanceof Use) {
useDatabase = true;
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
index fdf9c032742..50893b184cd 100644
--- 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
@@ -496,7 +496,8 @@ public class StatementAnalyzer {
@Override
protected Scope visitInsert(Insert insert, Optional<Scope> scope) {
- throw new SemanticException("Insert statement is not supported yet.");
+ throw new SemanticException(
+ "This kind of insert statement is not supported yet, please check your grammar.");
}
@Override
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
index 2408ff12907..95023a6a317 100644
--- 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
@@ -23,10 +23,14 @@ import org.apache.iotdb.common.rpc.thrift.TConsensusGroupType;
import org.apache.iotdb.commons.exception.IllegalPathException;
import org.apache.iotdb.commons.path.PartialPath;
import org.apache.iotdb.commons.schema.cache.CacheClearOptions;
+import org.apache.iotdb.commons.schema.table.TsTable;
import org.apache.iotdb.commons.schema.table.column.TsTableColumnCategory;
+import org.apache.iotdb.commons.schema.table.column.TsTableColumnSchema;
import org.apache.iotdb.commons.utils.CommonDateTimeUtils;
import org.apache.iotdb.commons.utils.PathUtils;
+import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.exception.sql.SemanticException;
+import org.apache.iotdb.db.protocol.session.IClientSession;
import org.apache.iotdb.db.queryengine.plan.expression.leaf.TimestampOperand;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.AddColumn;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.AliasedRelation;
@@ -83,7 +87,6 @@ import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Identifier;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.IfExpression;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.InListExpression;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.InPredicate;
-import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Insert;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.InsertRows;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Intersect;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.IsNotNullPredicate;
@@ -175,6 +178,7 @@ import org.apache.iotdb.db.queryengine.transformation.dag.column.unary.scalar.Ta
import org.apache.iotdb.db.relational.grammar.sql.RelationalSqlBaseVisitor;
import org.apache.iotdb.db.relational.grammar.sql.RelationalSqlLexer;
import org.apache.iotdb.db.relational.grammar.sql.RelationalSqlParser;
+import org.apache.iotdb.db.schemaengine.table.DataNodeTableCache;
import org.apache.iotdb.db.storageengine.load.config.LoadTsFileConfigurator;
import org.apache.iotdb.db.utils.DateTimeUtils;
import org.apache.iotdb.db.utils.TimestampPrecisionUtils;
@@ -184,7 +188,10 @@ import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.Token;
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;
import javax.annotation.Nullable;
@@ -234,9 +241,12 @@ public class AstBuilder extends RelationalSqlBaseVisitor<Node> {
private final ZoneId zoneId;
- AstBuilder(@Nullable NodeLocation baseLocation, ZoneId zoneId) {
+ private final IClientSession clientSession;
+
+ AstBuilder(@Nullable NodeLocation baseLocation, ZoneId zoneId, IClientSession clientSession) {
this.baseLocation = baseLocation;
this.zoneId = zoneId;
+ this.clientSession = clientSession;
}
@Override
@@ -436,24 +446,67 @@ public class AstBuilder extends RelationalSqlBaseVisitor<Node> {
@Override
public Node visitInsertStatement(RelationalSqlParser.InsertStatementContext ctx) {
+ QualifiedName qualifiedName = getQualifiedName(ctx.tableName);
+ String tableName = qualifiedName.getSuffix();
+ String databaseName =
+ qualifiedName
+ .getPrefix()
+ .map(QualifiedName::toString)
+ .orElse(clientSession.getDatabaseName());
+ if (databaseName == null) {
+ throw new SemanticException("Database not specified");
+ }
+ tableName = tableName.toLowerCase();
+ databaseName = databaseName.toLowerCase();
+
+ Query query = (Query) visit(ctx.query());
if (ctx.columnAliases() != null) {
- Query query = (Query) visit(ctx.query());
List<Identifier> identifiers = visit(ctx.columnAliases().identifier(), Identifier.class);
if (query.getQueryBody() instanceof Values) {
return visitInsertValues(
- getQualifiedName(ctx.tableName), identifiers, ((Values) query.getQueryBody()));
+ databaseName, tableName, identifiers, ((Values) query.getQueryBody()));
+ } else {
+ throw new SemanticException("Only support insert by values.");
}
- return new Insert(new Table(getQualifiedName(ctx.tableName)), identifiers, query);
} else {
- return new Insert(new Table(getQualifiedName(ctx.tableName)), (Query) visit(ctx.query()));
+ if (query.getQueryBody() instanceof Values) {
+ TsTable table = DataNodeTableCache.getInstance().getTable(databaseName, tableName);
+ if (table == null) {
+ throw new SemanticException(new NoTableException(tableName));
+ }
+ return visitInsertValues(databaseName, table, ((Values) query.getQueryBody()));
+ } else {
+ throw new SemanticException("Only support insert by values.");
+ }
}
}
- private Node visitInsertValues(
- QualifiedName qualifiedTableName, List<Identifier> identifiers, Values queryBody) {
- Optional<String> databaseName = qualifiedTableName.getPrefix().map(QualifiedName::toString);
- String tableName = qualifiedTableName.getSuffix();
+ private Node visitInsertValues(String databaseName, TsTable table, Values queryBody) {
+ List<Expression> rows = queryBody.getRows();
+ List<InsertRowStatement> rowStatements =
+ rows.stream()
+ .map(
+ r -> {
+ List<Expression> expressions;
+ if (r instanceof Row) {
+ expressions = ((Row) r).getItems();
+ } else if (r instanceof Literal) {
+ expressions = Collections.singletonList(r);
+ } else {
+ throw new SemanticException("unexpected expression: " + r);
+ }
+ return toInsertRowStatement(expressions, table, databaseName);
+ })
+ .collect(toList());
+
+ InsertRowsStatement insertRowsStatement = new InsertRowsStatement();
+ insertRowsStatement.setInsertRowStatementList(rowStatements);
+ insertRowsStatement.setWriteToTable(true);
+ return new InsertRows(insertRowsStatement, null);
+ }
+ private Node visitInsertValues(
+ String databaseName, String tableName, List<Identifier> identifiers, Values queryBody) {
List<String> columnNames = identifiers.stream().map(Identifier::getValue).collect(toList());
int timeColumnIndex = -1;
for (int i = 0; i < columnNames.size(); i++) {
@@ -468,6 +521,7 @@ public class AstBuilder extends RelationalSqlBaseVisitor<Node> {
if (timeColumnIndex != -1) {
columnNames.remove(timeColumnIndex);
}
+
String[] columnNameArray = columnNames.toArray(new String[0]);
List<Expression> rows = queryBody.getRows();
@@ -498,12 +552,79 @@ public class AstBuilder extends RelationalSqlBaseVisitor<Node> {
return new InsertRows(insertRowsStatement, null);
}
+ private InsertRowStatement toInsertRowStatement(
+ List<Expression> expressions, TsTable table, String databaseName) {
+ InsertRowStatement insertRowStatement = new InsertRowStatement();
+ insertRowStatement.setWriteToTable(true);
+ insertRowStatement.setDevicePath(new PartialPath(new String[] {table.getTableName()}));
+
+ List<TsTableColumnSchema> columnList = table.getColumnList();
+ if (expressions.size() != columnList.size()) {
+ throw new SemanticException(
+ "expressions and columns do not match, expressions size: "
+ + expressions.size()
+ + ", columns size: "
+ + columnList.size());
+ }
+
+ String[] nonTimeColumnNames = new String[columnList.size() - 1];
+ Object[] nonTimeValues = new Object[columnList.size() - 1];
+ TsTableColumnCategory[] nonTimeColumnCategories =
+ new TsTableColumnCategory[columnList.size() - 1];
+ MeasurementSchema[] columnSchemas = new MeasurementSchema[columnList.size() - 1];
+ TSDataType[] dataTypes = new TSDataType[columnList.size() - 1];
+ int nonTimeColumnIndex = 0;
+ long timestamp = -1;
+ for (int i = 0; i < columnList.size(); i++) {
+ TsTableColumnSchema columnSchema = columnList.get(i);
+ Expression expression = expressions.get(i);
+
+ if (columnSchema.getColumnCategory().equals(TIME)) {
+ if (expression instanceof LongLiteral) {
+ timestamp = ((LongLiteral) expression).getParsedValue();
+ } else {
+ timestamp =
+ parseDateTimeFormat(
+ ((StringLiteral) expression).getValue(),
+ CommonDateTimeUtils.currentTime(),
+ zoneId);
+ }
+ } else {
+ Object value = AstUtil.expressionToTsValue(expression);
+ nonTimeValues[nonTimeColumnIndex] = value;
+ nonTimeColumnNames[nonTimeColumnIndex] = columnSchema.getColumnName();
+ dataTypes[nonTimeColumnIndex] = columnSchema.getDataType();
+ nonTimeColumnCategories[nonTimeColumnIndex] = columnSchema.getColumnCategory();
+ columnSchemas[nonTimeColumnIndex] =
+ new MeasurementSchema(columnSchema.getColumnName(), columnSchema.getDataType());
+ nonTimeColumnIndex++;
+ }
+ }
+
+ TimestampPrecisionUtils.checkTimestampPrecision(timestamp);
+ insertRowStatement.setTime(timestamp);
+ insertRowStatement.setMeasurements(nonTimeColumnNames);
+ insertRowStatement.setDataTypes(dataTypes);
+ insertRowStatement.setMeasurementSchemas(columnSchemas);
+ insertRowStatement.setValues(nonTimeValues);
+ insertRowStatement.setColumnCategories(nonTimeColumnCategories);
+ insertRowStatement.setNeedInferType(false);
+ insertRowStatement.setDatabaseName(databaseName);
+
+ try {
+ insertRowStatement.transferType(zoneId);
+ } catch (QueryProcessException e) {
+ throw new SemanticException(e);
+ }
+ return insertRowStatement;
+ }
+
private InsertRowStatement toInsertRowStatement(
List<Expression> expressions,
int timeColumnIndex,
String[] nonTimeColumnNames,
String tableName,
- Optional<String> databaseName) {
+ String databaseName) {
InsertRowStatement insertRowStatement = new InsertRowStatement();
insertRowStatement.setWriteToTable(true);
insertRowStatement.setDevicePath(new PartialPath(new String[] {tableName}));
@@ -547,8 +668,7 @@ public class AstBuilder extends RelationalSqlBaseVisitor<Node> {
insertRowStatement.setValues(values);
insertRowStatement.setNeedInferType(true);
- databaseName.ifPresent(
- databaseName1 -> insertRowStatement.setDatabaseName(databaseName1.toLowerCase()));
+ insertRowStatement.setDatabaseName(databaseName);
return insertRowStatement;
}
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/parser/SqlParser.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/parser/SqlParser.java
index 1ee59aea651..377c88dfdb7 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/parser/SqlParser.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/relational/sql/parser/SqlParser.java
@@ -20,6 +20,7 @@
package org.apache.iotdb.db.queryengine.plan.relational.sql.parser;
import org.apache.iotdb.commons.service.metric.PerformanceOverviewMetrics;
+import org.apache.iotdb.db.protocol.session.IClientSession;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.DataType;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Expression;
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Node;
@@ -99,35 +100,41 @@ public class SqlParser {
this.initializer = requireNonNull(initializer, "initializer is null");
}
- public Statement createStatement(String sql, ZoneId zoneId) {
- return (Statement) invokeParser("statement", sql, RelationalSqlParser::singleStatement, zoneId);
+ public Statement createStatement(String sql, ZoneId zoneId, IClientSession clientSession) {
+ return (Statement)
+ invokeParser("statement", sql, RelationalSqlParser::singleStatement, zoneId, clientSession);
}
- public Statement createStatement(String sql, NodeLocation location, ZoneId zoneId) {
+ public Statement createStatement(
+ String sql, NodeLocation location, ZoneId zoneId, IClientSession clientSession) {
return (Statement)
invokeParser(
"statement",
sql,
Optional.ofNullable(location),
RelationalSqlParser::singleStatement,
- zoneId);
+ zoneId,
+ clientSession);
}
public Expression createExpression(String expression, ZoneId zoneId) {
return (Expression)
- invokeParser("expression", expression, RelationalSqlParser::standaloneExpression, zoneId);
+ invokeParser(
+ "expression", expression, RelationalSqlParser::standaloneExpression, zoneId, null);
}
public DataType createType(String expression, ZoneId zoneId) {
- return (DataType) invokeParser("type", expression, RelationalSqlParser::standaloneType, zoneId);
+ return (DataType)
+ invokeParser("type", expression, RelationalSqlParser::standaloneType, zoneId, null);
}
private Node invokeParser(
String name,
String sql,
Function<RelationalSqlParser, ParserRuleContext> parseFunction,
- ZoneId zoneId) {
- return invokeParser(name, sql, Optional.empty(), parseFunction, zoneId);
+ ZoneId zoneId,
+ IClientSession clientSession) {
+ return invokeParser(name, sql, Optional.empty(), parseFunction, zoneId, clientSession);
}
private Node invokeParser(
@@ -135,7 +142,8 @@ public class SqlParser {
String sql,
Optional<NodeLocation> location,
Function<RelationalSqlParser, ParserRuleContext> parseFunction,
- ZoneId zoneId) {
+ ZoneId zoneId,
+ IClientSession clientSession) {
long startTime = System.nanoTime();
try {
RelationalSqlLexer lexer =
@@ -193,7 +201,7 @@ public class SqlParser {
throw e;
}
- return new AstBuilder(location.orElse(null), zoneId).visit(tree);
+ return new AstBuilder(location.orElse(null), zoneId, clientSession).visit(tree);
} catch (StackOverflowError e) {
throw new ParsingException(name + " is too large (stack overflow while parsing)");
} finally {
diff --git a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertRowStatement.java b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertRowStatement.java
index 45a381293a3..47905b362fa 100644
--- a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertRowStatement.java
+++ b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/queryengine/plan/statement/crud/InsertRowStatement.java
@@ -226,8 +226,7 @@ public class InsertRowStatement extends InsertBaseStatement implements ISchemaVa
dataTypes[i] = measurementSchemas[i].getType();
try {
// if the type is binary and the value is already binary, do not convert
- if (values[i] instanceof String
- || values[i] != null && !(dataTypes[i].isBinary() && values[i] instanceof Binary)) {
+ if (values[i] != null && !(dataTypes[i].isBinary() && values[i] instanceof Binary)) {
values[i] = CommonUtils.parseValue(dataTypes[i], values[i].toString(), zoneId);
}
} catch (Exception e) {
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/AnalyzerTest.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/AnalyzerTest.java
index 2463e552c9b..780add1a7f9 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/AnalyzerTest.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/AnalyzerTest.java
@@ -1214,7 +1214,7 @@ public class AnalyzerTest {
public static Analysis analyzeSQL(String sql, Metadata metadata, final MPPQueryContext context) {
SqlParser sqlParser = new SqlParser();
- Statement statement = sqlParser.createStatement(sql, ZoneId.systemDefault());
+ Statement statement = sqlParser.createStatement(sql, ZoneId.systemDefault(), null);
SessionInfo session =
new SessionInfo(
0, "test", ZoneId.systemDefault(), "testdb", IClientSession.SqlDialect.TABLE);
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/TestUtils.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/TestUtils.java
index 84bb5ba1a6e..e0628feff9a 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/TestUtils.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/analyzer/TestUtils.java
@@ -143,7 +143,7 @@ public class TestUtils {
public static void assertAnalyzeSemanticException(String sql, String message) {
try {
SqlParser sqlParser = new SqlParser();
- Statement statement = sqlParser.createStatement(sql, ZoneId.systemDefault());
+ Statement statement = sqlParser.createStatement(sql, ZoneId.systemDefault(), null);
SessionInfo session =
new SessionInfo(
0, "test", ZoneId.systemDefault(), "testdb", IClientSession.SqlDialect.TABLE);
diff --git a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/planner/PlanTester.java b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/planner/PlanTester.java
index 199942012d2..e8862d61a19 100644
--- a/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/planner/PlanTester.java
+++ b/iotdb-core/datanode/src/test/java/org/apache/iotdb/db/queryengine/plan/relational/planner/PlanTester.java
@@ -41,6 +41,8 @@ import org.apache.iotdb.db.queryengine.plan.relational.security.AllowAllAccessCo
import org.apache.iotdb.db.queryengine.plan.relational.sql.ast.Statement;
import org.apache.iotdb.db.queryengine.plan.relational.sql.parser.SqlParser;
+import org.mockito.Mockito;
+
import java.time.ZoneId;
import java.util.Collections;
import java.util.List;
@@ -126,13 +128,15 @@ public class PlanTester {
public static Analysis analyze(String sql, Metadata metadata) {
SqlParser sqlParser = new SqlParser();
- Statement statement = sqlParser.createStatement(sql, ZoneId.systemDefault());
String databaseName;
if (metadata instanceof TSBSMetadata) {
databaseName = "tsbs";
} else {
databaseName = "testdb";
}
+ IClientSession clientSession = Mockito.mock(IClientSession.class);
+ Mockito.when(clientSession.getDatabaseName()).thenReturn(databaseName);
+ Statement statement = sqlParser.createStatement(sql, ZoneId.systemDefault(), clientSession);
SessionInfo session =
new SessionInfo(
0, "test", ZoneId.systemDefault(), databaseName, IClientSession.SqlDialect.TABLE);