You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ge...@apache.org on 2020/11/11 10:03:39 UTC
[iotdb] branch change_listener_to_visitor created (now af05fc1)
This is an automated email from the ASF dual-hosted git repository.
geniuspig pushed a change to branch change_listener_to_visitor
in repository https://gitbox.apache.org/repos/asf/iotdb.git.
at af05fc1 change listener to visitor
This branch includes the following new commits:
new af05fc1 change listener to visitor
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: change listener to visitor
Posted by ge...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
geniuspig pushed a commit to branch change_listener_to_visitor
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit af05fc19ef9d690c65a11dbfed0dc453b8aca738
Author: Boris <96...@qq.com>
AuthorDate: Wed Nov 11 17:55:20 2020 +0800
change listener to visitor
---
antlr/pom.xml | 4 +
.../iotdb/db/qp/{strategy => sql}/SqlBase.g4 | 0
.../apache/iotdb/db/qp/constant/SQLConstant.java | 2 +-
.../IoTDBSqlVisitor.java} | 1926 ++++++++------------
.../apache/iotdb/db/qp/strategy/ParseDriver.java | 19 +-
...gicalGeneratorError.java => SQLParseError.java} | 4 +-
.../sql/DatetimeQueryDataSetUtilsTest.java | 2 +-
.../iotdb/db/qp/strategy/LogicalGeneratorTest.java | 26 +-
8 files changed, 826 insertions(+), 1157 deletions(-)
diff --git a/antlr/pom.xml b/antlr/pom.xml
index 3d9da5f..955bd75 100644
--- a/antlr/pom.xml
+++ b/antlr/pom.xml
@@ -44,6 +44,10 @@
<version>${antlr4.version}</version>
<executions>
<execution>
+ <configuration>
+ <listener>false</listener>
+ <visitor>true</visitor>
+ </configuration>
<goals>
<goal>antlr4</goal>
</goals>
diff --git a/antlr/src/main/antlr4/org/apache/iotdb/db/qp/strategy/SqlBase.g4 b/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4
similarity index 100%
rename from antlr/src/main/antlr4/org/apache/iotdb/db/qp/strategy/SqlBase.g4
rename to antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/constant/SQLConstant.java b/server/src/main/java/org/apache/iotdb/db/qp/constant/SQLConstant.java
index 8976733..04b9520 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/constant/SQLConstant.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/constant/SQLConstant.java
@@ -21,7 +21,7 @@ package org.apache.iotdb.db.qp.constant;
import java.util.HashMap;
import java.util.Map;
import org.apache.iotdb.db.metadata.PartialPath;
-import org.apache.iotdb.db.qp.strategy.SqlBaseLexer;
+import org.apache.iotdb.db.qp.sql.SqlBaseLexer;
/**
* this class contains several constants used in SQL.
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/strategy/LogicalGenerator.java b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
similarity index 56%
rename from server/src/main/java/org/apache/iotdb/db/qp/strategy/LogicalGenerator.java
rename to server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
index 2826b3b..f315e50 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/strategy/LogicalGenerator.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
@@ -1,22 +1,4 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.iotdb.db.qp.strategy;
+package org.apache.iotdb.db.qp.sql;
import static org.apache.iotdb.db.qp.constant.SQLConstant.TIME_PATH;
@@ -36,7 +18,7 @@ import org.apache.iotdb.db.exception.runtime.SQLParserException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.constant.DatetimeUtils;
import org.apache.iotdb.db.qp.constant.SQLConstant;
-import org.apache.iotdb.db.qp.logical.RootOperator;
+import org.apache.iotdb.db.qp.logical.Operator;
import org.apache.iotdb.db.qp.logical.crud.BasicFunctionOperator;
import org.apache.iotdb.db.qp.logical.crud.DeleteDataOperator;
import org.apache.iotdb.db.qp.logical.crud.FilterOperator;
@@ -76,105 +58,97 @@ import org.apache.iotdb.db.qp.logical.sys.ShowStorageGroupOperator;
import org.apache.iotdb.db.qp.logical.sys.ShowTTLOperator;
import org.apache.iotdb.db.qp.logical.sys.ShowTimeSeriesOperator;
import org.apache.iotdb.db.qp.logical.sys.TracingOperator;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.AliasContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.AlignByDeviceClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.AlterUserContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.AndExpressionContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.AsClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.AsElementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.AttributeClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.AttributeClausesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ConstantContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.CountDevicesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.CountNodesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.CountStorageGroupContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.CountTimeseriesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.CreateRoleContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.CreateSnapshotContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.CreateTimeseriesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.CreateUserContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.DateExpressionContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.DeletePartitionContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.DeleteStatementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.DeleteStorageGroupContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.DeleteTimeseriesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.DropRoleContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.DropUserContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.FillClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.FlushContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.FromClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.FullMergeContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.FullPathContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.FunctionAsClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.FunctionAsElementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.FunctionCallContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.FunctionElementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.GrantRoleContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.GrantRoleToUserContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.GrantUserContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.GrantWatermarkEmbeddingContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.GroupByTimeClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.InClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.InsertColumnSpecContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.InsertStatementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.InsertValuesSpecContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.LastClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.LimitClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ListAllRoleOfUserContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ListAllUserOfRoleContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ListPrivilegesRoleContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ListPrivilegesUserContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ListRoleContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ListRolePrivilegesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ListUserContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ListUserPrivilegesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.LoadConfigurationStatementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.LoadFilesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.LoadStatementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.MergeContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.MoveFileContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.NodeNameContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.NodeNameWithoutStarContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.OffsetClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.OrExpressionContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.OrderByTimeClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.PredicateContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.PrefixPathContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.PrivilegesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.PropertyContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.PropertyValueContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.RemoveFileContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.RevokeRoleContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.RevokeRoleFromUserContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.RevokeUserContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.RevokeWatermarkEmbeddingContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.RootOrIdContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.SelectElementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.SelectStatementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.SetColContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.SetStorageGroupContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.SetTTLStatementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ShowAllTTLStatementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ShowChildPathsContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ShowDevicesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ShowMergeStatusContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ShowStorageGroupContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ShowTTLStatementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ShowTimeseriesContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ShowVersionContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.ShowWhereClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.SlimitClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.SoffsetClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.StringLiteralContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.SuffixPathContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.TagClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.TimeIntervalContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.TracingOffContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.TracingOnContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.TypeClauseContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.UnsetTTLStatementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.UpdateStatementContext;
-import org.apache.iotdb.db.qp.strategy.SqlBaseParser.WhereClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.AlignByDeviceClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.AlterClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.AlterTimeseriesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.AlterUserContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.AndExpressionContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.AttributeClausesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ClearcacheContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ConstantContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.CountDevicesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.CountNodesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.CountStorageGroupContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.CountTimeseriesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.CreateRoleContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.CreateSnapshotContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.CreateTimeseriesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.CreateUserContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.DateExpressionContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.DeletePartitionContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.DeleteStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.DeleteStorageGroupContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.DeleteTimeseriesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.DropRoleContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.DropUserContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.FlushContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.FromClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.FullMergeContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.FullPathContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.GrantRoleContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.GrantRoleToUserContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.GrantUserContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.GrantWatermarkEmbeddingContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.GroupByFillClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.GroupByTimeClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.InClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.InsertColumnSpecContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.InsertStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.InsertValuesSpecContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.LimitClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ListAllRoleOfUserContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ListAllUserOfRoleContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ListPrivilegesRoleContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ListPrivilegesUserContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ListRoleContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ListRolePrivilegesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ListUserContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ListUserPrivilegesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.LoadConfigurationStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.LoadFilesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.LoadStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.MergeContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.MoveFileContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.NodeNameContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.NodeNameWithoutStarContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.OrExpressionContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.OrderByTimeClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.PredicateContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.PrefixPathContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.PrivilegesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.PropertyContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.PropertyValueContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.RemoveFileContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.RevokeRoleContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.RevokeRoleFromUserContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.RevokeUserContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.RevokeWatermarkEmbeddingContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.RootOrIdContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.SelectElementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.SelectStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.SetColContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.SetStorageGroupContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.SetTTLStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ShowAllTTLStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ShowChildPathsContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ShowDevicesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ShowFlushTaskInfoContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ShowMergeStatusContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ShowStorageGroupContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ShowTTLStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ShowTimeseriesContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ShowVersionContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.ShowWhereClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.SlimitClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.StringLiteralContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.SuffixPathContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.TimeIntervalContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.TracingOffContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.TracingOnContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.TypeClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.UnsetTTLStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.UpdateStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.WhereClauseContext;
import org.apache.iotdb.db.query.executor.fill.IFill;
import org.apache.iotdb.db.query.executor.fill.LinearFill;
import org.apache.iotdb.db.query.executor.fill.PreviousFill;
@@ -186,327 +160,156 @@ import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
import org.apache.iotdb.tsfile.utils.Pair;
import org.apache.iotdb.tsfile.utils.StringContainer;
-/**
- * This class is a listener and you can get an operator which is a logical plan.
- */
-public class LogicalGenerator extends SqlBaseBaseListener {
-
- private RootOperator initializedOperator = null;
- private ZoneId zoneId;
- private int operatorType;
- private CreateTimeSeriesOperator createTimeSeriesOperator;
- private AlterTimeSeriesOperator alterTimeSeriesOperator;
- private InsertOperator insertOp;
- private SelectOperator selectOp;
- private UpdateOperator updateOp;
- private QueryOperator queryOp;
- private DeleteDataOperator deleteDataOp;
+public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
private static final String DELETE_RANGE_ERROR_MSG =
- "For delete statement, where clause can only contain atomic expressions like : " +
- "time > XXX, time <= XXX, or two atomic expressions connected by 'AND'";
-
+ "For delete statement, where clause can only contain atomic expressions like : " +
+ "time > XXX, time <= XXX, or two atomic expressions connected by 'AND'";
+ private ZoneId zoneId;
- LogicalGenerator(ZoneId zoneId) {
+ public void setZoneId(ZoneId zoneId) {
this.zoneId = zoneId;
}
- RootOperator getLogicalPlan() {
- return initializedOperator;
- }
-
- @Override
- public void enterCountTimeseries(CountTimeseriesContext ctx) {
- super.enterCountTimeseries(ctx);
- PrefixPathContext pathContext = ctx.prefixPath();
- PartialPath path = (pathContext != null ? parsePrefixPath(pathContext) : new PartialPath(SQLConstant.getSingleRootArray()));
- if (ctx.INT() != null) {
- initializedOperator = new CountOperator(SQLConstant.TOK_COUNT_NODE_TIMESERIES,
- path, Integer.parseInt(ctx.INT().getText()));
- } else {
- initializedOperator = new CountOperator(SQLConstant.TOK_COUNT_TIMESERIES,
- path);
- }
- }
-
@Override
- public void enterCountDevices(CountDevicesContext ctx) {
- super.enterCountDevices(ctx);
- PrefixPathContext pathContext = ctx.prefixPath();
- PartialPath path = (pathContext != null ? parsePrefixPath(pathContext) : new PartialPath(SQLConstant.getSingleRootArray()));
- initializedOperator = new CountOperator(SQLConstant.TOK_COUNT_DEVICES, path);
- }
-
- @Override
- public void enterCountStorageGroup(CountStorageGroupContext ctx) {
- super.enterCountStorageGroup(ctx);
- PrefixPathContext pathContext = ctx.prefixPath();
- PartialPath path = (pathContext != null ? parsePrefixPath(pathContext) : new PartialPath(SQLConstant.getSingleRootArray()));
- initializedOperator = new CountOperator(SQLConstant.TOK_COUNT_STORAGE_GROUP, path);
+ public Operator visitCreateTimeseries(CreateTimeseriesContext ctx) {
+ CreateTimeSeriesOperator createTimeSeriesOperator = new CreateTimeSeriesOperator(SQLConstant.TOK_METADATA_CREATE);
+ createTimeSeriesOperator.setPath(parseFullPath(ctx.fullPath()));
+ createTimeSeriesOperator.setAlias(ctx.alias().ID().getText());
+ parseAttributeClauses(ctx.attributeClauses(), createTimeSeriesOperator);
+ return createTimeSeriesOperator;
}
@Override
- public void enterFlush(FlushContext ctx) {
- super.enterFlush(ctx);
- FlushOperator flushOperator = new FlushOperator(SQLConstant.TOK_FLUSH);
- if (ctx.booleanClause() != null) {
- flushOperator.setSeq(Boolean.parseBoolean(ctx.booleanClause().getText()));
- }
- if (ctx.prefixPath(0) != null) {
- List<PartialPath> storageGroups = new ArrayList<>();
- for (PrefixPathContext prefixPathContext : ctx.prefixPath()) {
- storageGroups.add(parsePrefixPath(prefixPathContext));
- }
- flushOperator.setStorageGroupList(storageGroups);
+ public Operator visitDeleteTimeseries(DeleteTimeseriesContext ctx) {
+ List<PartialPath> deletePaths = new ArrayList<>();
+ List<PrefixPathContext> prefixPaths = ctx.prefixPath();
+ for (PrefixPathContext prefixPath : prefixPaths) {
+ deletePaths.add(parsePrefixPath(prefixPath));
}
-
- initializedOperator = flushOperator;
- }
-
- @Override
- public void enterTracingOn(TracingOnContext ctx) {
- super.enterTracingOn(ctx);
- initializedOperator = new TracingOperator(SQLConstant.TOK_TRACING, true);
- }
-
- @Override
- public void enterTracingOff(TracingOffContext ctx) {
- super.enterTracingOff(ctx);
- initializedOperator = new TracingOperator(SQLConstant.TOK_TRACING, false);
- }
-
- @Override
- public void enterMerge(MergeContext ctx) {
- super.enterMerge(ctx);
- initializedOperator = new MergeOperator(SQLConstant.TOK_MERGE);
- }
-
- @Override
- public void enterFullMerge(FullMergeContext ctx) {
- super.enterFullMerge(ctx);
- initializedOperator = new MergeOperator(SQLConstant.TOK_FULL_MERGE);
- }
-
- @Override
- public void enterClearcache(SqlBaseParser.ClearcacheContext ctx) {
- super.enterClearcache(ctx);
- initializedOperator = new ClearCacheOperator(SQLConstant.TOK_CLEAR_CACHE);
+ DeleteTimeSeriesOperator deleteTimeSeriesOperator = new DeleteTimeSeriesOperator(
+ SQLConstant.TOK_METADATA_DELETE);
+ deleteTimeSeriesOperator.setDeletePathList(deletePaths);
+ return deleteTimeSeriesOperator;
}
@Override
- public void enterCountNodes(CountNodesContext ctx) {
- super.enterCountNodes(ctx);
- initializedOperator = new CountOperator(SQLConstant.TOK_COUNT_NODES,
- parsePrefixPath(ctx.prefixPath()), Integer.parseInt(ctx.INT().getText()));
+ public Operator visitAlterTimeseries(AlterTimeseriesContext ctx) {
+ AlterTimeSeriesOperator alterTimeSeriesOperator = new AlterTimeSeriesOperator(SQLConstant.TOK_METADATA_ALTER);
+ alterTimeSeriesOperator.setPath(parseFullPath(ctx.fullPath()));
+ parseAlterClause(ctx.alterClause(), alterTimeSeriesOperator);
+ return alterTimeSeriesOperator;
}
@Override
- public void enterShowDevices(ShowDevicesContext ctx) {
- super.enterShowDevices(ctx);
- if (ctx.prefixPath() != null) {
- initializedOperator = new ShowDevicesOperator(SQLConstant.TOK_DEVICES,
- parsePrefixPath(ctx.prefixPath()));
- } else {
- initializedOperator = new ShowDevicesOperator(SQLConstant.TOK_DEVICES,
- new PartialPath(SQLConstant.getSingleRootArray()));
- }
+ public Operator visitInsertStatement(InsertStatementContext ctx) {
+ InsertOperator insertOp = new InsertOperator(SQLConstant.TOK_INSERT);
+ SelectOperator selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
+ selectOp.addSelectPath(parsePrefixPath(ctx.prefixPath()));
+ insertOp.setSelectOperator(selectOp);
+ parseInsertColumnSpec(ctx.insertColumnSpec(), insertOp);
+ parseInsertValuesSpec(ctx.insertValuesSpec(), insertOp);
+ return insertOp;
}
@Override
- public void enterShowChildPaths(ShowChildPathsContext ctx) {
- super.enterShowChildPaths(ctx);
- if (ctx.prefixPath() != null) {
- initializedOperator = new ShowChildPathsOperator(SQLConstant.TOK_CHILD_PATHS,
- parsePrefixPath(ctx.prefixPath()));
- } else {
- initializedOperator = new ShowChildPathsOperator(SQLConstant.TOK_CHILD_PATHS,
- new PartialPath(SQLConstant.getSingleRootArray()));
+ public Operator visitUpdateStatement(UpdateStatementContext ctx) {
+ UpdateOperator updateOp = new UpdateOperator(SQLConstant.TOK_UPDATE);
+ FromOperator fromOp = new FromOperator(SQLConstant.TOK_FROM);
+ fromOp.addPrefixTablePath(parsePrefixPath(ctx.prefixPath()));
+ SelectOperator selectOp = new SelectOperator(SQLConstant.TOK_QUERY);
+ for(SetColContext colContext : ctx.setClause().setCol()) {
+ parseSetCol(colContext, selectOp, updateOp);
}
+ FilterOperator whereOp = (FilterOperator) visit(ctx.whereClause());
+ updateOp.setFilterOperator(whereOp.getChildren().get(0));
+ updateOp.setSelectOperator(selectOp);
+ return updateOp;
}
@Override
- public void enterShowStorageGroup(ShowStorageGroupContext ctx) {
- super.enterShowStorageGroup(ctx);
- if (ctx.prefixPath() != null) {
- initializedOperator = new ShowStorageGroupOperator(SQLConstant.TOK_STORAGE_GROUP,
- parsePrefixPath(ctx.prefixPath()));
- } else {
- initializedOperator = new ShowStorageGroupOperator(SQLConstant.TOK_STORAGE_GROUP,
- new PartialPath(SQLConstant.getSingleRootArray()));
+ public Operator visitDeleteStatement(DeleteStatementContext ctx) {
+ DeleteDataOperator deleteDataOp = new DeleteDataOperator(SQLConstant.TOK_DELETE);
+ SelectOperator selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
+ List<PrefixPathContext> prefixPaths = ctx.prefixPath();
+ for (PrefixPathContext prefixPath : prefixPaths) {
+ PartialPath path = parsePrefixPath(prefixPath);
+ selectOp.addSelectPath(path);
}
- }
-
- @Override
- public void enterLoadFiles(LoadFilesContext ctx) {
- super.enterLoadFiles(ctx);
- if (ctx.autoCreateSchema() != null) {
- if (ctx.autoCreateSchema().INT() != null) {
- initializedOperator = new LoadFilesOperator(
- new File(removeStringQuote(ctx.stringLiteral().getText())),
- Boolean.parseBoolean(ctx.autoCreateSchema().booleanClause().getText()),
- Integer.parseInt(ctx.autoCreateSchema().INT().getText())
- );
- } else {
- initializedOperator = new LoadFilesOperator(
- new File(removeStringQuote(ctx.stringLiteral().getText())),
- Boolean.parseBoolean(ctx.autoCreateSchema().booleanClause().getText()),
- IoTDBDescriptor.getInstance().getConfig().getDefaultStorageGroupLevel()
- );
- }
- } else {
- initializedOperator = new LoadFilesOperator(
- new File(removeStringQuote(ctx.stringLiteral().getText())),
- true,
- IoTDBDescriptor.getInstance().getConfig().getDefaultStorageGroupLevel()
- );
+ deleteDataOp.setSelectOperator(selectOp);
+ if(ctx.whereClause() != null) {
+ FilterOperator whereOp = (FilterOperator) visit(ctx.whereClause());
+ deleteDataOp.setFilterOperator(whereOp.getChildren().get(0));
+ Pair<Long, Long> timeInterval = parseDeleteTimeInterval(deleteDataOp);
+ deleteDataOp.setStartTime(timeInterval.left);
+ deleteDataOp.setEndTime(timeInterval.right);
}
+ return deleteDataOp;
}
@Override
- public void enterMoveFile(MoveFileContext ctx) {
- super.enterMoveFile(ctx);
- initializedOperator = new MoveFileOperator(
- new File(removeStringQuote(ctx.stringLiteral(0).getText())),
- new File(removeStringQuote(ctx.stringLiteral(1).getText())));
- }
-
- @Override
- public void enterRemoveFile(RemoveFileContext ctx) {
- super.enterRemoveFile(ctx);
- initializedOperator = new RemoveFileOperator(
- new File(removeStringQuote(ctx.stringLiteral().getText())));
+ public Operator visitSetStorageGroup(SetStorageGroupContext ctx) {
+ SetStorageGroupOperator setStorageGroupOperator = new SetStorageGroupOperator(
+ SQLConstant.TOK_METADATA_SET_FILE_LEVEL);
+ PartialPath path = parsePrefixPath(ctx.prefixPath());
+ setStorageGroupOperator.setPath(path);
+ return setStorageGroupOperator;
}
@Override
- public void enterLoadConfigurationStatement(LoadConfigurationStatementContext ctx) {
- super.enterLoadConfigurationStatement(ctx);
- if (ctx.GLOBAL() != null) {
- initializedOperator = new LoadConfigurationOperator(LoadConfigurationOperatorType.GLOBAL);
- } else {
- initializedOperator = new LoadConfigurationOperator(LoadConfigurationOperatorType.LOCAL);
+ public Operator visitDeleteStorageGroup(DeleteStorageGroupContext ctx) {
+ List<PartialPath> deletePaths = new ArrayList<>();
+ List<PrefixPathContext> prefixPaths = ctx.prefixPath();
+ for (PrefixPathContext prefixPath : prefixPaths) {
+ deletePaths.add(parsePrefixPath(prefixPath));
}
-
- }
-
- @Override
- public void enterShowVersion(ShowVersionContext ctx) {
- super.enterShowVersion(ctx);
- initializedOperator = new ShowOperator(SQLConstant.TOK_VERSION);
+ DeleteStorageGroupOperator deleteStorageGroupOperator = new DeleteStorageGroupOperator(
+ SQLConstant.TOK_METADATA_DELETE_FILE_LEVEL);
+ deleteStorageGroupOperator.setDeletePathList(deletePaths);
+ return deleteStorageGroupOperator;
}
@Override
- public void enterShowFlushTaskInfo(SqlBaseParser.ShowFlushTaskInfoContext ctx) {
- super.enterShowFlushTaskInfo(ctx);
- initializedOperator = new ShowOperator(SQLConstant.TOK_FLUSH_TASK_INFO);
+ public Operator visitMerge(MergeContext ctx) {
+ return new MergeOperator(SQLConstant.TOK_MERGE);
}
@Override
- public void enterShowTimeseries(ShowTimeseriesContext ctx) {
- super.enterShowTimeseries(ctx);
- boolean orderByHeat = ctx.LATEST() != null;
- if (ctx.prefixPath() != null) {
- initializedOperator = new ShowTimeSeriesOperator(SQLConstant.TOK_TIMESERIES,
- parsePrefixPath(ctx.prefixPath()), orderByHeat);
- } else {
- initializedOperator = new ShowTimeSeriesOperator(SQLConstant.TOK_TIMESERIES, new PartialPath(SQLConstant.getSingleRootArray()),
- orderByHeat);
+ public Operator visitFlush(FlushContext ctx) {
+ FlushOperator flushOperator = new FlushOperator(SQLConstant.TOK_FLUSH);
+ if (ctx.booleanClause() != null) {
+ flushOperator.setSeq(Boolean.parseBoolean(ctx.booleanClause().getText()));
}
- }
-
- @Override
- public void enterCreateTimeseries(CreateTimeseriesContext ctx) {
- super.enterCreateTimeseries(ctx);
- createTimeSeriesOperator = new CreateTimeSeriesOperator(SQLConstant.TOK_METADATA_CREATE);
- operatorType = SQLConstant.TOK_METADATA_CREATE;
- createTimeSeriesOperator.setPath(parseFullPath(ctx.fullPath()));
- }
-
- @Override
- public void enterAlterTimeseries(SqlBaseParser.AlterTimeseriesContext ctx) {
- super.enterAlterTimeseries(ctx);
- alterTimeSeriesOperator = new AlterTimeSeriesOperator(SQLConstant.TOK_METADATA_ALTER);
- operatorType = SQLConstant.TOK_METADATA_ALTER;
- alterTimeSeriesOperator.setPath(parseFullPath(ctx.fullPath()));
- }
-
- @Override
- public void enterAlterClause(SqlBaseParser.AlterClauseContext ctx) {
- super.enterAlterClause(ctx);
- Map<String, String> alterMap = new HashMap<>();
- // rename
- if (ctx.RENAME() != null) {
- alterTimeSeriesOperator.setAlterType(AlterType.RENAME);
- alterMap.put(ctx.beforeName.getText(), ctx.currentName.getText());
- } else if (ctx.SET() != null) {
- // set
- alterTimeSeriesOperator.setAlterType(AlterType.SET);
- setMap(ctx, alterMap);
- } else if (ctx.DROP() != null) {
- // drop
- alterTimeSeriesOperator.setAlterType(AlterType.DROP);
- for (TerminalNode dropId : ctx.ID()) {
- alterMap.put(dropId.getText(), null);
+ if (ctx.prefixPath(0) != null) {
+ List<PartialPath> storageGroups = new ArrayList<>();
+ for (PrefixPathContext prefixPathContext : ctx.prefixPath()) {
+ storageGroups.add(parsePrefixPath(prefixPathContext));
}
- } else if (ctx.TAGS() != null) {
- // add tag
- alterTimeSeriesOperator.setAlterType(AlterType.ADD_TAGS);
- setMap(ctx, alterMap);
- } else if (ctx.ATTRIBUTES() != null) {
- // add attribute
- alterTimeSeriesOperator.setAlterType(AlterType.ADD_ATTRIBUTES);
- setMap(ctx, alterMap);
- } else {
- // upsert
- alterTimeSeriesOperator.setAlterType(AlterType.UPSERT);
+ flushOperator.setStorageGroupList(storageGroups);
}
- alterTimeSeriesOperator.setAlterMap(alterMap);
- initializedOperator = alterTimeSeriesOperator;
+ return flushOperator;
}
- private void setMap(SqlBaseParser.AlterClauseContext ctx, Map<String, String> alterMap) {
- List<PropertyContext> tagsList = ctx.property();
- if (ctx.property(0) != null) {
- for (PropertyContext property : tagsList) {
- String value;
- if (property.propertyValue().stringLiteral() != null) {
- value = removeStringQuote(property.propertyValue().getText());
- } else {
- value = property.propertyValue().getText();
- }
- alterMap.put(property.ID().getText(), value);
- }
- }
+ @Override
+ public Operator visitFullMerge(FullMergeContext ctx) {
+ return new MergeOperator(SQLConstant.TOK_FULL_MERGE);
}
@Override
- public void enterAlias(AliasContext ctx) {
- super.enterAlias(ctx);
- createTimeSeriesOperator.setAlias(ctx.ID().getText());
+ public Operator visitClearcache(ClearcacheContext ctx) {
+ return new ClearCacheOperator(SQLConstant.TOK_CLEAR_CACHE);
}
@Override
- public void enterCreateUser(CreateUserContext ctx) {
- super.enterCreateUser(ctx);
+ public Operator visitCreateUser(CreateUserContext ctx) {
AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_CREATE,
AuthorOperator.AuthorType.CREATE_USER);
authorOperator.setUserName(ctx.ID().getText());
authorOperator.setPassWord(removeStringQuote(ctx.password.getText()));
- initializedOperator = authorOperator;
- operatorType = SQLConstant.TOK_AUTHOR_CREATE;
- }
-
- @Override
- public void enterCreateRole(CreateRoleContext ctx) {
- super.enterCreateRole(ctx);
- AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_CREATE,
- AuthorOperator.AuthorType.CREATE_ROLE);
- authorOperator.setRoleName(ctx.ID().getText());
- initializedOperator = authorOperator;
- operatorType = SQLConstant.TOK_AUTHOR_CREATE;
+ return authorOperator;
}
@Override
- public void enterAlterUser(AlterUserContext ctx) {
- super.enterAlterUser(ctx);
+ public Operator visitAlterUser(AlterUserContext ctx) {
AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_UPDATE_USER,
AuthorOperator.AuthorType.UPDATE_USER);
if (ctx.ID() != null) {
@@ -515,103 +318,93 @@ public class LogicalGenerator extends SqlBaseBaseListener {
authorOperator.setUserName(ctx.ROOT().getText());
}
authorOperator.setNewPassword(removeStringQuote(ctx.password.getText()));
- initializedOperator = authorOperator;
- operatorType = SQLConstant.TOK_AUTHOR_UPDATE_USER;
+ return authorOperator;
}
@Override
- public void enterDropUser(DropUserContext ctx) {
- super.enterDropUser(ctx);
+ public Operator visitDropUser(DropUserContext ctx) {
AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_DROP,
AuthorOperator.AuthorType.DROP_USER);
authorOperator.setUserName(ctx.ID().getText());
- initializedOperator = authorOperator;
- operatorType = SQLConstant.TOK_AUTHOR_DROP;
+ return authorOperator;
+ }
+
+ @Override
+ public Operator visitCreateRole(CreateRoleContext ctx) {
+ AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_CREATE,
+ AuthorOperator.AuthorType.CREATE_ROLE);
+ authorOperator.setRoleName(ctx.ID().getText());
+ return authorOperator;
}
@Override
- public void enterDropRole(DropRoleContext ctx) {
- super.enterDropRole(ctx);
+ public Operator visitDropRole(DropRoleContext ctx) {
AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_DROP,
AuthorOperator.AuthorType.DROP_ROLE);
authorOperator.setRoleName(ctx.ID().getText());
- initializedOperator = authorOperator;
- operatorType = SQLConstant.TOK_AUTHOR_DROP;
+ return authorOperator;
}
@Override
- public void enterGrantUser(GrantUserContext ctx) {
- super.enterGrantUser(ctx);
+ public Operator visitGrantUser(GrantUserContext ctx) {
AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_GRANT,
AuthorOperator.AuthorType.GRANT_USER);
authorOperator.setUserName(ctx.ID().getText());
authorOperator.setPrivilegeList(parsePrivilege(ctx.privileges()));
authorOperator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
- initializedOperator = authorOperator;
- operatorType = SQLConstant.TOK_AUTHOR_GRANT;
+ return authorOperator;
}
@Override
- public void enterGrantRole(GrantRoleContext ctx) {
- super.enterGrantRole(ctx);
+ public Operator visitGrantRole(GrantRoleContext ctx) {
AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_GRANT,
AuthorType.GRANT_ROLE);
authorOperator.setRoleName(ctx.ID().getText());
authorOperator.setPrivilegeList(parsePrivilege(ctx.privileges()));
authorOperator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
- initializedOperator = authorOperator;
- operatorType = SQLConstant.TOK_AUTHOR_GRANT;
+ return authorOperator;
}
@Override
- public void enterRevokeUser(RevokeUserContext ctx) {
- super.enterRevokeUser(ctx);
+ public Operator visitRevokeUser(RevokeUserContext ctx) {
AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_GRANT,
AuthorType.REVOKE_USER);
authorOperator.setUserName(ctx.ID().getText());
authorOperator.setPrivilegeList(parsePrivilege(ctx.privileges()));
authorOperator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
- initializedOperator = authorOperator;
- operatorType = SQLConstant.TOK_AUTHOR_GRANT;
+ return authorOperator;
}
@Override
- public void enterRevokeRole(RevokeRoleContext ctx) {
- super.enterRevokeRole(ctx);
+ public Operator visitRevokeRole(RevokeRoleContext ctx) {
AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_GRANT,
AuthorType.REVOKE_ROLE);
authorOperator.setRoleName(ctx.ID().getText());
authorOperator.setPrivilegeList(parsePrivilege(ctx.privileges()));
authorOperator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
- initializedOperator = authorOperator;
- operatorType = SQLConstant.TOK_AUTHOR_GRANT;
+ return authorOperator;
}
@Override
- public void enterGrantRoleToUser(GrantRoleToUserContext ctx) {
- super.enterGrantRoleToUser(ctx);
+ public Operator visitGrantRoleToUser(GrantRoleToUserContext ctx) {
AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_GRANT,
AuthorOperator.AuthorType.GRANT_ROLE_TO_USER);
authorOperator.setRoleName(ctx.roleName.getText());
authorOperator.setUserName(ctx.userName.getText());
- initializedOperator = authorOperator;
- operatorType = SQLConstant.TOK_AUTHOR_GRANT;
+ return authorOperator;
}
@Override
- public void enterRevokeRoleFromUser(RevokeRoleFromUserContext ctx) {
- super.enterRevokeRoleFromUser(ctx);
+ public Operator visitRevokeRoleFromUser(RevokeRoleFromUserContext ctx) {
AuthorOperator authorOperator = new AuthorOperator(SQLConstant.TOK_AUTHOR_GRANT,
AuthorType.REVOKE_ROLE_FROM_USER);
authorOperator.setRoleName(ctx.roleName.getText());
authorOperator.setUserName(ctx.userName.getText());
- initializedOperator = authorOperator;
- operatorType = SQLConstant.TOK_AUTHOR_GRANT;
+ return authorOperator;
}
@Override
- public void enterLoadStatement(LoadStatementContext ctx) {
- super.enterLoadStatement(ctx);
+ public Operator visitLoadStatement(LoadStatementContext ctx) {
if (ctx.prefixPath().nodeName().size() < 3) {
throw new SQLParserException("data load command: child count < 3\n");
}
@@ -623,235 +416,384 @@ public class LogicalGenerator extends SqlBaseBaseListener {
for (NodeNameContext nodeName : nodeNames) {
sc.addTail(nodeName.getText());
}
- initializedOperator = new LoadDataOperator(SQLConstant.TOK_DATALOAD,
+ return new LoadDataOperator(SQLConstant.TOK_DATALOAD,
removeStringQuote(csvPath),
sc.toString());
- operatorType = SQLConstant.TOK_DATALOAD;
}
@Override
- public void enterGrantWatermarkEmbedding(GrantWatermarkEmbeddingContext ctx) {
- super.enterGrantWatermarkEmbedding(ctx);
+ public Operator visitGrantWatermarkEmbedding(GrantWatermarkEmbeddingContext ctx) {
List<RootOrIdContext> rootOrIdList = ctx.rootOrId();
List<String> users = new ArrayList<>();
for (RootOrIdContext rootOrId : rootOrIdList) {
users.add(rootOrId.getText());
}
- initializedOperator = new DataAuthOperator(SQLConstant.TOK_GRANT_WATERMARK_EMBEDDING, users);
+ return new DataAuthOperator(SQLConstant.TOK_GRANT_WATERMARK_EMBEDDING, users);
}
@Override
- public void enterRevokeWatermarkEmbedding(RevokeWatermarkEmbeddingContext ctx) {
- super.enterRevokeWatermarkEmbedding(ctx);
+ public Operator visitRevokeWatermarkEmbedding(RevokeWatermarkEmbeddingContext ctx) {
List<RootOrIdContext> rootOrIdList = ctx.rootOrId();
List<String> users = new ArrayList<>();
for (RootOrIdContext rootOrId : rootOrIdList) {
users.add(rootOrId.getText());
}
- initializedOperator = new DataAuthOperator(SQLConstant.TOK_REVOKE_WATERMARK_EMBEDDING, users);
- operatorType = SQLConstant.TOK_REVOKE_WATERMARK_EMBEDDING;
+ return new DataAuthOperator(SQLConstant.TOK_REVOKE_WATERMARK_EMBEDDING, users);
}
@Override
- public void enterListUser(ListUserContext ctx) {
- super.enterListUser(ctx);
- initializedOperator = new AuthorOperator(SQLConstant.TOK_LIST,
- AuthorOperator.AuthorType.LIST_USER);
- operatorType = SQLConstant.TOK_LIST;
+ public Operator visitListUser(ListUserContext ctx) {
+ return new AuthorOperator(SQLConstant.TOK_LIST, AuthorOperator.AuthorType.LIST_USER);
}
@Override
- public void enterListRole(ListRoleContext ctx) {
- super.enterListRole(ctx);
- initializedOperator = new AuthorOperator(SQLConstant.TOK_LIST,
- AuthorOperator.AuthorType.LIST_ROLE);
- operatorType = SQLConstant.TOK_LIST;
+ public Operator visitListRole(ListRoleContext ctx) {
+ return new AuthorOperator(SQLConstant.TOK_LIST, AuthorOperator.AuthorType.LIST_ROLE);
}
@Override
- public void enterListPrivilegesUser(ListPrivilegesUserContext ctx) {
- super.enterListPrivilegesUser(ctx);
+ public Operator visitListPrivilegesUser(ListPrivilegesUserContext ctx) {
AuthorOperator operator = new AuthorOperator(SQLConstant.TOK_LIST,
AuthorOperator.AuthorType.LIST_USER_PRIVILEGE);
operator.setUserName(ctx.rootOrId().getText());
operator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
- initializedOperator = operator;
- operatorType = SQLConstant.TOK_LIST;
+ return operator;
}
@Override
- public void enterListPrivilegesRole(ListPrivilegesRoleContext ctx) {
- super.enterListPrivilegesRole(ctx);
+ public Operator visitListPrivilegesRole(ListPrivilegesRoleContext ctx) {
AuthorOperator operator = new AuthorOperator(SQLConstant.TOK_LIST,
AuthorOperator.AuthorType.LIST_ROLE_PRIVILEGE);
operator.setRoleName((ctx.ID().getText()));
operator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
- initializedOperator = operator;
- operatorType = SQLConstant.TOK_LIST;
+ return operator;
}
@Override
- public void enterListUserPrivileges(ListUserPrivilegesContext ctx) {
- super.enterListUserPrivileges(ctx);
+ public Operator visitListUserPrivileges(ListUserPrivilegesContext ctx) {
AuthorOperator operator = new AuthorOperator(SQLConstant.TOK_LIST,
AuthorOperator.AuthorType.LIST_USER_PRIVILEGE);
operator.setUserName(ctx.rootOrId().getText());
- initializedOperator = operator;
- operatorType = SQLConstant.TOK_LIST;
+ return operator;
}
@Override
- public void enterListRolePrivileges(ListRolePrivilegesContext ctx) {
- super.enterListRolePrivileges(ctx);
+ public Operator visitListRolePrivileges(ListRolePrivilegesContext ctx) {
AuthorOperator operator = new AuthorOperator(SQLConstant.TOK_LIST,
AuthorOperator.AuthorType.LIST_ROLE_PRIVILEGE);
operator.setRoleName(ctx.ID().getText());
- initializedOperator = operator;
- operatorType = SQLConstant.TOK_LIST;
+ return operator;
}
@Override
- public void enterListAllRoleOfUser(ListAllRoleOfUserContext ctx) {
- super.enterListAllRoleOfUser(ctx);
+ public Operator visitListAllRoleOfUser(ListAllRoleOfUserContext ctx) {
AuthorOperator operator = new AuthorOperator(SQLConstant.TOK_LIST,
AuthorOperator.AuthorType.LIST_USER_ROLES);
- initializedOperator = operator;
operator.setUserName(ctx.rootOrId().getText());
- operatorType = SQLConstant.TOK_LIST;
+ return operator;
}
@Override
- public void enterListAllUserOfRole(ListAllUserOfRoleContext ctx) {
- super.enterListAllUserOfRole(ctx);
+ public Operator visitListAllUserOfRole(ListAllUserOfRoleContext ctx) {
AuthorOperator operator = new AuthorOperator(SQLConstant.TOK_LIST,
AuthorOperator.AuthorType.LIST_ROLE_USERS);
- initializedOperator = operator;
operator.setRoleName((ctx.ID().getText()));
- operatorType = SQLConstant.TOK_LIST;
+ return operator;
}
@Override
- public void enterSetTTLStatement(SetTTLStatementContext ctx) {
- super.enterSetTTLStatement(ctx);
+ public Operator visitSetTTLStatement(SetTTLStatementContext ctx) {
SetTTLOperator operator = new SetTTLOperator(SQLConstant.TOK_SET);
operator.setStorageGroup(parsePrefixPath(ctx.prefixPath()));
operator.setDataTTL(Long.parseLong(ctx.INT().getText()));
- initializedOperator = operator;
- operatorType = SQLConstant.TOK_SET;
+ return operator;
}
@Override
- public void enterUnsetTTLStatement(UnsetTTLStatementContext ctx) {
- super.enterUnsetTTLStatement(ctx);
+ public Operator visitUnsetTTLStatement(UnsetTTLStatementContext ctx) {
SetTTLOperator operator = new SetTTLOperator(SQLConstant.TOK_UNSET);
operator.setStorageGroup(parsePrefixPath(ctx.prefixPath()));
- initializedOperator = operator;
- operatorType = SQLConstant.TOK_UNSET;
+ return operator;
}
@Override
- public void enterShowTTLStatement(ShowTTLStatementContext ctx) {
- super.enterShowTTLStatement(ctx);
+ public Operator visitShowTTLStatement(ShowTTLStatementContext ctx) {
List<PartialPath> storageGroups = new ArrayList<>();
List<PrefixPathContext> prefixPathList = ctx.prefixPath();
for (PrefixPathContext prefixPath : prefixPathList) {
storageGroups.add(parsePrefixPath(prefixPath));
}
- initializedOperator = new ShowTTLOperator(storageGroups);
+ return new ShowTTLOperator(storageGroups);
}
@Override
- public void enterShowAllTTLStatement(ShowAllTTLStatementContext ctx) {
- super.enterShowAllTTLStatement(ctx);
+ public Operator visitShowAllTTLStatement(ShowAllTTLStatementContext ctx) {
List<PartialPath> storageGroups = new ArrayList<>();
- initializedOperator = new ShowTTLOperator(storageGroups);
+ return new ShowTTLOperator(storageGroups);
}
- private String[] parsePrivilege(PrivilegesContext ctx) {
- List<StringLiteralContext> privilegeList = ctx.stringLiteral();
- List<String> privileges = new ArrayList<>();
- for (StringLiteralContext privilege : privilegeList) {
- privileges.add(removeStringQuote(privilege.getText()));
- }
- return privileges.toArray(new String[0]);
+ @Override
+ public Operator visitShowFlushTaskInfo(ShowFlushTaskInfoContext ctx) {
+ return new ShowOperator(SQLConstant.TOK_FLUSH_TASK_INFO);
}
- private String removeStringQuote(String src) {
- if (src.charAt(0) == '\'' && src.charAt(src.length() - 1) == '\'') {
- return src.substring(1, src.length() - 1);
- } else if (src.charAt(0) == '\"' && src.charAt(src.length() - 1) == '\"') {
- return src.substring(1, src.length() - 1);
+ @Override
+ public Operator visitShowVersion(ShowVersionContext ctx) {
+ return new ShowOperator(SQLConstant.TOK_VERSION);
+ }
+
+ @Override
+ public Operator visitShowTimeseries(ShowTimeseriesContext ctx) {
+ boolean orderByHeat = ctx.LATEST() != null;
+ ShowTimeSeriesOperator showTimeSeriesOperator;
+ if (ctx.prefixPath() != null) {
+ showTimeSeriesOperator = new ShowTimeSeriesOperator(SQLConstant.TOK_TIMESERIES,
+ parsePrefixPath(ctx.prefixPath()), orderByHeat);
} else {
- throw new SQLParserException("error format for string with quote:" + src);
+ showTimeSeriesOperator = new ShowTimeSeriesOperator(SQLConstant.TOK_TIMESERIES, new PartialPath(SQLConstant.getSingleRootArray()),
+ orderByHeat);
}
+ if(ctx.showWhereClause() != null) {
+ parseShowWhereClause(ctx.showWhereClause(), showTimeSeriesOperator);
+ }
+ showTimeSeriesOperator.setLimit(parseLimitClause(ctx.limitClause()));
+ return showTimeSeriesOperator;
}
@Override
- public void enterDeleteTimeseries(DeleteTimeseriesContext ctx) {
- super.enterDeleteTimeseries(ctx);
- List<PartialPath> deletePaths = new ArrayList<>();
- List<PrefixPathContext> prefixPaths = ctx.prefixPath();
- for (PrefixPathContext prefixPath : prefixPaths) {
- deletePaths.add(parsePrefixPath(prefixPath));
+ public Operator visitShowStorageGroup(ShowStorageGroupContext ctx) {
+ if (ctx.prefixPath() != null) {
+ return new ShowStorageGroupOperator(SQLConstant.TOK_STORAGE_GROUP,
+ parsePrefixPath(ctx.prefixPath()));
+ } else {
+ return new ShowStorageGroupOperator(SQLConstant.TOK_STORAGE_GROUP,
+ new PartialPath(SQLConstant.getSingleRootArray()));
}
- DeleteTimeSeriesOperator deleteTimeSeriesOperator = new DeleteTimeSeriesOperator(
- SQLConstant.TOK_METADATA_DELETE);
- deleteTimeSeriesOperator.setDeletePathList(deletePaths);
- initializedOperator = deleteTimeSeriesOperator;
- operatorType = SQLConstant.TOK_METADATA_DELETE;
}
@Override
- public void enterSetStorageGroup(SetStorageGroupContext ctx) {
- super.enterSetStorageGroup(ctx);
- SetStorageGroupOperator setStorageGroupOperator = new SetStorageGroupOperator(
- SQLConstant.TOK_METADATA_SET_FILE_LEVEL);
- PartialPath path = parsePrefixPath(ctx.prefixPath());
- setStorageGroupOperator.setPath(path);
- initializedOperator = setStorageGroupOperator;
- operatorType = SQLConstant.TOK_METADATA_SET_FILE_LEVEL;
+ public Operator visitShowChildPaths(ShowChildPathsContext ctx) {
+ if (ctx.prefixPath() != null) {
+ return new ShowChildPathsOperator(SQLConstant.TOK_CHILD_PATHS,
+ parsePrefixPath(ctx.prefixPath()));
+ } else {
+ return new ShowChildPathsOperator(SQLConstant.TOK_CHILD_PATHS,
+ new PartialPath(SQLConstant.getSingleRootArray()));
+ }
}
@Override
- public void enterDeleteStorageGroup(DeleteStorageGroupContext ctx) {
- super.enterDeleteStorageGroup(ctx);
- List<PartialPath> deletePaths = new ArrayList<>();
- List<PrefixPathContext> prefixPaths = ctx.prefixPath();
- for (PrefixPathContext prefixPath : prefixPaths) {
- deletePaths.add(parsePrefixPath(prefixPath));
+ public Operator visitShowDevices(ShowDevicesContext ctx) {
+ if (ctx.prefixPath() != null) {
+ return new ShowDevicesOperator(SQLConstant.TOK_DEVICES,
+ parsePrefixPath(ctx.prefixPath()));
+ } else {
+ return new ShowDevicesOperator(SQLConstant.TOK_DEVICES,
+ new PartialPath(SQLConstant.getSingleRootArray()));
}
- DeleteStorageGroupOperator deleteStorageGroupOperator = new DeleteStorageGroupOperator(
- SQLConstant.TOK_METADATA_DELETE_FILE_LEVEL);
- deleteStorageGroupOperator.setDeletePathList(deletePaths);
- initializedOperator = deleteStorageGroupOperator;
- operatorType = SQLConstant.TOK_METADATA_DELETE_FILE_LEVEL;
}
@Override
- public void enterDeleteStatement(DeleteStatementContext ctx) {
- super.enterDeleteStatement(ctx);
- operatorType = SQLConstant.TOK_DELETE;
- deleteDataOp = new DeleteDataOperator(SQLConstant.TOK_DELETE);
- selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
- List<PrefixPathContext> prefixPaths = ctx.prefixPath();
- for (PrefixPathContext prefixPath : prefixPaths) {
- PartialPath path = parsePrefixPath(prefixPath);
- selectOp.addSelectPath(path);
+ public Operator visitShowMergeStatus(ShowMergeStatusContext ctx) {
+ return new ShowMergeStatusOperator(SQLConstant.TOK_SHOW_MERGE_STATUS);
+ }
+
+ @Override
+ public Operator visitTracingOn(TracingOnContext ctx) {
+ return new TracingOperator(SQLConstant.TOK_TRACING, true);
+ }
+
+ @Override
+ public Operator visitTracingOff(TracingOffContext ctx) {
+ return new TracingOperator(SQLConstant.TOK_TRACING, false);
+ }
+
+ @Override
+ public Operator visitCountTimeseries(CountTimeseriesContext ctx) {
+ PrefixPathContext pathContext = ctx.prefixPath();
+ PartialPath path = (pathContext != null ? parsePrefixPath(pathContext) : new PartialPath(SQLConstant.getSingleRootArray()));
+ if (ctx.INT() != null) {
+ return new CountOperator(SQLConstant.TOK_COUNT_NODE_TIMESERIES,
+ path, Integer.parseInt(ctx.INT().getText()));
+ } else {
+ return new CountOperator(SQLConstant.TOK_COUNT_TIMESERIES,
+ path);
}
- deleteDataOp.setSelectOperator(selectOp);
- initializedOperator = deleteDataOp;
}
@Override
- public void enterDisableAlign(SqlBaseParser.DisableAlignContext ctx) {
- super.enterDisableAlign(ctx);
- queryOp.setAlignByTime(false);
+ public Operator visitCountDevices(CountDevicesContext ctx) {
+ PrefixPathContext pathContext = ctx.prefixPath();
+ PartialPath path = (pathContext != null ? parsePrefixPath(pathContext) : new PartialPath(SQLConstant.getSingleRootArray()));
+ return new CountOperator(SQLConstant.TOK_COUNT_DEVICES, path);
+ }
+
+ @Override
+ public Operator visitCountStorageGroup(CountStorageGroupContext ctx) {
+ PrefixPathContext pathContext = ctx.prefixPath();
+ PartialPath path = (pathContext != null ? parsePrefixPath(pathContext) : new PartialPath(SQLConstant.getSingleRootArray()));
+ return new CountOperator(SQLConstant.TOK_COUNT_STORAGE_GROUP, path);
+ }
+
+ @Override
+ public Operator visitCountNodes(CountNodesContext ctx) {
+ return new CountOperator(SQLConstant.TOK_COUNT_NODES,
+ parsePrefixPath(ctx.prefixPath()), Integer.parseInt(ctx.INT().getText()));
+ }
+
+ @Override
+ public Operator visitLoadConfigurationStatement(LoadConfigurationStatementContext ctx) {
+ if (ctx.GLOBAL() != null) {
+ return new LoadConfigurationOperator(LoadConfigurationOperatorType.GLOBAL);
+ } else {
+ return new LoadConfigurationOperator(LoadConfigurationOperatorType.LOCAL);
+ }
+ }
+
+ @Override
+ public Operator visitLoadFiles(LoadFilesContext ctx) {
+ if (ctx.autoCreateSchema() != null) {
+ if (ctx.autoCreateSchema().INT() != null) {
+ return new LoadFilesOperator(
+ new File(removeStringQuote(ctx.stringLiteral().getText())),
+ Boolean.parseBoolean(ctx.autoCreateSchema().booleanClause().getText()),
+ Integer.parseInt(ctx.autoCreateSchema().INT().getText())
+ );
+ } else {
+ return new LoadFilesOperator(
+ new File(removeStringQuote(ctx.stringLiteral().getText())),
+ Boolean.parseBoolean(ctx.autoCreateSchema().booleanClause().getText()),
+ IoTDBDescriptor.getInstance().getConfig().getDefaultStorageGroupLevel()
+ );
+ }
+ } else {
+ return new LoadFilesOperator(
+ new File(removeStringQuote(ctx.stringLiteral().getText())),
+ true,
+ IoTDBDescriptor.getInstance().getConfig().getDefaultStorageGroupLevel()
+ );
+ }
+ }
+
+ @Override
+ public Operator visitRemoveFile(RemoveFileContext ctx) {
+ return new RemoveFileOperator(new File(removeStringQuote(ctx.stringLiteral().getText())));
+ }
+
+ @Override
+ public Operator visitMoveFile(MoveFileContext ctx) {
+ return new MoveFileOperator(
+ new File(removeStringQuote(ctx.stringLiteral(0).getText())),
+ new File(removeStringQuote(ctx.stringLiteral(1).getText())));
+ }
+
+ @Override
+ public Operator visitDeletePartition(DeletePartitionContext ctx) {
+ DeletePartitionOperator deletePartitionOperator = new DeletePartitionOperator(
+ SQLConstant.TOK_DELETE_PARTITION);
+ deletePartitionOperator.setStorageGroupName(parsePrefixPath(ctx.prefixPath()));
+ Set<Long> idSet = new HashSet<>();
+ for (TerminalNode terminalNode : ctx.INT()) {
+ idSet.add(Long.parseLong(terminalNode.getText()));
+ }
+ deletePartitionOperator.setPartitionIds(idSet);
+ return deletePartitionOperator;
+ }
+
+ @Override
+ public Operator visitCreateSnapshot(CreateSnapshotContext ctx) {
+ return new CreateSnapshotOperator(SQLConstant.TOK_CREATE_SCHEMA_SNAPSHOT);
+ }
+
+ @Override
+ public Operator visitSelectStatement(SelectStatementContext ctx) {
+ QueryOperator queryOp = new QueryOperator(SQLConstant.TOK_QUERY);
+ SelectOperator selectOp = (SelectOperator) visit(ctx.selectElements());
+ FromOperator fromOp = (FromOperator) visit(ctx.fromClause());
+ FilterOperator whereOp = (FilterOperator) visit(ctx.whereClause());
+ queryOp.setFromOperator(fromOp);
+ queryOp.setFilterOperator(whereOp.getChildren().get(0));
+ queryOp.setSelectOperator(selectOp);
+ return queryOp;
+ }
+
+ @Override
+ public Operator visitSelectElement(SelectElementContext ctx) {
+ SelectOperator selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
+ List<SqlBaseParser.SuffixPathOrConstantContext> suffixPathOrConstants = ctx.suffixPathOrConstant();
+ for (SqlBaseParser.SuffixPathOrConstantContext suffixPathOrConstant : suffixPathOrConstants) {
+ if (suffixPathOrConstant.suffixPath() != null) {
+ PartialPath path = parseSuffixPath(suffixPathOrConstant.suffixPath());
+ selectOp.addSelectPath(path);
+ } else {
+ PartialPath path = new PartialPath(new String[]{suffixPathOrConstant.SINGLE_QUOTE_STRING_LITERAL().getText()});
+ selectOp.addSelectPath(path);
+ }
+ }
+ return selectOp;
}
- @SuppressWarnings("squid:S3776") // Suppress high Cognitive Complexity warning
@Override
- public void enterGroupByFillClause(SqlBaseParser.GroupByFillClauseContext ctx) {
- super.enterGroupByFillClause(ctx);
+ public Operator visitFromClause(FromClauseContext ctx) {
+ FromOperator fromOp = new FromOperator(SQLConstant.TOK_FROM);
+ List<PrefixPathContext> prefixFromPaths = ctx.prefixPath();
+ for (PrefixPathContext prefixFromPath : prefixFromPaths) {
+ PartialPath path = parsePrefixPath(prefixFromPath);
+ fromOp.addPrefixTablePath(path);
+ }
+ return fromOp;
+ }
+
+ private int parseLimitClause(LimitClauseContext ctx) {
+ int limit;
+ try {
+ limit = Integer.parseInt(ctx.INT().getText());
+ } catch (NumberFormatException e) {
+ throw new SQLParserException("Out of range. LIMIT <N>: N should be Int32.");
+ }
+ if (limit <= 0) {
+ throw new SQLParserException("LIMIT <N>: N should be greater than 0.");
+ }
+ return limit;
+ }
+
+ private int parseSlimitClause(SlimitClauseContext ctx) {
+ int slimit;
+ try {
+ slimit = Integer.parseInt(ctx.INT().getText());
+ } catch (NumberFormatException e) {
+ throw new SQLParserException(
+ "Out of range. SLIMIT <SN>: SN should be Int32.");
+ }
+ if (slimit <= 0) {
+ throw new SQLParserException("SLIMIT <SN>: SN should be greater than 0.");
+ }
+ return slimit;
+ }
+
+ private void parseGroupByTimeClause(GroupByTimeClauseContext ctx, QueryOperator queryOp) {
+ queryOp.setGroupByTime(true);
+ queryOp.setLeftCRightO(ctx.timeInterval().LS_BRACKET() != null);
+ // parse timeUnit
+ queryOp.setUnit(parseDuration(ctx.DURATION(0).getText()));
+ queryOp.setSlidingStep(queryOp.getUnit());
+ // parse sliding step
+ if (ctx.DURATION().size() == 2) {
+ queryOp.setSlidingStep(parseDuration(ctx.DURATION(1).getText()));
+ if (queryOp.getSlidingStep() < queryOp.getUnit()) {
+ throw new SQLParserException(
+ "The third parameter sliding step shouldn't be smaller than the second parameter time interval.");
+ }
+ }
+
+ parseTimeInterval(ctx.timeInterval(), queryOp);
+
+ if (ctx.INT() != null) {
+ queryOp.setLevel(Integer.parseInt(ctx.INT().getText()));
+ }
+ }
+
+ private void parseGroupByFillClause(GroupByFillClauseContext ctx, QueryOperator queryOp) {
queryOp.setGroupByTime(true);
queryOp.setFill(true);
queryOp.setLeftCRightO(ctx.timeInterval().LS_BRACKET() != null);
@@ -860,7 +802,7 @@ public class LogicalGenerator extends SqlBaseBaseListener {
queryOp.setUnit(parseDuration(ctx.DURATION().getText()));
queryOp.setSlidingStep(queryOp.getUnit());
- parseTimeInterval(ctx.timeInterval());
+ parseTimeInterval(ctx.timeInterval(), queryOp);
List<TypeClauseContext> list = ctx.typeClause();
Map<TSDataType, IFill> fillTypes = new EnumMap<>(TSDataType.class);
@@ -901,80 +843,6 @@ public class LogicalGenerator extends SqlBaseBaseListener {
queryOp.setFillTypes(fillTypes);
}
- private void parseTimeInterval(TimeIntervalContext timeInterval) {
- long startTime;
- long endTime;
- if (timeInterval.timeValue(0).INT() != null) {
- startTime = Long.parseLong(timeInterval.timeValue(0).INT().getText());
- } else if (timeInterval.timeValue(0).dateExpression() != null) {
- startTime = parseDateExpression(timeInterval.timeValue(0).dateExpression());
- } else {
- startTime = parseTimeFormat(timeInterval.timeValue(0).dateFormat().getText());
- }
- if (timeInterval.timeValue(1).INT() != null) {
- endTime = Long.parseLong(timeInterval.timeValue(1).INT().getText());
- } else if (timeInterval.timeValue(1).dateExpression() != null) {
- endTime = parseDateExpression(timeInterval.timeValue(1).dateExpression());
- } else {
- endTime = parseTimeFormat(timeInterval.timeValue(1).dateFormat().getText());
- }
-
- queryOp.setStartTime(startTime);
- queryOp.setEndTime(endTime);
- if (startTime >= endTime) {
- throw new SQLParserException("start time should be smaller than endTime in GroupBy");
- }
- }
-
- @Override
- public void enterGroupByTimeClause(GroupByTimeClauseContext ctx) {
- super.enterGroupByTimeClause(ctx);
-
- queryOp.setGroupByTime(true);
- queryOp.setLeftCRightO(ctx.timeInterval().LS_BRACKET() != null);
- // parse timeUnit
- queryOp.setUnit(parseDuration(ctx.DURATION(0).getText()));
- queryOp.setSlidingStep(queryOp.getUnit());
- // parse sliding step
- if (ctx.DURATION().size() == 2) {
- queryOp.setSlidingStep(parseDuration(ctx.DURATION(1).getText()));
- if (queryOp.getSlidingStep() < queryOp.getUnit()) {
- throw new SQLParserException(
- "The third parameter sliding step shouldn't be smaller than the second parameter time interval.");
- }
- }
-
- parseTimeInterval(ctx.timeInterval());
-
- if (ctx.INT() != null) {
- queryOp.setLevel(Integer.parseInt(ctx.INT().getText()));
- }
- }
-
- @Override
- public void enterGroupByLevelClause(SqlBaseParser.GroupByLevelClauseContext ctx) {
- super.enterGroupByLevelClause(ctx);
- queryOp.setGroupByLevel(true);
-
- queryOp.setLevel(Integer.parseInt(ctx.INT().getText()));
- }
-
- @Override
- public void enterFillClause(FillClauseContext ctx) {
- super.enterFillClause(ctx);
- FilterOperator filterOperator = queryOp.getFilterOperator();
- if (!filterOperator.isLeaf() || filterOperator.getTokenIntType() != SQLConstant.EQUAL) {
- throw new SQLParserException("Only \"=\" can be used in fill function");
- }
- List<TypeClauseContext> list = ctx.typeClause();
- Map<TSDataType, IFill> fillTypes = new EnumMap<>(TSDataType.class);
- for (TypeClauseContext typeClause : list) {
- parseTypeClause(typeClause, fillTypes);
- }
- queryOp.setFill(true);
- queryOp.setFillTypes(fillTypes);
- }
-
private void parseTypeClause(TypeClauseContext ctx, Map<TSDataType, IFill> fillTypes) {
TSDataType dataType = parseType(ctx.dataType().getText());
if (ctx.linearClause() != null && dataType == TSDataType.TEXT) {
@@ -1009,12 +877,6 @@ public class LogicalGenerator extends SqlBaseBaseListener {
}
}
- @Override
- public void enterAlignByDeviceClause(AlignByDeviceClauseContext ctx) {
- super.enterAlignByDeviceClause(ctx);
- queryOp.setAlignByDevice(true);
- }
-
/**
* parse datatype node.
*/
@@ -1038,356 +900,264 @@ public class LogicalGenerator extends SqlBaseBaseListener {
}
}
- @Override
- public void enterLimitClause(LimitClauseContext ctx) {
- super.enterLimitClause(ctx);
- int limit;
- try {
- limit = Integer.parseInt(ctx.INT().getText());
- } catch (NumberFormatException e) {
- throw new SQLParserException("Out of range. LIMIT <N>: N should be Int32.");
- }
- if (limit <= 0) {
- throw new SQLParserException("LIMIT <N>: N should be greater than 0.");
- }
- if (initializedOperator instanceof ShowTimeSeriesOperator) {
- ((ShowTimeSeriesOperator) initializedOperator).setLimit(limit);
- } else {
- queryOp.setRowLimit(limit);
- }
- }
-
- @Override
- public void enterOffsetClause(OffsetClauseContext ctx) {
- super.enterOffsetClause(ctx);
- int offset;
- try {
- offset = Integer.parseInt(ctx.INT().getText());
- } catch (NumberFormatException e) {
- throw new SQLParserException(
- "Out of range. OFFSET <OFFSETValue>: OFFSETValue should be Int32.");
- }
- if (offset < 0) {
- throw new SQLParserException("OFFSET <OFFSETValue>: OFFSETValue should >= 0.");
- }
- if (initializedOperator instanceof ShowTimeSeriesOperator) {
- ((ShowTimeSeriesOperator) initializedOperator).setOffset(offset);
- } else {
- queryOp.setRowOffset(offset);
- }
- }
-
- @Override
- public void enterOrderByTimeClause(OrderByTimeClauseContext ctx) {
- super.enterOrderByTimeClause(ctx);
+ private void parseOrderByTimeClause(OrderByTimeClauseContext ctx, QueryOperator queryOp) {
queryOp.setColumn(ctx.TIME().getText());
if (ctx.DESC() != null) {
queryOp.setAscending(false);
}
}
- @Override
- public void enterSlimitClause(SlimitClauseContext ctx) {
- super.enterSlimitClause(ctx);
- int slimit;
- try {
- slimit = Integer.parseInt(ctx.INT().getText());
- } catch (NumberFormatException e) {
- throw new SQLParserException(
- "Out of range. SLIMIT <SN>: SN should be Int32.");
- }
- if (slimit <= 0) {
- throw new SQLParserException("SLIMIT <SN>: SN should be greater than 0.");
- }
- queryOp.setSeriesLimit(slimit);
+ private void parseAlignByDeviceClause(QueryOperator queryOp) {
+ queryOp.setAlignByDevice(true);
}
- @Override
- public void enterSoffsetClause(SoffsetClauseContext ctx) {
- super.enterSoffsetClause(ctx);
- int soffset;
- try {
- soffset = Integer.parseInt(ctx.INT().getText());
- } catch (NumberFormatException e) {
- throw new SQLParserException(
- "Out of range. SOFFSET <SOFFSETValue>: SOFFSETValue should be Int32.");
- }
- if (soffset < 0) {
- throw new SQLParserException(
- "SOFFSET <SOFFSETValue>: SOFFSETValue should >= 0.");
- }
- queryOp.setSeriesOffset(soffset);
- }
-
- @Override
- public void enterInsertColumnSpec(InsertColumnSpecContext ctx) {
- super.enterInsertColumnSpec(ctx);
- List<NodeNameWithoutStarContext> nodeNamesWithoutStar = ctx.nodeNameWithoutStar();
- List<String> measurementList = new ArrayList<>();
- for (NodeNameWithoutStarContext nodeNameWithoutStar : nodeNamesWithoutStar) {
- String measurement = nodeNameWithoutStar.getText();
- measurementList.add(measurement);
- }
- insertOp.setMeasurementList(measurementList.toArray(new String[0]));
+ private void parseDisableAlign(QueryOperator queryOp) {
+ queryOp.setAlignByTime(false);
}
- @Override
- public void enterInsertValuesSpec(InsertValuesSpecContext ctx) {
- super.enterInsertValuesSpec(ctx);
- long timestamp;
- if (ctx.dateFormat() != null) {
- timestamp = parseTimeFormat(ctx.dateFormat().getText());
+ private void parseTimeInterval(TimeIntervalContext timeInterval, QueryOperator queryOp) {
+ long startTime;
+ long endTime;
+ if (timeInterval.timeValue(0).INT() != null) {
+ startTime = Long.parseLong(timeInterval.timeValue(0).INT().getText());
+ } else if (timeInterval.timeValue(0).dateExpression() != null) {
+ startTime = parseDateExpression(timeInterval.timeValue(0).dateExpression());
} else {
- timestamp = Long.parseLong(ctx.INT().getText());
+ startTime = parseTimeFormat(timeInterval.timeValue(0).dateFormat().getText());
}
- insertOp.setTime(timestamp);
- List<String> valueList = new ArrayList<>();
- List<ConstantContext> values = ctx.constant();
- for (ConstantContext value : values) {
- valueList.add(value.getText());
+ if (timeInterval.timeValue(1).INT() != null) {
+ endTime = Long.parseLong(timeInterval.timeValue(1).INT().getText());
+ } else if (timeInterval.timeValue(1).dateExpression() != null) {
+ endTime = parseDateExpression(timeInterval.timeValue(1).dateExpression());
+ } else {
+ endTime = parseTimeFormat(timeInterval.timeValue(1).dateFormat().getText());
}
- insertOp.setValueList(valueList.toArray(new String[0]));
- initializedOperator = insertOp;
- }
- private PartialPath parseFullPath(FullPathContext ctx) {
- List<NodeNameWithoutStarContext> nodeNamesWithoutStar = ctx.nodeNameWithoutStar();
- String[] path = new String[nodeNamesWithoutStar.size() + 1];
- int i = 0;
- if (ctx.ROOT() != null) {
- path[0] = ctx.ROOT().getText();
- }
- for (NodeNameWithoutStarContext nodeNameWithoutStar : nodeNamesWithoutStar) {
- i++;
- path[i] = nodeNameWithoutStar.getText();
+ queryOp.setStartTime(startTime);
+ queryOp.setEndTime(endTime);
+ if (startTime >= endTime) {
+ throw new SQLParserException("start time should be smaller than endTime in GroupBy");
}
- return new PartialPath(path);
}
- @Override
- public void enterAttributeClauses(AttributeClausesContext ctx) {
- super.enterAttributeClauses(ctx);
- final String dataType = ctx.dataType().getChild(0).getText().toUpperCase();
- final TSDataType tsDataType = TSDataType.valueOf(dataType);
- createTimeSeriesOperator.setDataType(tsDataType);
-
- final IoTDBDescriptor ioTDBDescriptor = IoTDBDescriptor.getInstance();
- TSEncoding encoding = ioTDBDescriptor.getDefualtEncodingByType(tsDataType);
- if (Objects.nonNull(ctx.encoding())) {
- String encodingString = ctx.encoding().getChild(0).getText().toUpperCase();
- encoding = TSEncoding.valueOf(encodingString);
- }
- createTimeSeriesOperator.setEncoding(encoding);
-
- CompressionType compressor;
- List<PropertyContext> properties = ctx.property();
- if (ctx.compressor() != null) {
- compressor = CompressionType.valueOf(ctx.compressor().getText().toUpperCase());
+ private void parseShowWhereClause(ShowWhereClauseContext ctx, ShowTimeSeriesOperator operator) {
+ PropertyValueContext propertyValueContext;
+ if (ctx.containsExpression() != null) {
+ operator.setContains(true);
+ propertyValueContext = ctx.containsExpression().propertyValue();
+ operator.setKey(ctx.containsExpression().ID().getText());
} else {
- compressor = TSFileDescriptor.getInstance().getConfig().getCompressor();
+ operator.setContains(false);
+ propertyValueContext = ctx.property().propertyValue();
+ operator.setKey(ctx.property().ID().getText());
}
- Map<String, String> props = null;
- if (ctx.property(0) != null) {
- props = new HashMap<>(properties.size());
- for (PropertyContext property : properties) {
- props.put(property.ID().getText().toLowerCase(),
- property.propertyValue().getText().toLowerCase());
- }
+ String value;
+ if (propertyValueContext.stringLiteral() != null) {
+ value = removeStringQuote(propertyValueContext.getText());
+ } else {
+ value = propertyValueContext.getText();
}
- createTimeSeriesOperator.setCompressor(compressor);
- createTimeSeriesOperator.setProps(props);
- initializedOperator = createTimeSeriesOperator;
+ operator.setValue(value);
}
- @Override
- public void enterAliasClause(SqlBaseParser.AliasClauseContext ctx) {
- super.enterAliasClause(ctx);
- if (alterTimeSeriesOperator != null && ctx.ID() != null) {
- alterTimeSeriesOperator.setAlias(ctx.ID().getText());
+ private String[] parsePrivilege(PrivilegesContext ctx) {
+ List<StringLiteralContext> privilegeList = ctx.stringLiteral();
+ List<String> privileges = new ArrayList<>();
+ for (StringLiteralContext privilege : privilegeList) {
+ privileges.add(removeStringQuote(privilege.getText()));
}
+ return privileges.toArray(new String[0]);
}
+ /**
+ * for delete command, time should only have an end time.
+ *
+ * @param operator delete logical plan
+ */
+ private Pair<Long, Long> parseDeleteTimeInterval(DeleteDataOperator operator) {
+ FilterOperator filterOperator = operator.getFilterOperator();
+ if (!filterOperator.isLeaf() && filterOperator.getTokenIntType() != SQLConstant.KW_AND) {
+ throw new SQLParserException(
+ DELETE_RANGE_ERROR_MSG);
+ }
- @Override
- public void enterAttributeClause(AttributeClauseContext ctx) {
- super.enterAttributeClause(ctx);
- Map<String, String> attributes = extractMap(ctx.property(), ctx.property(0));
- if (createTimeSeriesOperator != null) {
- createTimeSeriesOperator.setAttributes(attributes);
- } else if (alterTimeSeriesOperator != null) {
- alterTimeSeriesOperator.setAttributesMap(attributes);
+ if (filterOperator.isLeaf()) {
+ return calcOperatorInterval(filterOperator);
}
- }
- @Override
- public void enterTagClause(TagClauseContext ctx) {
- super.enterTagClause(ctx);
- Map<String, String> tags = extractMap(ctx.property(), ctx.property(0));
- if (createTimeSeriesOperator != null) {
- createTimeSeriesOperator.setTags(tags);
- } else if (alterTimeSeriesOperator != null) {
- alterTimeSeriesOperator.setTagsMap(tags);
+ List<FilterOperator> children = filterOperator.getChildren();
+ FilterOperator lOperator = children.get(0);
+ FilterOperator rOperator = children.get(1);
+ if (!lOperator.isLeaf() || !rOperator.isLeaf()) {
+ throw new SQLParserException(
+ DELETE_RANGE_ERROR_MSG);
}
- }
- private Map<String, String> extractMap(List<PropertyContext> property2,
- PropertyContext property3) {
- String value;
- Map<String, String> tags = new HashMap<>(property2.size());
- if (property3 != null) {
- for (PropertyContext property : property2) {
- if (property.propertyValue().stringLiteral() != null) {
- value = removeStringQuote(property.propertyValue().getText());
- } else {
- value = property.propertyValue().getText();
- }
- tags.put(property.ID().getText(), value);
- }
+ Pair<Long, Long> leftOpInterval = calcOperatorInterval(lOperator);
+ Pair<Long, Long> rightOpInterval = calcOperatorInterval(rOperator);
+ Pair<Long, Long> parsedInterval = new Pair<>(
+ Math.max(leftOpInterval.left, rightOpInterval.left),
+ Math.min(leftOpInterval.right, rightOpInterval.right));
+ if (parsedInterval.left > parsedInterval.right) {
+ throw new SQLParserException(
+ "Invalid delete range: [" + parsedInterval.left + ", " + parsedInterval.right + "]");
}
- return tags;
+ return parsedInterval;
}
- @Override
- public void enterInsertStatement(InsertStatementContext ctx) {
- super.enterInsertStatement(ctx);
- insertOp = new InsertOperator(SQLConstant.TOK_INSERT);
- selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
- operatorType = SQLConstant.TOK_INSERT;
- selectOp.addSelectPath(parsePrefixPath(ctx.prefixPath()));
- insertOp.setSelectOperator(selectOp);
+ private Pair<Long, Long> calcOperatorInterval(FilterOperator filterOperator) {
+ long time = Long.parseLong(((BasicFunctionOperator) filterOperator).getValue());
+ switch (filterOperator.getTokenIntType()) {
+ case SQLConstant.LESSTHAN:
+ return new Pair<>(Long.MIN_VALUE, time - 1);
+ case SQLConstant.LESSTHANOREQUALTO:
+ return new Pair<>(Long.MIN_VALUE, time);
+ case SQLConstant.GREATERTHAN:
+ return new Pair<>(time + 1, Long.MAX_VALUE);
+ case SQLConstant.GREATERTHANOREQUALTO:
+ return new Pair<>(time, Long.MAX_VALUE);
+ case SQLConstant.EQUAL:
+ return new Pair<>(time, time);
+ default:
+ throw new SQLParserException(
+ DELETE_RANGE_ERROR_MSG);
+ }
}
- @Override
- public void enterUpdateStatement(UpdateStatementContext ctx) {
- super.enterUpdateStatement(ctx);
- updateOp = new UpdateOperator(SQLConstant.TOK_UPDATE);
- FromOperator fromOp = new FromOperator(SQLConstant.TOK_FROM);
- fromOp.addPrefixTablePath(parsePrefixPath(ctx.prefixPath()));
- selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
- operatorType = SQLConstant.TOK_UPDATE;
- initializedOperator = updateOp;
- }
- @Override
- public void enterSelectStatement(SelectStatementContext ctx) {
- super.enterSelectStatement(ctx);
- operatorType = SQLConstant.TOK_QUERY;
- queryOp = new QueryOperator(SQLConstant.TOK_QUERY);
- initializedOperator = queryOp;
- }
- @Override
- public void enterFromClause(FromClauseContext ctx) {
- super.enterFromClause(ctx);
- FromOperator fromOp = new FromOperator(SQLConstant.TOK_FROM);
- List<PrefixPathContext> prefixFromPaths = ctx.prefixPath();
- for (PrefixPathContext prefixFromPath : prefixFromPaths) {
- PartialPath path = parsePrefixPath(prefixFromPath);
- fromOp.addPrefixTablePath(path);
- }
- queryOp.setFromOperator(fromOp);
- }
@Override
- public void enterFunctionElement(FunctionElementContext ctx) {
- super.enterFunctionElement(ctx);
- selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
- List<FunctionCallContext> functionCallContextList = ctx.functionCall();
- for (FunctionCallContext functionCallContext : functionCallContextList) {
- PartialPath path = parseSuffixPath(functionCallContext.suffixPath());
- selectOp.addClusterPath(path, functionCallContext.functionName().getText());
- }
- queryOp.setSelectOperator(selectOp);
+ public Operator visitWhereClause(WhereClauseContext ctx) {
+ FilterOperator whereOp = new FilterOperator(SQLConstant.TOK_WHERE);
+ whereOp.addChildOperator(parseOrExpression(ctx.orExpression()));
+ return whereOp;
}
- @Override
- public void enterSelectElement(SelectElementContext ctx) {
- super.enterSelectElement(ctx);
- selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
- List<SqlBaseParser.SuffixPathOrConstantContext> suffixPathOrConstants = ctx.suffixPathOrConstant();
- for (SqlBaseParser.SuffixPathOrConstantContext suffixPathOrConstant : suffixPathOrConstants) {
- if (suffixPathOrConstant.suffixPath() != null) {
- PartialPath path = parseSuffixPath(suffixPathOrConstant.suffixPath());
- selectOp.addSelectPath(path);
- } else {
- PartialPath path = new PartialPath(new String[]{suffixPathOrConstant.SINGLE_QUOTE_STRING_LITERAL().getText()});
- selectOp.addSelectPath(path);
+ private FilterOperator parseOrExpression(OrExpressionContext ctx) {
+ if (ctx.andExpression().size() == 1) {
+ return parseAndExpression(ctx.andExpression(0));
+ }
+ FilterOperator binaryOp = new FilterOperator(SQLConstant.KW_OR);
+ if (ctx.andExpression().size() > 2) {
+ binaryOp.addChildOperator(parseAndExpression(ctx.andExpression(0)));
+ binaryOp.addChildOperator(parseAndExpression(ctx.andExpression(1)));
+ for (int i = 2; i < ctx.andExpression().size(); i++) {
+ FilterOperator op = new FilterOperator(SQLConstant.KW_OR);
+ op.addChildOperator(binaryOp);
+ op.addChildOperator(parseAndExpression(ctx.andExpression(i)));
+ binaryOp = op;
+ }
+ } else {
+ for (AndExpressionContext andExpressionContext : ctx.andExpression()) {
+ binaryOp.addChildOperator(parseAndExpression(andExpressionContext));
}
}
- queryOp.setSelectOperator(selectOp);
+ return binaryOp;
}
- @Override
- public void enterLastElement(SqlBaseParser.LastElementContext ctx) {
- super.enterLastElement(ctx);
- selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
- selectOp.setLastQuery();
- LastClauseContext lastClauseContext = ctx.lastClause();
- if (lastClauseContext.asClause().size() != 0) {
- parseAsClause(lastClauseContext.asClause());
+ private FilterOperator parseAndExpression(AndExpressionContext ctx) {
+ if (ctx.predicate().size() == 1) {
+ return parsePredicate(ctx.predicate(0));
+ }
+ FilterOperator binaryOp = new FilterOperator(SQLConstant.KW_AND);
+ int size = ctx.predicate().size();
+ if (size > 2) {
+ binaryOp.addChildOperator(parsePredicate(ctx.predicate(0)));
+ binaryOp.addChildOperator(parsePredicate(ctx.predicate(1)));
+ for (int i = 2; i < size; i++) {
+ FilterOperator op = new FilterOperator(SQLConstant.KW_AND);
+ op.addChildOperator(binaryOp);
+ op.addChildOperator(parsePredicate(ctx.predicate(i)));
+ binaryOp = op;
+ }
} else {
- List<SuffixPathContext> suffixPaths = lastClauseContext.suffixPath();
- for (SuffixPathContext suffixPath : suffixPaths) {
- PartialPath path = parseSuffixPath(suffixPath);
- selectOp.addSelectPath(path);
+ for (PredicateContext predicateContext : ctx.predicate()) {
+ binaryOp.addChildOperator(parsePredicate(predicateContext));
}
}
- queryOp.setSelectOperator(selectOp);
- }
-
- @Override
- public void enterAsElement(AsElementContext ctx) {
- super.enterAsElement(ctx);
- selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
- parseAsClause(ctx.asClause());
- queryOp.setSelectOperator(selectOp);
+ return binaryOp;
}
- public void parseAsClause(List<AsClauseContext> asClauseContexts) {
- for (AsClauseContext asClauseContext : asClauseContexts) {
- PartialPath path = parseSuffixPath(asClauseContext.suffixPath());
- if (asClauseContext.ID() != null) {
- path.setTsAlias(asClauseContext.ID().toString());
+ @SuppressWarnings("squid:S3776") // Suppress high Cognitive Complexity warning
+ private FilterOperator parsePredicate(PredicateContext ctx) {
+ if (ctx.OPERATOR_NOT() != null) {
+ FilterOperator notOp = new FilterOperator(SQLConstant.KW_NOT);
+ notOp.addChildOperator(parseOrExpression(ctx.orExpression()));
+ return notOp;
+ } else if (ctx.LR_BRACKET() != null && ctx.OPERATOR_NOT() == null) {
+ return parseOrExpression(ctx.orExpression());
+ } else {
+ PartialPath path = null;
+ if (ctx.TIME() != null || ctx.TIMESTAMP() != null) {
+ path = new PartialPath(SQLConstant.getSingleTimeArray());
+ }
+ if (ctx.fullPath() != null) {
+ path = parseFullPath(ctx.fullPath());
+ }
+ if (ctx.suffixPath() != null) {
+ path = parseSuffixPath(ctx.suffixPath());
+ }
+ if (path == null) {
+ throw new SQLParserException("Path is null, please check the sql.");
+ }
+ if (ctx.inClause() != null) {
+ return parseInOperator(ctx.inClause(), path);
+ } else {
+ return parseBasicFunctionOperator(ctx, path);
}
- selectOp.addSelectPath(path);
}
}
- @Override
- public void enterFunctionAsElement(FunctionAsElementContext ctx) {
- super.enterFunctionAsElement(ctx);
- selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
- List<FunctionAsClauseContext> functionAsClauseContexts = ctx.functionAsClause();
- for (FunctionAsClauseContext functionAsClauseContext : functionAsClauseContexts) {
- FunctionCallContext functionCallContext = functionAsClauseContext.functionCall();
- PartialPath path = parseSuffixPath(functionCallContext.suffixPath());
- if (functionAsClauseContext.ID() != null) {
- path.setTsAlias(functionAsClauseContext.ID().toString());
+ private FilterOperator parseInOperator(InClauseContext ctx, PartialPath path) {
+ Set<String> values = new HashSet<>();
+ boolean not = ctx.OPERATOR_NOT() != null;
+ for (ConstantContext constant : ctx.constant()) {
+ if (constant.dateExpression() != null) {
+ if (!path.equals(TIME_PATH)) {
+ throw new SQLParserException(path.getFullPath(), "Date can only be used to time");
+ }
+ values.add(Long.toString(parseDateExpression(constant.dateExpression())));
+ } else {
+ values.add(constant.getText());
}
- selectOp.addClusterPath(path, functionCallContext.functionName().getText());
}
- queryOp.setSelectOperator(selectOp);
+ return new InOperator(ctx.OPERATOR_IN().getSymbol().getType(), path, not, values);
}
- @Override
- public void enterSetCol(SetColContext ctx) {
- super.enterSetCol(ctx);
- selectOp.addSelectPath(parseSuffixPath(ctx.suffixPath()));
- updateOp.setSelectOperator(selectOp);
- updateOp.setValue(ctx.constant().getText());
+ private FilterOperator parseBasicFunctionOperator(PredicateContext ctx, PartialPath path) {
+ BasicFunctionOperator basic;
+ if (ctx.constant().dateExpression() != null) {
+ if (!path.equals(TIME_PATH)) {
+ throw new SQLParserException(path.getFullPath(), "Date can only be used to time");
+ }
+ basic = new BasicFunctionOperator(ctx.comparisonOperator().type.getType(), path,
+ Long.toString(parseDateExpression(ctx.constant().dateExpression())));
+ } else {
+ basic = new BasicFunctionOperator(ctx.comparisonOperator().type.getType(), path,
+ ctx.constant().getText());
+ }
+ return basic;
}
-
- private PartialPath parsePrefixPath(PrefixPathContext ctx) {
- List<NodeNameContext> nodeNames = ctx.nodeName();
- String[] path = new String[nodeNames.size() + 1];
- path[0] = ctx.ROOT().getText();
- for (int i = 0; i < nodeNames.size(); i++) {
- path[i + 1] = nodeNames.get(i).getText();
+ /**
+ * parse time expression, which is addition and subtraction expression of duration time, now() or
+ * DataTimeFormat time. <p> eg. now() + 1d - 2h </p>
+ */
+ private Long parseDateExpression(DateExpressionContext ctx) {
+ long time;
+ time = parseTimeFormat(ctx.getChild(0).getText());
+ for (int i = 1; i < ctx.getChildCount(); i = i + 2) {
+ if (ctx.getChild(i).getText().equals("+")) {
+ time += parseDuration(ctx.getChild(i + 1).getText());
+ } else {
+ time -= parseDuration(ctx.getChild(i + 1).getText());
+ }
}
- return new PartialPath(path);
+ return time;
}
+
/**
* parse duration to time value.
*
@@ -1422,189 +1192,164 @@ public class LogicalGenerator extends SqlBaseBaseListener {
return total;
}
- @Override
- public void enterWhereClause(WhereClauseContext ctx) {
- super.enterWhereClause(ctx);
- FilterOperator whereOp = new FilterOperator(SQLConstant.TOK_WHERE);
- whereOp.addChildOperator(parseOrExpression(ctx.orExpression()));
- switch (operatorType) {
- case SQLConstant.TOK_DELETE:
- deleteDataOp.setFilterOperator(whereOp.getChildren().get(0));
- Pair<Long, Long> timeInterval = parseDeleteTimeInterval(deleteDataOp);
- deleteDataOp.setStartTime(timeInterval.left);
- deleteDataOp.setEndTime(timeInterval.right);
- break;
- case SQLConstant.TOK_QUERY:
- queryOp.setFilterOperator(whereOp.getChildren().get(0));
- break;
- case SQLConstant.TOK_UPDATE:
- updateOp.setFilterOperator(whereOp.getChildren().get(0));
- break;
- default:
- throw new SQLParserException("Where only support select, delete, update.");
- }
+ private void parseSetCol(SetColContext ctx, SelectOperator selectOp, UpdateOperator updateOp) {
+ selectOp.addSelectPath(parseSuffixPath(ctx.suffixPath()));
+ updateOp.setValue(ctx.constant().getText());
}
- @Override
- public void enterShowWhereClause(ShowWhereClauseContext ctx) {
- super.enterShowWhereClause(ctx);
-
- ShowTimeSeriesOperator operator = (ShowTimeSeriesOperator) initializedOperator;
- PropertyValueContext propertyValueContext;
- if (ctx.containsExpression() != null) {
- operator.setContains(true);
- propertyValueContext = ctx.containsExpression().propertyValue();
- operator.setKey(ctx.containsExpression().ID().getText());
- } else {
- operator.setContains(false);
- propertyValueContext = ctx.property().propertyValue();
- operator.setKey(ctx.property().ID().getText());
- }
- String value;
- if (propertyValueContext.stringLiteral() != null) {
- value = removeStringQuote(propertyValueContext.getText());
- } else {
- value = propertyValueContext.getText();
+ private PartialPath parseSuffixPath(SuffixPathContext ctx) {
+ List<NodeNameContext> nodeNames = ctx.nodeName();
+ String[] path = new String[nodeNames.size()];
+ for (int i = 0; i < nodeNames.size(); i++) {
+ path[i] = nodeNames.get(i).getText();
}
- operator.setValue(value);
+ return new PartialPath(path);
}
- private FilterOperator parseOrExpression(OrExpressionContext ctx) {
- if (ctx.andExpression().size() == 1) {
- return parseAndExpression(ctx.andExpression(0));
- }
- FilterOperator binaryOp = new FilterOperator(SQLConstant.KW_OR);
- if (ctx.andExpression().size() > 2) {
- binaryOp.addChildOperator(parseAndExpression(ctx.andExpression(0)));
- binaryOp.addChildOperator(parseAndExpression(ctx.andExpression(1)));
- for (int i = 2; i < ctx.andExpression().size(); i++) {
- FilterOperator op = new FilterOperator(SQLConstant.KW_OR);
- op.addChildOperator(binaryOp);
- op.addChildOperator(parseAndExpression(ctx.andExpression(i)));
- binaryOp = op;
- }
- } else {
- for (AndExpressionContext andExpressionContext : ctx.andExpression()) {
- binaryOp.addChildOperator(parseAndExpression(andExpressionContext));
- }
+ private void parseInsertColumnSpec(InsertColumnSpecContext ctx, InsertOperator insertOp) {
+ List<NodeNameWithoutStarContext> nodeNamesWithoutStar = ctx.nodeNameWithoutStar();
+ List<String> measurementList = new ArrayList<>();
+ for (NodeNameWithoutStarContext nodeNameWithoutStar : nodeNamesWithoutStar) {
+ String measurement = nodeNameWithoutStar.getText();
+ measurementList.add(measurement);
}
- return binaryOp;
+ insertOp.setMeasurementList(measurementList.toArray(new String[0]));
}
- private FilterOperator parseAndExpression(AndExpressionContext ctx) {
- if (ctx.predicate().size() == 1) {
- return parsePredicate(ctx.predicate(0));
- }
- FilterOperator binaryOp = new FilterOperator(SQLConstant.KW_AND);
- int size = ctx.predicate().size();
- if (size > 2) {
- binaryOp.addChildOperator(parsePredicate(ctx.predicate(0)));
- binaryOp.addChildOperator(parsePredicate(ctx.predicate(1)));
- for (int i = 2; i < size; i++) {
- FilterOperator op = new FilterOperator(SQLConstant.KW_AND);
- op.addChildOperator(binaryOp);
- op.addChildOperator(parsePredicate(ctx.predicate(i)));
- binaryOp = op;
- }
+ private void parseInsertValuesSpec(InsertValuesSpecContext ctx, InsertOperator insertOp) {
+ long timestamp;
+ if (ctx.dateFormat() != null) {
+ timestamp = parseTimeFormat(ctx.dateFormat().getText());
} else {
- for (PredicateContext predicateContext : ctx.predicate()) {
- binaryOp.addChildOperator(parsePredicate(predicateContext));
- }
+ timestamp = Long.parseLong(ctx.INT().getText());
}
- return binaryOp;
+ insertOp.setTime(timestamp);
+ List<String> valueList = new ArrayList<>();
+ List<ConstantContext> values = ctx.constant();
+ for (ConstantContext value : values) {
+ valueList.add(value.getText());
+ }
+ insertOp.setValueList(valueList.toArray(new String[0]));
}
- @SuppressWarnings("squid:S3776") // Suppress high Cognitive Complexity warning
- private FilterOperator parsePredicate(PredicateContext ctx) {
- if (ctx.OPERATOR_NOT() != null) {
- FilterOperator notOp = new FilterOperator(SQLConstant.KW_NOT);
- notOp.addChildOperator(parseOrExpression(ctx.orExpression()));
- return notOp;
- } else if (ctx.LR_BRACKET() != null && ctx.OPERATOR_NOT() == null) {
- return parseOrExpression(ctx.orExpression());
- } else {
- PartialPath path = null;
- if (ctx.TIME() != null || ctx.TIMESTAMP() != null) {
- path = new PartialPath(SQLConstant.getSingleTimeArray());
- }
- if (ctx.fullPath() != null) {
- path = parseFullPath(ctx.fullPath());
- }
- if (ctx.suffixPath() != null) {
- path = parseSuffixPath(ctx.suffixPath());
- }
- if (path == null) {
- throw new SQLParserException("Path is null, please check the sql.");
- }
- if (ctx.inClause() != null) {
- return parseInOperator(ctx.inClause(), path);
- } else {
- return parseBasicFunctionOperator(ctx, path);
+
+
+ private void parseAlterClause(AlterClauseContext ctx, AlterTimeSeriesOperator alterTimeSeriesOperator) {
+ Map<String, String> alterMap = new HashMap<>();
+ // rename
+ if (ctx.RENAME() != null) {
+ alterTimeSeriesOperator.setAlterType(AlterType.RENAME);
+ alterMap.put(ctx.beforeName.getText(), ctx.currentName.getText());
+ } else if (ctx.SET() != null) {
+ // set
+ alterTimeSeriesOperator.setAlterType(AlterType.SET);
+ setMap(ctx, alterMap);
+ } else if (ctx.DROP() != null) {
+ // drop
+ alterTimeSeriesOperator.setAlterType(AlterType.DROP);
+ for (TerminalNode dropId : ctx.ID()) {
+ alterMap.put(dropId.getText(), null);
}
+ } else if (ctx.TAGS() != null) {
+ // add tag
+ alterTimeSeriesOperator.setAlterType(AlterType.ADD_TAGS);
+ setMap(ctx, alterMap);
+ } else if (ctx.ATTRIBUTES() != null) {
+ // add attribute
+ alterTimeSeriesOperator.setAlterType(AlterType.ADD_ATTRIBUTES);
+ setMap(ctx, alterMap);
+ } else {
+ // upsert
+ alterTimeSeriesOperator.setAlterType(AlterType.UPSERT);
}
+ alterTimeSeriesOperator.setAlterMap(alterMap);
}
- private FilterOperator parseInOperator(InClauseContext ctx, PartialPath path) {
- Set<String> values = new HashSet<>();
- boolean not = ctx.OPERATOR_NOT() != null;
- for (ConstantContext constant : ctx.constant()) {
- if (constant.dateExpression() != null) {
- if (!path.equals(TIME_PATH)) {
- throw new SQLParserException(path.getFullPath(), "Date can only be used to time");
+ private void setMap(SqlBaseParser.AlterClauseContext ctx, Map<String, String> alterMap) {
+ List<PropertyContext> tagsList = ctx.property();
+ if (ctx.property(0) != null) {
+ for (PropertyContext property : tagsList) {
+ String value;
+ if (property.propertyValue().stringLiteral() != null) {
+ value = removeStringQuote(property.propertyValue().getText());
+ } else {
+ value = property.propertyValue().getText();
}
- values.add(Long.toString(parseDateExpression(constant.dateExpression())));
- } else {
- values.add(constant.getText());
+ alterMap.put(property.ID().getText(), value);
}
}
- return new InOperator(ctx.OPERATOR_IN().getSymbol().getType(), path, not, values);
}
- private FilterOperator parseBasicFunctionOperator(PredicateContext ctx, PartialPath path) {
- BasicFunctionOperator basic;
- if (ctx.constant().dateExpression() != null) {
- if (!path.equals(TIME_PATH)) {
- throw new SQLParserException(path.getFullPath(), "Date can only be used to time");
- }
- basic = new BasicFunctionOperator(ctx.comparisonOperator().type.getType(), path,
- Long.toString(parseDateExpression(ctx.constant().dateExpression())));
+ private String removeStringQuote(String src) {
+ if (src.charAt(0) == '\'' && src.charAt(src.length() - 1) == '\'') {
+ return src.substring(1, src.length() - 1);
+ } else if (src.charAt(0) == '\"' && src.charAt(src.length() - 1) == '\"') {
+ return src.substring(1, src.length() - 1);
} else {
- basic = new BasicFunctionOperator(ctx.comparisonOperator().type.getType(), path,
- ctx.constant().getText());
+ throw new SQLParserException("error format for string with quote:" + src);
}
- return basic;
}
- private PartialPath parseSuffixPath(SuffixPathContext ctx) {
+ private PartialPath parsePrefixPath(PrefixPathContext ctx) {
List<NodeNameContext> nodeNames = ctx.nodeName();
- String[] path = new String[nodeNames.size()];
+ String[] path = new String[nodeNames.size() + 1];
+ path[0] = ctx.ROOT().getText();
for (int i = 0; i < nodeNames.size(); i++) {
- path[i] = nodeNames.get(i).getText();
+ path[i + 1] = nodeNames.get(i).getText();
}
return new PartialPath(path);
}
- /**
- * parse time expression, which is addition and subtraction expression of duration time, now() or
- * DataTimeFormat time. <p> eg. now() + 1d - 2h </p>
- */
- private Long parseDateExpression(DateExpressionContext ctx) {
- long time;
- time = parseTimeFormat(ctx.getChild(0).getText());
- for (int i = 1; i < ctx.getChildCount(); i = i + 2) {
- if (ctx.getChild(i).getText().equals("+")) {
- time += parseDuration(ctx.getChild(i + 1).getText());
- } else {
- time -= parseDuration(ctx.getChild(i + 1).getText());
+ public void parseAttributeClauses(AttributeClausesContext ctx, CreateTimeSeriesOperator createTimeSeriesOperator) {
+ final String dataType = ctx.dataType().getChild(0).getText().toUpperCase();
+ final TSDataType tsDataType = TSDataType.valueOf(dataType);
+ createTimeSeriesOperator.setDataType(tsDataType);
+
+ final IoTDBDescriptor ioTDBDescriptor = IoTDBDescriptor.getInstance();
+ TSEncoding encoding = ioTDBDescriptor.getDefualtEncodingByType(tsDataType);
+ if (Objects.nonNull(ctx.encoding())) {
+ String encodingString = ctx.encoding().getChild(0).getText().toUpperCase();
+ encoding = TSEncoding.valueOf(encodingString);
+ }
+ createTimeSeriesOperator.setEncoding(encoding);
+
+ CompressionType compressor;
+ List<PropertyContext> properties = ctx.property();
+ if (ctx.compressor() != null) {
+ compressor = CompressionType.valueOf(ctx.compressor().getText().toUpperCase());
+ } else {
+ compressor = TSFileDescriptor.getInstance().getConfig().getCompressor();
+ }
+ Map<String, String> props = null;
+ if (ctx.property(0) != null) {
+ props = new HashMap<>(properties.size());
+ for (PropertyContext property : properties) {
+ props.put(property.ID().getText().toLowerCase(),
+ property.propertyValue().getText().toLowerCase());
}
}
- return time;
+ createTimeSeriesOperator.setCompressor(compressor);
+ createTimeSeriesOperator.setProps(props);
+ }
+
+ private PartialPath parseFullPath(FullPathContext ctx) {
+ List<NodeNameWithoutStarContext> nodeNamesWithoutStar = ctx.nodeNameWithoutStar();
+ String[] path = new String[nodeNamesWithoutStar.size() + 1];
+ int i = 0;
+ if (ctx.ROOT() != null) {
+ path[0] = ctx.ROOT().getText();
+ }
+ for (NodeNameWithoutStarContext nodeNameWithoutStar : nodeNamesWithoutStar) {
+ i++;
+ path[i] = nodeNameWithoutStar.getText();
+ }
+ return new PartialPath(path);
}
/**
* function for parsing time format.
*/
- long parseTimeFormat(String timestampStr) throws SQLParserException {
+ public long parseTimeFormat(String timestampStr) throws SQLParserException {
if (timestampStr == null || timestampStr.trim().equals("")) {
throw new SQLParserException("input timestamp cannot be empty");
}
@@ -1631,85 +1376,4 @@ public class LogicalGenerator extends SqlBaseBaseListener {
+ "refer to user document for more info.", timestampStr));
}
}
-
- /**
- * for delete command, time should only have an end time.
- *
- * @param operator delete logical plan
- */
- private Pair<Long, Long> parseDeleteTimeInterval(DeleteDataOperator operator) {
- FilterOperator filterOperator = operator.getFilterOperator();
- if (!filterOperator.isLeaf() && filterOperator.getTokenIntType() != SQLConstant.KW_AND) {
- throw new SQLParserException(
- DELETE_RANGE_ERROR_MSG);
- }
-
- if (filterOperator.isLeaf()) {
- return calcOperatorInterval(filterOperator);
- }
-
- List<FilterOperator> children = filterOperator.getChildren();
- FilterOperator lOperator = children.get(0);
- FilterOperator rOperator = children.get(1);
- if (!lOperator.isLeaf() || !rOperator.isLeaf()) {
- throw new SQLParserException(
- DELETE_RANGE_ERROR_MSG);
- }
-
- Pair<Long, Long> leftOpInterval = calcOperatorInterval(lOperator);
- Pair<Long, Long> rightOpInterval = calcOperatorInterval(rOperator);
- Pair<Long, Long> parsedInterval = new Pair<>(
- Math.max(leftOpInterval.left, rightOpInterval.left),
- Math.min(leftOpInterval.right, rightOpInterval.right));
- if (parsedInterval.left > parsedInterval.right) {
- throw new SQLParserException(
- "Invalid delete range: [" + parsedInterval.left + ", " + parsedInterval.right + "]");
- }
- return parsedInterval;
- }
-
- private Pair<Long, Long> calcOperatorInterval(FilterOperator filterOperator) {
- long time = Long.parseLong(((BasicFunctionOperator) filterOperator).getValue());
- switch (filterOperator.getTokenIntType()) {
- case SQLConstant.LESSTHAN:
- return new Pair<>(Long.MIN_VALUE, time - 1);
- case SQLConstant.LESSTHANOREQUALTO:
- return new Pair<>(Long.MIN_VALUE, time);
- case SQLConstant.GREATERTHAN:
- return new Pair<>(time + 1, Long.MAX_VALUE);
- case SQLConstant.GREATERTHANOREQUALTO:
- return new Pair<>(time, Long.MAX_VALUE);
- case SQLConstant.EQUAL:
- return new Pair<>(time, time);
- default:
- throw new SQLParserException(
- DELETE_RANGE_ERROR_MSG);
- }
- }
-
- @Override
- public void enterShowMergeStatus(ShowMergeStatusContext ctx) {
- super.enterShowMergeStatus(ctx);
- initializedOperator = new ShowMergeStatusOperator(SQLConstant.TOK_SHOW_MERGE_STATUS);
- }
-
- @Override
- public void enterDeletePartition(DeletePartitionContext ctx) {
- super.enterDeletePartition(ctx);
- DeletePartitionOperator deletePartitionOperator = new DeletePartitionOperator(
- SQLConstant.TOK_DELETE_PARTITION);
- deletePartitionOperator.setStorageGroupName(parsePrefixPath(ctx.prefixPath()));
- Set<Long> idSet = new HashSet<>();
- for (TerminalNode terminalNode : ctx.INT()) {
- idSet.add(Long.parseLong(terminalNode.getText()));
- }
- deletePartitionOperator.setPartitionIds(idSet);
- initializedOperator = deletePartitionOperator;
- }
-
- @Override
- public void enterCreateSnapshot(CreateSnapshotContext ctx) {
- super.enterCreateSnapshot(ctx);
- initializedOperator = new CreateSnapshotOperator(SQLConstant.TOK_CREATE_SCHEMA_SNAPSHOT);
- }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/strategy/ParseDriver.java b/server/src/main/java/org/apache/iotdb/db/qp/strategy/ParseDriver.java
index 89b05e6..37b9467 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/strategy/ParseDriver.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/strategy/ParseDriver.java
@@ -25,29 +25,29 @@ import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.atn.PredictionMode;
import org.antlr.v4.runtime.misc.ParseCancellationException;
import org.antlr.v4.runtime.tree.ParseTree;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.sql.IoTDBSqlVisitor;
+import org.apache.iotdb.db.qp.sql.SqlBaseLexer;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser;
/**
* ParseDriver.
*
*/
public class ParseDriver {
- private ParseTreeWalker walker;
- public ParseDriver() {
- walker = new ParseTreeWalker();
- }
+ public ParseDriver() { }
public Operator parse(String sql, ZoneId zoneId) throws ParseCancellationException {
- LogicalGenerator logicalGenerator = new LogicalGenerator(zoneId);
+ IoTDBSqlVisitor ioTDBSqlVisitor = new IoTDBSqlVisitor();
+ ioTDBSqlVisitor.setZoneId(zoneId);
CharStream charStream1 = CharStreams.fromString(sql);
SqlBaseLexer lexer1 = new SqlBaseLexer(charStream1);
CommonTokenStream tokens1 = new CommonTokenStream(lexer1);
SqlBaseParser parser1 = new SqlBaseParser(tokens1);
parser1.getInterpreter().setPredictionMode(PredictionMode.SLL);
parser1.removeErrorListeners();
- parser1.addErrorListener(LogicalGeneratorError.INSTANCE);
+ parser1.addErrorListener(SQLParseError.INSTANCE);
ParseTree tree;
try {
tree = parser1.singleStatement(); // STAGE 1
@@ -59,11 +59,10 @@ public class ParseDriver {
SqlBaseParser parser2 = new SqlBaseParser(tokens2);
parser2.getInterpreter().setPredictionMode(PredictionMode.LL);
parser2.removeErrorListeners();
- parser2.addErrorListener(LogicalGeneratorError.INSTANCE);
+ parser2.addErrorListener(SQLParseError.INSTANCE);
tree = parser2.singleStatement(); // STAGE 2
// if we parse ok, it's LL not SLL
}
- walker.walk(logicalGenerator, tree);
- return logicalGenerator.getLogicalPlan();
+ return ioTDBSqlVisitor.visit(tree);
}
}
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/strategy/LogicalGeneratorError.java b/server/src/main/java/org/apache/iotdb/db/qp/strategy/SQLParseError.java
similarity index 89%
rename from server/src/main/java/org/apache/iotdb/db/qp/strategy/LogicalGeneratorError.java
rename to server/src/main/java/org/apache/iotdb/db/qp/strategy/SQLParseError.java
index 69cd382..85c0e78 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/strategy/LogicalGeneratorError.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/strategy/SQLParseError.java
@@ -23,9 +23,9 @@ import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.Recognizer;
import org.antlr.v4.runtime.misc.ParseCancellationException;
-public class LogicalGeneratorError extends BaseErrorListener {
+public class SQLParseError extends BaseErrorListener {
- public static final LogicalGeneratorError INSTANCE = new LogicalGeneratorError();
+ public static final SQLParseError INSTANCE = new SQLParseError();
@Override
public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) {
diff --git a/server/src/test/java/org/apache/iotdb/db/sql/DatetimeQueryDataSetUtilsTest.java b/server/src/test/java/org/apache/iotdb/db/qp/sql/DatetimeQueryDataSetUtilsTest.java
similarity index 99%
rename from server/src/test/java/org/apache/iotdb/db/sql/DatetimeQueryDataSetUtilsTest.java
rename to server/src/test/java/org/apache/iotdb/db/qp/sql/DatetimeQueryDataSetUtilsTest.java
index c3043e3..1052f45 100644
--- a/server/src/test/java/org/apache/iotdb/db/sql/DatetimeQueryDataSetUtilsTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/qp/sql/DatetimeQueryDataSetUtilsTest.java
@@ -16,7 +16,7 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.apache.iotdb.db.sql;
+package org.apache.iotdb.db.qp.sql;
import static org.junit.Assert.assertEquals;
diff --git a/server/src/test/java/org/apache/iotdb/db/qp/strategy/LogicalGeneratorTest.java b/server/src/test/java/org/apache/iotdb/db/qp/strategy/LogicalGeneratorTest.java
index c19a69c..cbf11e2 100644
--- a/server/src/test/java/org/apache/iotdb/db/qp/strategy/LogicalGeneratorTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/qp/strategy/LogicalGeneratorTest.java
@@ -28,17 +28,19 @@ import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.exception.query.LogicalOperatorException;
import org.apache.iotdb.db.exception.runtime.SQLParserException;
import org.apache.iotdb.db.qp.constant.SQLConstant;
+import org.apache.iotdb.db.qp.sql.IoTDBSqlVisitor;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class LogicalGeneratorTest {
- LogicalGenerator generator;
+ IoTDBSqlVisitor visitor;
@Before
public void setUp() throws Exception {
- generator = new LogicalGenerator(ZonedDateTime.now().getOffset());
+ visitor = new IoTDBSqlVisitor();
+ visitor.setZoneId(ZonedDateTime.now().getOffset());
}
@After
@@ -46,8 +48,8 @@ public class LogicalGeneratorTest {
}
@Test
- public void testParseTimeFormatNow() throws LogicalOperatorException {
- long now = generator.parseTimeFormat(SQLConstant.NOW_FUNC);
+ public void testParseTimeFormatNow() {
+ long now = visitor.parseTimeFormat(SQLConstant.NOW_FUNC);
for (int i = 0; i <= 12; i++) {
ZoneOffset offset1, offset2;
if (i < 10) {
@@ -68,18 +70,18 @@ public class LogicalGeneratorTest {
}
@Test
- public void testParseTimeFormatNowPrecision() throws LogicalOperatorException {
+ public void testParseTimeFormatNowPrecision() {
String timePrecision = IoTDBDescriptor.getInstance().getConfig().getTimestampPrecision();
IoTDBDescriptor.getInstance().getConfig().setTimestampPrecision("ms");
- long now_ms = generator.parseTimeFormat(SQLConstant.NOW_FUNC);
+ long now_ms = visitor.parseTimeFormat(SQLConstant.NOW_FUNC);
String ms_str = String.valueOf(now_ms);
IoTDBDescriptor.getInstance().getConfig().setTimestampPrecision("us");
- long now_us = generator.parseTimeFormat(SQLConstant.NOW_FUNC);
+ long now_us = visitor.parseTimeFormat(SQLConstant.NOW_FUNC);
String us_str = String.valueOf(now_us);
IoTDBDescriptor.getInstance().getConfig().setTimestampPrecision("ns");
- long now_ns = generator.parseTimeFormat(SQLConstant.NOW_FUNC);
+ long now_ns = visitor.parseTimeFormat(SQLConstant.NOW_FUNC);
String ns_str = String.valueOf(now_ns);
assertEquals(ms_str.length() + 3, (us_str).length());
@@ -88,12 +90,12 @@ public class LogicalGeneratorTest {
}
@Test(expected = SQLParserException.class)
- public void testParseTimeFormatFail1() throws LogicalOperatorException {
- generator.parseTimeFormat(null);
+ public void testParseTimeFormatFail1() {
+ visitor.parseTimeFormat(null);
}
@Test(expected = SQLParserException.class)
- public void testParseTimeFormatFail2() throws LogicalOperatorException {
- generator.parseTimeFormat("");
+ public void testParseTimeFormatFail2() {
+ visitor.parseTimeFormat("");
}
}