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/12/05 02:43:19 UTC
[iotdb] branch change_listener_to_visitor_0.11 created (now e2803be)
This is an automated email from the ASF dual-hosted git repository.
geniuspig pushed a change to branch change_listener_to_visitor_0.11
in repository https://gitbox.apache.org/repos/asf/iotdb.git.
at e2803be update
This branch includes the following new commits:
new e7f93c4 change listener to visitor
new ca43e3e fix bug
new 5b06140 fix bug
new b5eff27 finish query
new 1fe32eb add linsense
new d1d61eb fix bugs
new 6c9a588 fix bugs
new 51c89e3 fix bug
new e2803be update
The 9 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] 06/09: fix bugs
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_0.11
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit d1d61eb1d485c5fde88ffaefa07fe9d03a9a83c0
Author: Boris <96...@qq.com>
AuthorDate: Mon Nov 16 15:39:05 2020 +0800
fix bugs
---
antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4 | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4 b/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4
index 29cccbe..4ff3c48 100644
--- a/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4
+++ b/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4
@@ -157,11 +157,11 @@ alterClause
| DROP ID (COMMA ID)*
| ADD TAGS property (COMMA property)*
| ADD ATTRIBUTES property (COMMA property)*
- | UPSERT aliasClause tagClause attributeClause?
+ | UPSERT aliasClause? tagClause? attributeClause?
;
aliasClause
- : (ALIAS OPERATOR_EQ ID)?
+ : ALIAS OPERATOR_EQ ID
;
attributeClauses
[iotdb] 03/09: fix bug
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_0.11
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 5b061404eb0b0258e17726a45bac7a2ad6f033cd
Author: Boris <96...@qq.com>
AuthorDate: Thu Nov 12 13:37:50 2020 +0800
fix bug
---
.../src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
index 2ee4d45..f701c82 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
@@ -180,8 +180,12 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
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);
+ if(ctx.alias() != null) {
+ createTimeSeriesOperator.setAlias(ctx.alias().ID().getText());
+ }
+ if(ctx.attributeClauses() != null) {
+ parseAttributeClauses(ctx.attributeClauses(), createTimeSeriesOperator);
+ }
return createTimeSeriesOperator;
}
[iotdb] 04/09: finish query
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_0.11
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit b5eff27d78dddac52e7ec2b2b275e3169429313e
Author: Boris <96...@qq.com>
AuthorDate: Thu Nov 12 17:06:00 2020 +0800
finish query
---
.../antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4 | 30 +-
.../main/java/org/apache/iotdb/db/qp/Planner.java | 8 +-
.../apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java | 350 ++++++++++++++++++++-
.../{ParseDriver.java => LogicalGenerator.java} | 8 +-
.../iotdb/db/qp/plan/LogicalPlanSmallTest.java | 110 +++----
5 files changed, 417 insertions(+), 89 deletions(-)
diff --git a/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4 b/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4
index 27bca32..29cccbe 100644
--- a/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4
+++ b/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/SqlBase.g4
@@ -157,7 +157,7 @@ alterClause
| DROP ID (COMMA ID)*
| ADD TAGS property (COMMA property)*
| ADD ATTRIBUTES property (COMMA property)*
- | UPSERT aliasClause tagClause attributeClause
+ | UPSERT aliasClause tagClause attributeClause?
;
aliasClause
@@ -168,8 +168,8 @@ attributeClauses
: DATATYPE OPERATOR_EQ dataType (COMMA ENCODING OPERATOR_EQ encoding)?
(COMMA (COMPRESSOR | COMPRESSION) OPERATOR_EQ compressor)?
(COMMA property)*
- tagClause
- attributeClause
+ tagClause?
+ attributeClause?
;
compressor
@@ -184,11 +184,11 @@ compressor
;
attributeClause
- : (ATTRIBUTES LR_BRACKET property (COMMA property)* RR_BRACKET)?
+ : ATTRIBUTES LR_BRACKET property (COMMA property)* RR_BRACKET
;
tagClause
- : (TAGS LR_BRACKET property (COMMA property)* RR_BRACKET)?
+ : TAGS LR_BRACKET property (COMMA property)* RR_BRACKET
;
setClause
@@ -229,19 +229,19 @@ fromClause
;
specialClause
- : specialLimit
- | orderByTimeClause specialLimit?
- | groupByTimeClause orderByTimeClause? specialLimit?
- | groupByFillClause orderByTimeClause? specialLimit?
- | fillClause slimitClause? alignByDeviceClauseOrDisableAlign?
- | alignByDeviceClauseOrDisableAlign
- | groupByLevelClause orderByTimeClause? specialLimit?
+ : specialLimit #specialLimitStatement
+ | orderByTimeClause specialLimit? #orderByTimeStatement
+ | groupByTimeClause orderByTimeClause? specialLimit? #groupByTimeStatement
+ | groupByFillClause orderByTimeClause? specialLimit? #groupByFillStatement
+ | fillClause slimitClause? alignByDeviceClauseOrDisableAlign? #fillStatement
+ | alignByDeviceClauseOrDisableAlign #alignByDeviceStatementOrDisableAlignInSpecialClause
+ | groupByLevelClause orderByTimeClause? specialLimit? #groupByLevelStatement
;
specialLimit
- : limitClause slimitClause? alignByDeviceClauseOrDisableAlign?
- | slimitClause limitClause? alignByDeviceClauseOrDisableAlign?
- | alignByDeviceClauseOrDisableAlign
+ : limitClause slimitClause? alignByDeviceClauseOrDisableAlign? #limitStatement
+ | slimitClause limitClause? alignByDeviceClauseOrDisableAlign? #slimitStatement
+ | alignByDeviceClauseOrDisableAlign #alignByDeviceClauseOrDisableAlignInSpecialLimit
;
orderByTimeClause
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/Planner.java b/server/src/main/java/org/apache/iotdb/db/qp/Planner.java
index 48bb90e..4b6e79c 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/Planner.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/Planner.java
@@ -41,7 +41,7 @@ import org.apache.iotdb.db.qp.logical.crud.QueryOperator;
import org.apache.iotdb.db.qp.logical.crud.SFWOperator;
import org.apache.iotdb.db.qp.logical.crud.SelectOperator;
import org.apache.iotdb.db.qp.physical.PhysicalPlan;
-import org.apache.iotdb.db.qp.strategy.ParseDriver;
+import org.apache.iotdb.db.qp.strategy.LogicalGenerator;
import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
import org.apache.iotdb.db.qp.strategy.optimizer.ConcatPathOptimizer;
import org.apache.iotdb.db.qp.strategy.optimizer.DnfFilterOptimizer;
@@ -56,10 +56,10 @@ import org.apache.iotdb.service.rpc.thrift.TSRawDataQueryReq;
*/
public class Planner {
- protected ParseDriver parseDriver;
+ protected LogicalGenerator logicalGenerator;
public Planner() {
- this.parseDriver = new ParseDriver();
+ this.logicalGenerator = new LogicalGenerator();
}
@TestOnly
@@ -73,7 +73,7 @@ public class Planner {
*/
public PhysicalPlan parseSQLToPhysicalPlan(String sqlStr, ZoneId zoneId, int fetchSize)
throws QueryProcessException {
- Operator operator = parseDriver.parse(sqlStr, zoneId);
+ Operator operator = logicalGenerator.generate(sqlStr, zoneId);
int maxDeduplicatedPathNum = QueryResourceManager.getInstance()
.getMaxDeduplicatedPathNum(fetchSize);
if (operator instanceof SFWOperator && ((SFWOperator) operator).isLastQuery()) {
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
index f701c82..9213b84 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
@@ -58,11 +58,16 @@ 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.sql.SqlBaseParser.AlignByDeviceClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.AliasClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.AlignByDeviceClauseOrDisableAlignInSpecialLimitContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.AlignByDeviceStatementOrDisableAlignInSpecialClauseContext;
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.AsClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.AsElementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.AttributeClauseContext;
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;
@@ -81,21 +86,34 @@ 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.FillClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.FillStatementContext;
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.FunctionAsClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.FunctionAsElementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.FunctionCallContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.FunctionElementContext;
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.GroupByFillStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.GroupByLevelClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.GroupByLevelStatementContext;
import org.apache.iotdb.db.qp.sql.SqlBaseParser.GroupByTimeClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.GroupByTimeStatementContext;
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.LastClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.LastElementContext;
import org.apache.iotdb.db.qp.sql.SqlBaseParser.LimitClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.LimitStatementContext;
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;
@@ -111,8 +129,10 @@ 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.OffsetClauseContext;
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.OrderByTimeStatementContext;
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;
@@ -141,8 +161,12 @@ 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.SingleStatementContext;
import org.apache.iotdb.db.qp.sql.SqlBaseParser.SlimitClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.SlimitStatementContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.SoffsetClauseContext;
+import org.apache.iotdb.db.qp.sql.SqlBaseParser.SpecialLimitStatementContext;
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.TagClauseContext;
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;
@@ -166,6 +190,7 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
"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;
+ QueryOperator queryOp;
public void setZoneId(ZoneId zoneId) {
this.zoneId = zoneId;
@@ -218,7 +243,7 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
insertOp.setSelectOperator(selectOp);
parseInsertColumnSpec(ctx.insertColumnSpec(), insertOp);
parseInsertValuesSpec(ctx.insertValuesSpec(), insertOp);
- return insertOp;
+ return insertOp;
}
@Override
@@ -566,7 +591,9 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
if(ctx.showWhereClause() != null) {
parseShowWhereClause(ctx.showWhereClause(), showTimeSeriesOperator);
}
- showTimeSeriesOperator.setLimit(parseLimitClause(ctx.limitClause()));
+ if(ctx.limitClause() != null) {
+ parseLimitClause(ctx.limitClause(), showTimeSeriesOperator);
+ }
return showTimeSeriesOperator;
}
@@ -717,13 +744,200 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
@Override
public Operator visitSelectStatement(SelectStatementContext ctx) {
- QueryOperator queryOp = new QueryOperator(SQLConstant.TOK_QUERY);
+ queryOp = new QueryOperator(SQLConstant.TOK_QUERY);
SelectOperator selectOp = (SelectOperator) visit(ctx.selectElements());
+ queryOp.setSelectOperator(selectOp);
FromOperator fromOp = (FromOperator) visit(ctx.fromClause());
- FilterOperator whereOp = (FilterOperator) visit(ctx.whereClause());
queryOp.setFromOperator(fromOp);
- queryOp.setFilterOperator(whereOp.getChildren().get(0));
- queryOp.setSelectOperator(selectOp);
+ if(ctx.whereClause() != null) {
+ FilterOperator whereOp = (FilterOperator) visit(ctx.whereClause());
+ queryOp.setFilterOperator(whereOp.getChildren().get(0));
+ }
+ if(ctx.specialClause() != null) {
+ visit(ctx.specialClause());
+ }
+ return queryOp;
+ }
+
+ @Override
+ public Operator visitFunctionElement(FunctionElementContext ctx) {
+ SelectOperator 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());
+ }
+ return selectOp;
+ }
+
+ @Override
+ public Operator visitLastElement(LastElementContext ctx) {
+ SelectOperator selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
+ selectOp.setLastQuery();
+ LastClauseContext lastClauseContext = ctx.lastClause();
+ if (lastClauseContext.asClause().size() != 0) {
+ parseAsClause(lastClauseContext.asClause(), selectOp);
+ } else {
+ List<SuffixPathContext> suffixPaths = lastClauseContext.suffixPath();
+ for (SuffixPathContext suffixPath : suffixPaths) {
+ PartialPath path = parseSuffixPath(suffixPath);
+ selectOp.addSelectPath(path);
+ }
+ }
+ return selectOp;
+ }
+
+ @Override
+ public Operator visitAsElement(AsElementContext ctx) {
+ SelectOperator selectOp = new SelectOperator(SQLConstant.TOK_SELECT);
+ parseAsClause(ctx.asClause(), selectOp);
+ return selectOp;
+ }
+
+ @Override
+ public Operator visitFunctionAsElement(FunctionAsElementContext ctx) {
+ SelectOperator 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());
+ }
+ selectOp.addClusterPath(path, functionCallContext.functionName().getText());
+ }
+ return selectOp;
+ }
+
+ public void parseAsClause(List<AsClauseContext> asClauseContexts, SelectOperator selectOp) {
+ for (AsClauseContext asClauseContext : asClauseContexts) {
+ PartialPath path = parseSuffixPath(asClauseContext.suffixPath());
+ if (asClauseContext.ID() != null) {
+ path.setTsAlias(asClauseContext.ID().toString());
+ }
+ selectOp.addSelectPath(path);
+ }
+ }
+
+ @Override
+ public Operator visitSpecialLimitStatement(SpecialLimitStatementContext ctx) {
+ return visit(ctx.specialLimit());
+ }
+
+ @Override
+ public Operator visitLimitStatement(LimitStatementContext ctx) {
+ parseLimitClause(ctx.limitClause(), queryOp);
+ if(ctx.slimitClause() != null) {
+ parseSlimitClause(ctx.slimitClause(), queryOp);
+ }
+ if(ctx.alignByDeviceClauseOrDisableAlign() != null) {
+ if(ctx.alignByDeviceClauseOrDisableAlign().alignByDeviceClause() != null) {
+ parseAlignByDeviceClause(queryOp);
+ } else {
+ parseDisableAlign(queryOp);
+ }
+ }
+ return queryOp;
+ }
+
+ @Override
+ public Operator visitSlimitStatement(SlimitStatementContext ctx) {
+ parseSlimitClause(ctx.slimitClause(), queryOp);
+ if(ctx.limitClause() != null) {
+ parseLimitClause(ctx.limitClause(), queryOp);
+ }
+ if(ctx.alignByDeviceClauseOrDisableAlign() != null) {
+ if(ctx.alignByDeviceClauseOrDisableAlign().alignByDeviceClause() != null) {
+ parseAlignByDeviceClause(queryOp);
+ } else {
+ parseDisableAlign(queryOp);
+ }
+ }
+ return queryOp;
+ }
+
+ @Override
+ public Operator visitAlignByDeviceClauseOrDisableAlignInSpecialLimit(
+ AlignByDeviceClauseOrDisableAlignInSpecialLimitContext ctx) {
+ if(ctx.alignByDeviceClauseOrDisableAlign().alignByDeviceClause() != null) {
+ parseAlignByDeviceClause(queryOp);
+ } else {
+ parseDisableAlign(queryOp);
+ }
+ return queryOp;
+ }
+
+ @Override
+ public Operator visitOrderByTimeStatement(OrderByTimeStatementContext ctx) {
+ parseOrderByTimeClause(ctx.orderByTimeClause(), queryOp);
+ if(ctx.specialLimit() != null) {
+ return visit(ctx.specialLimit());
+ }
+ return queryOp;
+ }
+
+ @Override
+ public Operator visitGroupByTimeStatement(GroupByTimeStatementContext ctx) {
+ parseGroupByTimeClause(ctx.groupByTimeClause(), queryOp);
+ if(ctx.orderByTimeClause() != null) {
+ parseOrderByTimeClause(ctx.orderByTimeClause(), queryOp);
+ }
+ if(ctx.specialLimit() != null) {
+ return visit(ctx.specialLimit());
+ }
+ return queryOp;
+ }
+
+ @Override
+ public Operator visitGroupByFillStatement(GroupByFillStatementContext ctx) {
+ parseGroupByFillClause(ctx.groupByFillClause(), queryOp);
+ if(ctx.orderByTimeClause() != null) {
+ parseOrderByTimeClause(ctx.orderByTimeClause(), queryOp);
+ }
+ if(ctx.specialLimit() != null) {
+ return visit(ctx.specialLimit());
+ }
+ return queryOp;
+ }
+
+ @Override
+ public Operator visitFillStatement(FillStatementContext ctx) {
+ parseFillClause(ctx.fillClause(), queryOp);
+ if(ctx.slimitClause() != null) {
+ queryOp = (QueryOperator) visit(ctx.slimitClause());
+ }
+ if(ctx.alignByDeviceClauseOrDisableAlign() != null) {
+ if(ctx.alignByDeviceClauseOrDisableAlign().alignByDeviceClause() != null) {
+ parseAlignByDeviceClause(queryOp);
+ } else {
+ parseDisableAlign(queryOp);
+ }
+ }
+ return queryOp;
+ }
+
+ @Override
+ public Operator visitAlignByDeviceStatementOrDisableAlignInSpecialClause(
+ AlignByDeviceStatementOrDisableAlignInSpecialClauseContext ctx) {
+ if(ctx.alignByDeviceClauseOrDisableAlign() != null) {
+ if(ctx.alignByDeviceClauseOrDisableAlign().alignByDeviceClause() != null) {
+ parseAlignByDeviceClause(queryOp);
+ } else {
+ parseDisableAlign(queryOp);
+ }
+ }
+ return queryOp;
+ }
+
+ @Override
+ public Operator visitGroupByLevelStatement(GroupByLevelStatementContext ctx) {
+ parseGroupByLevelClause(ctx.groupByLevelClause(), queryOp);
+ if(ctx.orderByTimeClause() != null) {
+ parseOrderByTimeClause(ctx.orderByTimeClause(), queryOp);
+ }
+ if(ctx.specialLimit() != null) {
+ return visit(ctx.specialLimit());
+ }
return queryOp;
}
@@ -754,7 +968,26 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
return fromOp;
}
- private int parseLimitClause(LimitClauseContext ctx) {
+ public void parseGroupByLevelClause(GroupByLevelClauseContext ctx, QueryOperator queryOp) {
+ queryOp.setGroupByLevel(true);
+ queryOp.setLevel(Integer.parseInt(ctx.INT().getText()));
+ }
+
+ public void parseFillClause(FillClauseContext ctx, QueryOperator queryOp) {
+ 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 parseLimitClause(LimitClauseContext ctx, Operator operator) {
int limit;
try {
limit = Integer.parseInt(ctx.INT().getText());
@@ -764,10 +997,35 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
if (limit <= 0) {
throw new SQLParserException("LIMIT <N>: N should be greater than 0.");
}
- return limit;
+ if(operator instanceof ShowTimeSeriesOperator) {
+ ((ShowTimeSeriesOperator) operator).setLimit(limit);
+ } else {
+ ((QueryOperator) operator).setRowLimit(limit);
+ }
+ if(ctx.offsetClause() != null) {
+ parseOffsetClause(ctx.offsetClause(), operator);
+ }
}
- private int parseSlimitClause(SlimitClauseContext ctx) {
+ private void parseOffsetClause(OffsetClauseContext ctx, Operator operator) {
+ 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 (operator instanceof ShowTimeSeriesOperator) {
+ ((ShowTimeSeriesOperator) operator).setOffset(offset);
+ } else {
+ ((QueryOperator) operator).setRowOffset(offset);
+ }
+ }
+
+ private void parseSlimitClause(SlimitClauseContext ctx, QueryOperator queryOp) {
int slimit;
try {
slimit = Integer.parseInt(ctx.INT().getText());
@@ -778,7 +1036,25 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
if (slimit <= 0) {
throw new SQLParserException("SLIMIT <SN>: SN should be greater than 0.");
}
- return slimit;
+ queryOp.setSeriesLimit(slimit);
+ if(ctx.soffsetClause() != null) {
+ parseSoffsetClause(ctx.soffsetClause(), queryOp);
+ }
+ }
+
+ public void parseSoffsetClause(SoffsetClauseContext ctx, QueryOperator queryOp) {
+ 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);
}
private void parseGroupByTimeClause(GroupByTimeClauseContext ctx, QueryOperator queryOp) {
@@ -1271,10 +1547,21 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
} else {
// upsert
alterTimeSeriesOperator.setAlterType(AlterType.UPSERT);
+ parseAliasClause(ctx.aliasClause(), alterTimeSeriesOperator);
+ parseTagClause(ctx.tagClause(), alterTimeSeriesOperator);
+ if(ctx.attributeClause() != null) {
+ parseAttributeClause(ctx.attributeClause(), alterTimeSeriesOperator);
+ }
}
alterTimeSeriesOperator.setAlterMap(alterMap);
}
+ public void parseAliasClause(AliasClauseContext ctx, AlterTimeSeriesOperator alterTimeSeriesOperator) {
+ if (alterTimeSeriesOperator != null && ctx.ID() != null) {
+ alterTimeSeriesOperator.setAlias(ctx.ID().getText());
+ }
+ }
+
private void setMap(SqlBaseParser.AlterClauseContext ctx, Map<String, String> alterMap) {
List<PropertyContext> tagsList = ctx.property();
if (ctx.property(0) != null) {
@@ -1340,6 +1627,47 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
}
createTimeSeriesOperator.setCompressor(compressor);
createTimeSeriesOperator.setProps(props);
+ if(ctx.tagClause() != null) {
+ parseTagClause(ctx.tagClause(), createTimeSeriesOperator);
+ }
+ if(ctx.attributeClause() != null) {
+ parseAttributeClause(ctx.attributeClause(), createTimeSeriesOperator);
+ }
+ }
+
+ public void parseAttributeClause(AttributeClauseContext ctx, Operator operator) {
+ Map<String, String> attributes = extractMap(ctx.property(), ctx.property(0));
+ if (operator instanceof CreateTimeSeriesOperator) {
+ ((CreateTimeSeriesOperator) operator).setAttributes(attributes);
+ } else if (operator instanceof AlterTimeSeriesOperator) {
+ ((AlterTimeSeriesOperator) operator).setAttributesMap(attributes);
+ }
+ }
+
+ public void parseTagClause(TagClauseContext ctx, Operator operator) {
+ Map<String, String> tags = extractMap(ctx.property(), ctx.property(0));
+ if (operator instanceof CreateTimeSeriesOperator) {
+ ((CreateTimeSeriesOperator) operator).setTags(tags);
+ } else if (operator instanceof AlterTimeSeriesOperator) {
+ ((AlterTimeSeriesOperator) operator).setTagsMap(tags);
+ }
+ }
+
+ 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);
+ }
+ }
+ return tags;
}
private PartialPath parseFullPath(FullPathContext ctx) {
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/LogicalGenerator.java
similarity index 93%
rename from server/src/main/java/org/apache/iotdb/db/qp/strategy/ParseDriver.java
rename to server/src/main/java/org/apache/iotdb/db/qp/strategy/LogicalGenerator.java
index 37b9467..057e4bc 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/LogicalGenerator.java
@@ -31,14 +31,14 @@ import org.apache.iotdb.db.qp.sql.SqlBaseLexer;
import org.apache.iotdb.db.qp.sql.SqlBaseParser;
/**
- * ParseDriver.
+ * LogicalGenerator.
*
*/
-public class ParseDriver {
+public class LogicalGenerator {
- public ParseDriver() { }
+ public LogicalGenerator() { }
- public Operator parse(String sql, ZoneId zoneId) throws ParseCancellationException {
+ public Operator generate(String sql, ZoneId zoneId) throws ParseCancellationException {
IoTDBSqlVisitor ioTDBSqlVisitor = new IoTDBSqlVisitor();
ioTDBSqlVisitor.setZoneId(zoneId);
CharStream charStream1 = CharStreams.fromString(sql);
diff --git a/server/src/test/java/org/apache/iotdb/db/qp/plan/LogicalPlanSmallTest.java b/server/src/test/java/org/apache/iotdb/db/qp/plan/LogicalPlanSmallTest.java
index 614117e..f048a28 100644
--- a/server/src/test/java/org/apache/iotdb/db/qp/plan/LogicalPlanSmallTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/qp/plan/LogicalPlanSmallTest.java
@@ -32,7 +32,7 @@ import org.apache.iotdb.db.qp.logical.crud.DeleteDataOperator;
import org.apache.iotdb.db.qp.logical.crud.QueryOperator;
import org.apache.iotdb.db.qp.logical.sys.DeleteStorageGroupOperator;
import org.apache.iotdb.db.qp.logical.sys.SetStorageGroupOperator;
-import org.apache.iotdb.db.qp.strategy.ParseDriver;
+import org.apache.iotdb.db.qp.strategy.LogicalGenerator;
import org.apache.iotdb.db.qp.strategy.optimizer.ConcatPathOptimizer;
import org.apache.iotdb.db.service.IoTDB;
import org.junit.Assert;
@@ -41,18 +41,18 @@ import org.junit.Test;
public class LogicalPlanSmallTest {
- private ParseDriver parseDriver;
+ private LogicalGenerator logicalGenerator;
@Before
public void before() {
- parseDriver = new ParseDriver();
+ logicalGenerator = new LogicalGenerator();
}
@Test
public void testLimit() {
String sqlStr = "select * from root.vehicle.d1 limit 10";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertEquals(10, ((QueryOperator) operator).getRowLimit());
Assert.assertEquals(0, ((QueryOperator) operator).getRowOffset());
@@ -63,8 +63,8 @@ public class LogicalPlanSmallTest {
@Test
public void testOffset() {
String sqlStr = "select * from root.vehicle.d1 limit 10 offset 20";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertEquals(10, ((QueryOperator) operator).getRowLimit());
Assert.assertEquals(20, ((QueryOperator) operator).getRowOffset());
@@ -75,8 +75,8 @@ public class LogicalPlanSmallTest {
@Test
public void testSlimit() {
String sqlStr = "select * from root.vehicle.d1 limit 10 slimit 1";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertEquals(10, ((QueryOperator) operator).getRowLimit());
Assert.assertEquals(0, ((QueryOperator) operator).getRowOffset());
@@ -87,8 +87,8 @@ public class LogicalPlanSmallTest {
@Test
public void testSOffset() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and time <= now() limit 50 slimit 10 soffset 100";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertEquals(50, ((QueryOperator) operator).getRowLimit());
Assert.assertEquals(0, ((QueryOperator) operator).getRowOffset());
@@ -99,8 +99,8 @@ public class LogicalPlanSmallTest {
@Test
public void testSOffsetTimestamp() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and timestamp <= now() limit 50 slimit 10 soffset 100";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertEquals(50, ((QueryOperator) operator).getRowLimit());
Assert.assertEquals(0, ((QueryOperator) operator).getRowOffset());
@@ -111,16 +111,16 @@ public class LogicalPlanSmallTest {
@Test(expected = SQLParserException.class)
public void testLimitOutOfRange() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and time <= now() limit 1111111111111111111111";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
// expected to throw SQLParserException: Out of range. LIMIT <N>: N should be Int32.
}
@Test(expected = SQLParserException.class)
public void testLimitNotPositive() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and time <= now() limit 0";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
// expected to throw SQLParserException: LIMIT <N>: N should be greater than 0.
}
@@ -128,32 +128,32 @@ public class LogicalPlanSmallTest {
public void testOffsetOutOfRange() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and time <= now() "
+ "limit 1 offset 1111111111111111111111";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
// expected to throw SQLParserException: Out of range. OFFSET <OFFSETValue>: OFFSETValue should be Int32.
}
@Test(expected = ParseCancellationException.class)
public void testOffsetNotPositive() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and time <= now() limit 1 offset -1";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
// expected to throw SQLParserException: OFFSET <OFFSETValue>: OFFSETValue should >= 0.
}
@Test(expected = SQLParserException.class)
public void testSlimitOutOfRange() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and time <= now() slimit 1111111111111111111111";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
// expected to throw SQLParserException: Out of range. SLIMIT <SN>: SN should be Int32.
}
@Test(expected = SQLParserException.class)
public void testSlimitNotPositive() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and time <= now() slimit 0";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
// expected to throw SQLParserException: SLIMIT <SN>: SN should be greater than 0.
}
@@ -161,16 +161,16 @@ public class LogicalPlanSmallTest {
public void testSoffsetOutOfRange() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and time <= now() "
+ "slimit 1 soffset 1111111111111111111111";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
// expected to throw SQLParserException: Out of range. SOFFSET <SOFFSETValue>: SOFFSETValue should be Int32.
}
@Test
public void testSoffsetNotPositive() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and time <= now() slimit 1 soffset 1";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(1, ((QueryOperator) operator).getSeriesOffset());
Assert.assertEquals(1, ((QueryOperator) operator).getSeriesLimit());
}
@@ -178,8 +178,8 @@ public class LogicalPlanSmallTest {
@Test(expected = LogicalOptimizeException.class)
public void testSoffsetExceedColumnNum() throws QueryProcessException {
String sqlStr = "select s1 from root.vehicle.d1 where s1 < 20 and time <= now() slimit 2 soffset 1";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
IoTDB.metaManager.init();
ConcatPathOptimizer concatPathOptimizer = new ConcatPathOptimizer();
concatPathOptimizer.transform(operator, 1000);
@@ -190,8 +190,8 @@ public class LogicalPlanSmallTest {
@Test
public void testDeleteStorageGroup() throws IllegalPathException {
String sqlStr = "delete storage group root.vehicle.d1";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(DeleteStorageGroupOperator.class, operator.getClass());
PartialPath path = new PartialPath("root.vehicle.d1");
Assert.assertEquals(path, ((DeleteStorageGroupOperator) operator).getDeletePathList().get(0));
@@ -200,8 +200,8 @@ public class LogicalPlanSmallTest {
@Test
public void testDisableAlign() {
String sqlStr = "select * from root.vehicle disable align";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertFalse(((QueryOperator) operator).isAlignByTime());
}
@@ -209,8 +209,8 @@ public class LogicalPlanSmallTest {
@Test
public void testNotDisableAlign() {
String sqlStr = "select * from root.vehicle";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertTrue(((QueryOperator) operator).isAlignByTime());
}
@@ -218,21 +218,21 @@ public class LogicalPlanSmallTest {
@Test(expected = ParseCancellationException.class)
public void testDisableAlignConflictAlignByDevice() {
String sqlStr = "select * from root.vehicle disable align align by device";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr, ZoneId.systemDefault());
}
@Test
public void testChineseCharacter() throws IllegalPathException {
String sqlStr1 = "set storage group to root.一级";
- RootOperator operator = (RootOperator) parseDriver
- .parse(sqlStr1, ZoneId.systemDefault());
+ RootOperator operator = (RootOperator) logicalGenerator
+ .generate(sqlStr1, ZoneId.systemDefault());
Assert.assertEquals(SetStorageGroupOperator.class, operator.getClass());
Assert.assertEquals(new PartialPath("root.一级"), ((SetStorageGroupOperator) operator).getPath());
String sqlStr2 = "select * from root.一级.设备1 limit 10 offset 20";
- operator = (RootOperator) parseDriver
- .parse(sqlStr2, ZoneId.systemDefault());
+ operator = (RootOperator) logicalGenerator
+ .generate(sqlStr2, ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
ArrayList<PartialPath> paths = new ArrayList<>();
paths.add(new PartialPath("*"));
@@ -252,7 +252,7 @@ public class LogicalPlanSmallTest {
+ "FIRST_VALUE.SUM.LAST_VALUE.LAST.DISABLE.ALIGN.COMPRESSION.TIME.ATTRIBUTES.TAGS.RENAME.FULL.CLEAR.CACHE."
+ "SNAPSHOT.FOR.SCHEMA.TRACING.OFF where time>=1 and time < 3";
- Operator op = parseDriver.parse(sql, ZoneId.systemDefault());
+ Operator op = logicalGenerator.generate(sql, ZoneId.systemDefault());
Assert.assertEquals(DeleteDataOperator.class, op.getClass());
} catch (ParseCancellationException ignored) {
}
@@ -261,7 +261,7 @@ public class LogicalPlanSmallTest {
@Test
public void testRangeDelete() throws IllegalPathException {
String sql1 = "delete from root.d1.s1 where time>=1 and time < 3";
- Operator op = parseDriver.parse(sql1, ZoneId.systemDefault());
+ Operator op = logicalGenerator.generate(sql1, ZoneId.systemDefault());
Assert.assertEquals(DeleteDataOperator.class, op.getClass());
ArrayList<PartialPath> paths = new ArrayList<>();
paths.add(new PartialPath("root.d1.s1"));
@@ -270,37 +270,37 @@ public class LogicalPlanSmallTest {
Assert.assertEquals(2, ((DeleteDataOperator) op).getEndTime());
String sql2 = "delete from root.d1.s1 where time>=1";
- op = parseDriver.parse(sql2, ZoneId.systemDefault());
+ op = logicalGenerator.generate(sql2, ZoneId.systemDefault());
Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
Assert.assertEquals(1, ((DeleteDataOperator) op).getStartTime());
Assert.assertEquals(Long.MAX_VALUE, ((DeleteDataOperator) op).getEndTime());
String sql3 = "delete from root.d1.s1 where time>1";
- op = parseDriver.parse(sql3, ZoneId.systemDefault());
+ op = logicalGenerator.generate(sql3, ZoneId.systemDefault());
Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
Assert.assertEquals(2, ((DeleteDataOperator) op).getStartTime());
Assert.assertEquals(Long.MAX_VALUE, ((DeleteDataOperator) op).getEndTime());
String sql4 = "delete from root.d1.s1 where time <= 1";
- op = parseDriver.parse(sql4, ZoneId.systemDefault());
+ op = logicalGenerator.generate(sql4, ZoneId.systemDefault());
Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
Assert.assertEquals(Long.MIN_VALUE, ((DeleteDataOperator) op).getStartTime());
Assert.assertEquals(1, ((DeleteDataOperator) op).getEndTime());
String sql5 = "delete from root.d1.s1 where time<1";
- op = parseDriver.parse(sql5, ZoneId.systemDefault());
+ op = logicalGenerator.generate(sql5, ZoneId.systemDefault());
Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
Assert.assertEquals(Long.MIN_VALUE, ((DeleteDataOperator) op).getStartTime());
Assert.assertEquals(0, ((DeleteDataOperator) op).getEndTime());
String sql6 = "delete from root.d1.s1 where time = 3";
- op = parseDriver.parse(sql6, ZoneId.systemDefault());
+ op = logicalGenerator.generate(sql6, ZoneId.systemDefault());
Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
Assert.assertEquals(3, ((DeleteDataOperator) op).getStartTime());
Assert.assertEquals(3, ((DeleteDataOperator) op).getEndTime());
String sql7 = "delete from root.d1.s1 where time > 5 and time >= 2";
- op = parseDriver.parse(sql7, ZoneId.systemDefault());
+ op = logicalGenerator.generate(sql7, ZoneId.systemDefault());
Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
Assert.assertEquals(6, ((DeleteDataOperator) op).getStartTime());
Assert.assertEquals(Long.MAX_VALUE, ((DeleteDataOperator) op).getEndTime());
@@ -311,7 +311,7 @@ public class LogicalPlanSmallTest {
String sql = "delete from root.d1.s1 where time>=1 and time < 3 or time >1";
String errorMsg = null;
try {
- parseDriver.parse(sql, ZoneId.systemDefault());
+ logicalGenerator.generate(sql, ZoneId.systemDefault());
} catch (SQLParserException e) {
errorMsg = e.getMessage();
}
@@ -323,7 +323,7 @@ public class LogicalPlanSmallTest {
sql = "delete from root.d1.s1 where time>=1 or time < 3";
errorMsg = null;
try {
- parseDriver.parse(sql, ZoneId.systemDefault());
+ logicalGenerator.generate(sql, ZoneId.systemDefault());
} catch (SQLParserException e) {
errorMsg = e.getMessage();
}
@@ -335,7 +335,7 @@ public class LogicalPlanSmallTest {
String sql7 = "delete from root.d1.s1 where time = 1 and time < -1";
errorMsg = null;
try {
- parseDriver.parse(sql7, ZoneId.systemDefault());
+ logicalGenerator.generate(sql7, ZoneId.systemDefault());
} catch (RuntimeException e) {
errorMsg = e.getMessage();
}
@@ -344,7 +344,7 @@ public class LogicalPlanSmallTest {
sql = "delete from root.d1.s1 where time > 5 and time <= 0";
errorMsg = null;
try {
- parseDriver.parse(sql, ZoneId.systemDefault());
+ logicalGenerator.generate(sql, ZoneId.systemDefault());
} catch (SQLParserException e) {
errorMsg = e.getMessage();
}
[iotdb] 08/09: fix bug
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_0.11
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 51c89e32caa9aae744eaac180a05dd9a0cd5d949
Author: Boris <96...@qq.com>
AuthorDate: Mon Nov 16 18:37:57 2020 +0800
fix bug
---
server/src/main/java/org/apache/iotdb/db/metadata/MManager.java | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java b/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java
index ae3b252..44d2bd2 100644
--- a/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/metadata/MManager.java
@@ -1256,7 +1256,10 @@ public class MManager {
}
}
- pair.right.putAll(attributesMap);
+ if (attributesMap != null) {
+ pair.right.putAll(attributesMap);
+ }
+
// persist the change to disk
tagLogFile.write(pair.left, pair.right, leafMNode.getOffset());
[iotdb] 02/09: fix bug
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_0.11
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit ca43e3e484c596ac673dc4e1b267466815b4464c
Author: Boris <96...@qq.com>
AuthorDate: Thu Nov 12 08:48:48 2020 +0800
fix bug
---
.../src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
index f315e50..2ee4d45 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
@@ -139,6 +139,7 @@ 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.SingleStatementContext;
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;
@@ -171,6 +172,11 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
}
@Override
+ public Operator visitSingleStatement(SingleStatementContext ctx) {
+ return visit(ctx.statement());
+ }
+
+ @Override
public Operator visitCreateTimeseries(CreateTimeseriesContext ctx) {
CreateTimeSeriesOperator createTimeSeriesOperator = new CreateTimeSeriesOperator(SQLConstant.TOK_METADATA_CREATE);
createTimeSeriesOperator.setPath(parseFullPath(ctx.fullPath()));
[iotdb] 05/09: add linsense
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_0.11
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 1fe32eb6f6c81f887b98620a168d1c17fe0897d5
Author: Boris <96...@qq.com>
AuthorDate: Mon Nov 16 15:12:12 2020 +0800
add linsense
---
.../org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java | 18 ++++++++++++++++++
1 file changed, 18 insertions(+)
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
index 9213b84..4a35e68 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
@@ -1,3 +1,21 @@
+/*
+ * 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.sql;
import static org.apache.iotdb.db.qp.constant.SQLConstant.TIME_PATH;
[iotdb] 01/09: 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_0.11
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit e7f93c46831be80aeabdf1b6a11addf23b2b3244
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 6c2beeb..8293218 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("");
}
}
[iotdb] 07/09: fix bugs
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_0.11
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 6c9a5884e988fb7a9f63baffa90826d3c7bd453b
Author: Boris <96...@qq.com>
AuthorDate: Mon Nov 16 15:55:55 2020 +0800
fix bugs
---
.../src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
index 4a35e68..4938ba3 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
@@ -1565,8 +1565,12 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
} else {
// upsert
alterTimeSeriesOperator.setAlterType(AlterType.UPSERT);
- parseAliasClause(ctx.aliasClause(), alterTimeSeriesOperator);
- parseTagClause(ctx.tagClause(), alterTimeSeriesOperator);
+ if(ctx.aliasClause() != null) {
+ parseAliasClause(ctx.aliasClause(), alterTimeSeriesOperator);
+ }
+ if(ctx.tagClause() != null) {
+ parseTagClause(ctx.tagClause(), alterTimeSeriesOperator);
+ }
if(ctx.attributeClause() != null) {
parseAttributeClause(ctx.attributeClause(), alterTimeSeriesOperator);
}
[iotdb] 09/09: update
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_0.11
in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit e2803be1f519b181a622ace8483280db7f9256d8
Author: Boris <96...@qq.com>
AuthorDate: Sat Dec 5 10:42:54 2020 +0800
update
---
.../main/java/org/apache/iotdb/db/qp/Planner.java | 22 ++++++++--------------
.../apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java | 2 +-
2 files changed, 9 insertions(+), 15 deletions(-)
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/Planner.java b/server/src/main/java/org/apache/iotdb/db/qp/Planner.java
index 4b6e79c..1fa57c4 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/Planner.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/Planner.java
@@ -18,14 +18,6 @@
*/
package org.apache.iotdb.db.qp;
-import static org.apache.iotdb.db.conf.IoTDBConstant.TIME;
-
-import java.time.ZoneId;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import org.apache.iotdb.db.conf.IoTDBConfig;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
import org.apache.iotdb.db.exception.metadata.IllegalPathException;
import org.apache.iotdb.db.exception.query.LogicalOperatorException;
import org.apache.iotdb.db.exception.query.LogicalOptimizeException;
@@ -34,12 +26,7 @@ import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.constant.SQLConstant;
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.FilterOperator;
-import org.apache.iotdb.db.qp.logical.crud.FromOperator;
-import org.apache.iotdb.db.qp.logical.crud.QueryOperator;
-import org.apache.iotdb.db.qp.logical.crud.SFWOperator;
-import org.apache.iotdb.db.qp.logical.crud.SelectOperator;
+import org.apache.iotdb.db.qp.logical.crud.*;
import org.apache.iotdb.db.qp.physical.PhysicalPlan;
import org.apache.iotdb.db.qp.strategy.LogicalGenerator;
import org.apache.iotdb.db.qp.strategy.PhysicalGenerator;
@@ -51,6 +38,13 @@ import org.apache.iotdb.db.query.control.QueryResourceManager;
import org.apache.iotdb.db.utils.TestOnly;
import org.apache.iotdb.service.rpc.thrift.TSRawDataQueryReq;
+import java.time.ZoneId;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static org.apache.iotdb.db.conf.IoTDBConstant.TIME;
+
/**
* provide a integration method for other user.
*/
diff --git a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
index 4938ba3..d87ea82 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
@@ -922,7 +922,7 @@ public class IoTDBSqlVisitor extends SqlBaseBaseVisitor<Operator> {
public Operator visitFillStatement(FillStatementContext ctx) {
parseFillClause(ctx.fillClause(), queryOp);
if(ctx.slimitClause() != null) {
- queryOp = (QueryOperator) visit(ctx.slimitClause());
+ parseSlimitClause(ctx.slimitClause(), queryOp);
}
if(ctx.alignByDeviceClauseOrDisableAlign() != null) {
if(ctx.alignByDeviceClauseOrDisableAlign().alignByDeviceClause() != null) {