This is an automated email from the ASF dual-hosted git repository.
rong pushed a commit to branch iotdb-1022-v2
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/iotdb-1022-v2 by this push:
new d98cd84 refactor removeWildcards() in ConcatPathOptimizer and fix
build errors
d98cd84 is described below
commit d98cd84de118300f7df3db4b7177c2c5bab6ed1b
Author: SteveYurongSu <[email protected]>
AuthorDate: Fri May 14 18:12:12 2021 +0800
refactor removeWildcards() in ConcatPathOptimizer and fix build errors
---
.../cluster/query/ClusterConcatPathOptimizer.java | 2 +-
.../cluster/query/ClusterPhysicalGenerator.java | 4 +-
.../query/ClusterPhysicalGeneratorTest.java | 10 +-
.../iotdb/db/qp/logical/crud/QueryOperator.java | 3 +-
.../qp/strategy/optimizer/ConcatPathOptimizer.java | 151 ++------------------
.../iotdb/db/qp/utils/PathNumberLimiter.java | 22 ---
.../apache/iotdb/db/qp/utils/WildcardsRemover.java | 158 +++++++++++++++++++++
.../iotdb/db/query/expression/Expression.java | 6 +
.../iotdb/db/query/expression/ResultColumn.java | 11 ++
.../query/expression/binary/BinaryExpression.java | 24 +++-
.../query/expression/unary/FunctionExpression.java | 11 ++
.../db/query/expression/unary/MinusExpression.java | 12 ++
.../expression/unary/NumberLiteralOperand.java | 7 +
.../query/expression/unary/TimeSeriesOperand.java | 10 ++
.../iotdb/db/qp/logical/IndexLogicalPlanTest.java | 47 +++---
.../iotdb/db/qp/logical/LogicalPlanSmallTest.java | 88 ++++++------
.../query/dataset/UDTFAlignByTimeDataSetTest.java | 45 ++----
17 files changed, 335 insertions(+), 276 deletions(-)
diff --git
a/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterConcatPathOptimizer.java
b/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterConcatPathOptimizer.java
index 5d67a8c..7be399a 100644
---
a/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterConcatPathOptimizer.java
+++
b/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterConcatPathOptimizer.java
@@ -30,7 +30,7 @@ import java.util.List;
public class ClusterConcatPathOptimizer extends ConcatPathOptimizer {
@Override
- protected Pair<List<PartialPath>, Integer> removeWildcard(PartialPath path,
int limit, int offset)
+ public Pair<List<PartialPath>, Integer> removeWildcard(PartialPath path, int
limit, int offset)
throws MetadataException {
return IoTDB.metaManager.getAllTimeseriesPathWithAlias(path, limit,
offset);
}
diff --git
a/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterPhysicalGenerator.java
b/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterPhysicalGenerator.java
index c074d92..ce620fa 100644
---
a/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterPhysicalGenerator.java
+++
b/cluster/src/main/java/org/apache/iotdb/cluster/query/ClusterPhysicalGenerator.java
@@ -26,7 +26,7 @@ import
org.apache.iotdb.db.exception.metadata.MetadataException;
import org.apache.iotdb.db.exception.query.QueryProcessException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.logical.Operator;
-import org.apache.iotdb.db.qp.logical.crud.SFWOperator;
+import org.apache.iotdb.db.qp.logical.crud.QueryOperator;
import
org.apache.iotdb.db.qp.logical.sys.LoadConfigurationOperator.LoadConfigurationOperatorType;
import org.apache.iotdb.db.qp.physical.PhysicalPlan;
import org.apache.iotdb.db.qp.physical.sys.LoadConfigurationPlan;
@@ -88,7 +88,7 @@ public class ClusterPhysicalGenerator extends
PhysicalGenerator {
public PhysicalPlan transformToPhysicalPlan(Operator operator, int fetchSize)
throws QueryProcessException {
// update storage groups before parsing query plans
- if (operator instanceof SFWOperator) {
+ if (operator instanceof QueryOperator) {
try {
getCMManager().syncMetaLeader();
} catch (MetadataException e) {
diff --git
a/cluster/src/test/java/org/apache/iotdb/cluster/query/ClusterPhysicalGeneratorTest.java
b/cluster/src/test/java/org/apache/iotdb/cluster/query/ClusterPhysicalGeneratorTest.java
index b6dc1f6..f1d7d57 100644
---
a/cluster/src/test/java/org/apache/iotdb/cluster/query/ClusterPhysicalGeneratorTest.java
+++
b/cluster/src/test/java/org/apache/iotdb/cluster/query/ClusterPhysicalGeneratorTest.java
@@ -28,11 +28,15 @@ 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.SelectOperator;
import org.apache.iotdb.db.qp.physical.crud.RawDataQueryPlan;
+import org.apache.iotdb.db.query.expression.ResultColumn;
+import org.apache.iotdb.db.query.expression.unary.TimeSeriesOperand;
import org.junit.Before;
import org.junit.Test;
import java.time.ZoneId;
+import java.util.ArrayList;
+import java.util.List;
import static org.junit.Assert.assertEquals;
@@ -53,7 +57,11 @@ public class ClusterPhysicalGeneratorTest extends
BaseQueryTest {
SelectOperator selectOperator =
new SelectOperator(SQLConstant.TOK_SELECT, ZoneId.systemDefault());
- selectOperator.setSuffixPathList(pathList);
+ List<ResultColumn> resultColumns = new ArrayList<>();
+ for (PartialPath partialPath : pathList) {
+ resultColumns.add(new ResultColumn(new TimeSeriesOperand(partialPath)));
+ }
+ selectOperator.setResultColumns(resultColumns);
FromOperator fromOperator = new FromOperator(SQLConstant.TOK_FROM);
fromOperator.addPrefixTablePath(new PartialPath(TestUtils.getTestSg(0)));
diff --git
a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/QueryOperator.java
b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/QueryOperator.java
index f80dcbb..e52dd92 100644
---
a/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/QueryOperator.java
+++
b/server/src/main/java/org/apache/iotdb/db/qp/logical/crud/QueryOperator.java
@@ -20,12 +20,13 @@ package org.apache.iotdb.db.qp.logical.crud;
import org.apache.iotdb.db.index.common.IndexType;
import org.apache.iotdb.db.qp.logical.Operator;
+import org.apache.iotdb.db.qp.logical.RootOperator;
import org.apache.iotdb.db.query.executor.fill.IFill;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
import java.util.Map;
-public class QueryOperator extends Operator {
+public class QueryOperator extends RootOperator {
private SelectOperator selectOperator;
private FromOperator fromOperator;
diff --git
a/server/src/main/java/org/apache/iotdb/db/qp/strategy/optimizer/ConcatPathOptimizer.java
b/server/src/main/java/org/apache/iotdb/db/qp/strategy/optimizer/ConcatPathOptimizer.java
index 31e0744..b36dab9 100644
---
a/server/src/main/java/org/apache/iotdb/db/qp/strategy/optimizer/ConcatPathOptimizer.java
+++
b/server/src/main/java/org/apache/iotdb/db/qp/strategy/optimizer/ConcatPathOptimizer.java
@@ -31,7 +31,7 @@ import org.apache.iotdb.db.qp.logical.crud.FromOperator;
import org.apache.iotdb.db.qp.logical.crud.FunctionOperator;
import org.apache.iotdb.db.qp.logical.crud.QueryOperator;
import org.apache.iotdb.db.qp.logical.crud.SelectOperator;
-import org.apache.iotdb.db.query.control.QueryResourceManager;
+import org.apache.iotdb.db.qp.utils.WildcardsRemover;
import org.apache.iotdb.db.query.expression.ResultColumn;
import org.apache.iotdb.db.service.IoTDB;
import org.apache.iotdb.tsfile.utils.Pair;
@@ -62,7 +62,7 @@ public class ConcatPathOptimizer implements ILogicalOptimizer
{
return queryOperator;
}
concatSelect(queryOperator);
- removeWildcardsInSelectPaths(queryOperator);
+ removeWildcardsInSelectPaths(queryOperator, fetchSize);
concatFilter(queryOperator);
return queryOperator;
}
@@ -96,145 +96,22 @@ public class ConcatPathOptimizer implements
ILogicalOptimizer {
queryOperator.getSelectOperator().setResultColumns(resultColumns);
}
- private void removeWildcardsInSelectPaths(
- List<PartialPath> afterConcatPaths,
- List<String> afterConcatAggregations,
- List<UDFContext> afterConcatUdfList,
- SelectOperator selectOperator,
- int finalLimit,
- int finalOffset,
- int maxDeduplicatedPathNum)
+ private void removeWildcardsInSelectPaths(QueryOperator queryOperator, int
fetchSize)
throws LogicalOptimizeException, PathNumOverLimitException {
-
- int maxDeduplicatedPathNum =
-
QueryResourceManager.getInstance().getMaxDeduplicatedPathNum(fetchSize);
- if (queryOperator.isLastQuery()) {
- // Dataset of last query actually has only three columns, so we
shouldn't limit the path num
- // while constructing logical plan
- // To avoid overflowing because logicalOptimize function may do
maxDeduplicatedPathNum + 1, we
- // set it to Integer.MAX_VALUE - 1
- maxDeduplicatedPathNum = Integer.MAX_VALUE - 1;
- }
-
- int seriesLimit = queryOperator.getSeriesLimit();
- int seriesOffset = queryOperator.getSeriesOffset();
- boolean needRemoveStar = queryOperator.getIndexType() == null;
-
- int offset = finalOffset;
- int limit =
- finalLimit == 0 || maxDeduplicatedPathNum < finalLimit
- ? maxDeduplicatedPathNum + 1
- : finalLimit;
- int consumed = 0;
-
- List<PartialPath> newSuffixPathList = new ArrayList<>();
- List<String> newAggregations = new ArrayList<>();
- List<UDFContext> newUdfList = new ArrayList<>();
-
- for (int i = 0; i < afterConcatPaths.size(); i++) {
- try {
- PartialPath afterConcatPath = afterConcatPaths.get(i);
-
- if (afterConcatPath == null) { // udf
- UDFContext originUdf = afterConcatUdfList.get(i);
- List<PartialPath> originPaths = originUdf.getPaths();
- List<List<PartialPath>> extendedPaths = new ArrayList<>();
-
- boolean atLeastOneSeriesNotExisted = false;
- for (PartialPath originPath : originPaths) {
- List<PartialPath> actualPaths = removeWildcard(originPath, 0,
0).left;
- if (actualPaths.isEmpty()) {
- atLeastOneSeriesNotExisted = true;
- break;
- }
- checkAndSetTsAlias(actualPaths, originPath);
- extendedPaths.add(actualPaths);
- }
- if (atLeastOneSeriesNotExisted) {
- continue;
- }
-
- List<List<PartialPath>> actualPaths = new ArrayList<>();
- cartesianProduct(extendedPaths, actualPaths, 0, new ArrayList<>());
-
- for (List<PartialPath> actualPath : actualPaths) {
- if (offset != 0) {
- --offset;
- continue;
- } else if (limit != 0) {
- --limit;
- } else {
- break;
- }
-
- newSuffixPathList.add(null);
- extendListSafely(afterConcatAggregations, i, newAggregations);
-
- newUdfList.add(
- new UDFContext(originUdf.getName(), originUdf.getAttributes(),
actualPath));
- }
- } else { // non-udf
- Pair<List<PartialPath>, Integer> pair =
removeWildcard(afterConcatPath, limit, offset);
- List<PartialPath> actualPaths = pair.left;
- checkAndSetTsAlias(actualPaths, afterConcatPath);
-
- for (PartialPath actualPath : actualPaths) {
- newSuffixPathList.add(actualPath);
- extendListSafely(afterConcatAggregations, i, newAggregations);
-
- newUdfList.add(null);
- }
-
- consumed += pair.right;
- if (offset != 0) {
- int delta = offset - pair.right;
- offset = Math.max(delta, 0);
- if (delta < 0) {
- limit += delta;
- }
- } else {
- limit -= pair.right;
- }
- }
-
- if (limit == 0) {
- if (maxDeduplicatedPathNum < newSuffixPathList.size()) {
- throw new PathNumOverLimitException(maxDeduplicatedPathNum);
- }
- break;
- }
- } catch (MetadataException e) {
- throw new LogicalOptimizeException("error when remove star: " +
e.getMessage());
- }
+ if (queryOperator.getIndexType() != null) {
+ return;
}
- if (consumed == 0 ? finalOffset != 0 : newSuffixPathList.isEmpty()) {
- throw new LogicalOptimizeException(
- String.format(
- "The value of SOFFSET (%d) is equal to or exceeds the number of
sequences (%d) that can actually be returned.",
- finalOffset, consumed));
- }
- selectOperator.setSuffixPathList(newSuffixPathList);
- selectOperator.setAggregations(newAggregations);
- selectOperator.setUdfList(newUdfList);
- }
-
- private void checkAndSetTsAlias(List<PartialPath> actualPaths, PartialPath
originPath)
- throws LogicalOptimizeException {
- if (originPath.isTsAliasExists()) {
- if (actualPaths.size() == 1) {
- actualPaths.get(0).setTsAlias(originPath.getTsAlias());
- } else if (actualPaths.size() >= 2) {
- throw new LogicalOptimizeException(
- "alias '" + originPath.getTsAlias() + "' can only be matched with
one time series");
+ WildcardsRemover wildcardsRemover = new WildcardsRemover(this,
queryOperator, fetchSize);
+ List<ResultColumn> resultColumns = new ArrayList<>();
+ for (ResultColumn resultColumn :
queryOperator.getSelectOperator().getResultColumns()) {
+ resultColumn.removeWildcards(wildcardsRemover, resultColumns);
+ if (wildcardsRemover.checkIfPathNumberIsOverLimit(resultColumns)) {
+ break;
}
}
- }
-
- private void removeWildcardsInSelectPaths(QueryOperator queryOperator) {
- if (queryOperator.getIndexType() != null) {
- return;
- }
+ wildcardsRemover.checkIfSoffsetIsExceeded(resultColumns);
+ queryOperator.getSelectOperator().setResultColumns(resultColumns);
}
private void concatFilter(QueryOperator queryOperator) throws
LogicalOptimizeException {
@@ -338,7 +215,7 @@ public class ConcatPathOptimizer implements
ILogicalOptimizer {
return retPaths;
}
- protected Pair<List<PartialPath>, Integer> removeWildcard(PartialPath path,
int limit, int offset)
+ public Pair<List<PartialPath>, Integer> removeWildcard(PartialPath path, int
limit, int offset)
throws MetadataException {
return IoTDB.metaManager.getAllTimeseriesPathWithAlias(path, limit,
offset);
}
diff --git
a/server/src/main/java/org/apache/iotdb/db/qp/utils/PathNumberLimiter.java
b/server/src/main/java/org/apache/iotdb/db/qp/utils/PathNumberLimiter.java
deleted file mode 100644
index d312fb8..0000000
--- a/server/src/main/java/org/apache/iotdb/db/qp/utils/PathNumberLimiter.java
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * 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.utils;
-
-public class PathNumberLimiter {}
diff --git
a/server/src/main/java/org/apache/iotdb/db/qp/utils/WildcardsRemover.java
b/server/src/main/java/org/apache/iotdb/db/qp/utils/WildcardsRemover.java
new file mode 100644
index 0000000..41696af
--- /dev/null
+++ b/server/src/main/java/org/apache/iotdb/db/qp/utils/WildcardsRemover.java
@@ -0,0 +1,158 @@
+/*
+ * 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.utils;
+
+import org.apache.iotdb.db.exception.metadata.MetadataException;
+import org.apache.iotdb.db.exception.query.LogicalOptimizeException;
+import org.apache.iotdb.db.exception.query.PathNumOverLimitException;
+import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.logical.crud.QueryOperator;
+import org.apache.iotdb.db.qp.strategy.optimizer.ConcatPathOptimizer;
+import org.apache.iotdb.db.query.control.QueryResourceManager;
+import org.apache.iotdb.db.query.expression.Expression;
+import org.apache.iotdb.db.query.expression.ResultColumn;
+import org.apache.iotdb.tsfile.utils.Pair;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class WildcardsRemover {
+
+ private final ConcatPathOptimizer concatPathOptimizer;
+
+ private final int maxDeduplicatedPathNum;
+ private final int soffset;
+
+ private int offset;
+ private int limit;
+ private int consumed;
+
+ public WildcardsRemover(
+ ConcatPathOptimizer concatPathOptimizer, QueryOperator queryOperator,
int fetchSize) {
+ this.concatPathOptimizer = concatPathOptimizer;
+
+ // Dataset of last query actually has only three columns, so we shouldn't
limit the path num
+ // while constructing logical plan
+ // To avoid overflowing because logicalOptimize function may do
maxDeduplicatedPathNum + 1, we
+ // set it to Integer.MAX_VALUE - 1
+ maxDeduplicatedPathNum =
+ queryOperator.isLastQuery()
+ ? Integer.MAX_VALUE - 1
+ :
QueryResourceManager.getInstance().getMaxDeduplicatedPathNum(fetchSize);
+ soffset = queryOperator.getSeriesOffset();
+ offset = soffset;
+
+ final int slimit = queryOperator.getSeriesLimit();
+ limit = slimit == 0 || maxDeduplicatedPathNum < slimit ?
maxDeduplicatedPathNum + 1 : slimit;
+
+ consumed = 0;
+ }
+
+ public List<PartialPath> removeWildcardFrom(PartialPath path) throws
LogicalOptimizeException {
+ try {
+ Pair<List<PartialPath>, Integer> pair =
+ concatPathOptimizer.removeWildcard(path, limit, offset);
+
+ checkAndSetTsAlias(path, pair.left);
+
+ consumed += pair.right;
+ if (offset != 0) {
+ int delta = offset - pair.right;
+ offset = Math.max(delta, 0);
+ if (delta < 0) {
+ limit += delta;
+ }
+ } else {
+ limit -= pair.right;
+ }
+
+ return pair.left;
+ } catch (MetadataException e) {
+ throw new LogicalOptimizeException("error occurred when removing star: "
+ e.getMessage());
+ }
+ }
+
+ private void checkAndSetTsAlias(PartialPath originPath, List<PartialPath>
actualPaths)
+ throws LogicalOptimizeException {
+ if (originPath.isTsAliasExists()) {
+ if (actualPaths.size() == 1) {
+ actualPaths.get(0).setTsAlias(originPath.getTsAlias());
+ } else if (actualPaths.size() >= 2) {
+ throw new LogicalOptimizeException(
+ "alias '" + originPath.getTsAlias() + "' can only be matched with
one time series");
+ }
+ }
+ }
+
+ public List<List<Expression>> removeWildcardsFrom(List<Expression>
expressions)
+ throws LogicalOptimizeException {
+ List<List<Expression>> extendedExpressions = new ArrayList<>();
+
+ boolean atLeastOneSeriesNotExisted = false;
+ for (Expression originExpression : expressions) {
+ List<Expression> actualExpressions = new ArrayList<>();
+ originExpression.removeWildcards(this, actualExpressions);
+ if (actualExpressions.isEmpty()) {
+ atLeastOneSeriesNotExisted = true;
+ break;
+ }
+ extendedExpressions.add(actualExpressions);
+ }
+ if (atLeastOneSeriesNotExisted) {
+ return extendedExpressions;
+ }
+
+ List<List<Expression>> actualExpressions = new ArrayList<>();
+ ConcatPathOptimizer.cartesianProduct(
+ extendedExpressions, actualExpressions, 0, new ArrayList<>());
+ for (@SuppressWarnings("squid:S1481") List<Expression> ignored :
actualExpressions) {
+ if (offset != 0) {
+ --offset;
+ } else if (limit != 0) {
+ --limit;
+ } else {
+ break;
+ }
+ }
+ return actualExpressions;
+ }
+
+ /** @return should break the loop or not */
+ public boolean checkIfPathNumberIsOverLimit(List<ResultColumn> resultColumns)
+ throws PathNumOverLimitException {
+ if (limit == 0) {
+ if (maxDeduplicatedPathNum < resultColumns.size()) {
+ throw new PathNumOverLimitException(maxDeduplicatedPathNum);
+ }
+ return true;
+ }
+ return false;
+ }
+
+ public void checkIfSoffsetIsExceeded(List<ResultColumn> resultColumns)
+ throws LogicalOptimizeException {
+ if (consumed == 0 ? soffset != 0 : resultColumns.isEmpty()) {
+ throw new LogicalOptimizeException(
+ String.format(
+ "The value of SOFFSET (%d) is equal to or exceeds the number of
sequences (%d) that can actually be returned.",
+ soffset, consumed));
+ }
+ }
+}
diff --git
a/server/src/main/java/org/apache/iotdb/db/query/expression/Expression.java
b/server/src/main/java/org/apache/iotdb/db/query/expression/Expression.java
index 70f5a85..94f888e 100644
--- a/server/src/main/java/org/apache/iotdb/db/query/expression/Expression.java
+++ b/server/src/main/java/org/apache/iotdb/db/query/expression/Expression.java
@@ -20,7 +20,9 @@
package org.apache.iotdb.db.query.expression;
import org.apache.iotdb.db.exception.metadata.MetadataException;
+import org.apache.iotdb.db.exception.query.LogicalOptimizeException;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.utils.WildcardsRemover;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
import java.util.List;
@@ -41,4 +43,8 @@ public abstract class Expression {
public abstract TSDataType dataType() throws MetadataException;
public abstract void concat(List<PartialPath> prefixPaths, List<Expression>
resultExpressions);
+
+ public abstract void removeWildcards(
+ WildcardsRemover wildcardsRemover, List<Expression> resultExpressions)
+ throws LogicalOptimizeException;
}
diff --git
a/server/src/main/java/org/apache/iotdb/db/query/expression/ResultColumn.java
b/server/src/main/java/org/apache/iotdb/db/query/expression/ResultColumn.java
index 3289c53..dd4a149 100644
---
a/server/src/main/java/org/apache/iotdb/db/query/expression/ResultColumn.java
+++
b/server/src/main/java/org/apache/iotdb/db/query/expression/ResultColumn.java
@@ -19,7 +19,9 @@
package org.apache.iotdb.db.query.expression;
+import org.apache.iotdb.db.exception.query.LogicalOptimizeException;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.utils.WildcardsRemover;
import java.util.ArrayList;
import java.util.List;
@@ -47,6 +49,15 @@ public class ResultColumn {
}
}
+ public void removeWildcards(WildcardsRemover wildcardsRemover,
List<ResultColumn> resultColumns)
+ throws LogicalOptimizeException {
+ List<Expression> resultExpressions = new ArrayList<>();
+ expression.removeWildcards(wildcardsRemover, resultExpressions);
+ for (Expression resultExpression : resultExpressions) {
+ resultColumns.add(new ResultColumn(resultExpression, alias));
+ }
+ }
+
public Expression getExpression() {
return expression;
}
diff --git
a/server/src/main/java/org/apache/iotdb/db/query/expression/binary/BinaryExpression.java
b/server/src/main/java/org/apache/iotdb/db/query/expression/binary/BinaryExpression.java
index 97047e5..6f83c60 100644
---
a/server/src/main/java/org/apache/iotdb/db/query/expression/binary/BinaryExpression.java
+++
b/server/src/main/java/org/apache/iotdb/db/query/expression/binary/BinaryExpression.java
@@ -19,7 +19,9 @@
package org.apache.iotdb.db.query.expression.binary;
+import org.apache.iotdb.db.exception.query.LogicalOptimizeException;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.utils.WildcardsRemover;
import org.apache.iotdb.db.query.expression.Expression;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
@@ -54,8 +56,28 @@ public abstract class BinaryExpression extends Expression {
List<Expression> rightExpressions = new ArrayList<>();
rightExpression.concat(prefixPaths, rightExpressions);
+ reconstruct(leftExpressions, rightExpressions, resultExpressions);
+ }
+
+ @Override
+ public final void removeWildcards(
+ WildcardsRemover wildcardsRemover, List<Expression> resultExpressions)
+ throws LogicalOptimizeException {
+ List<Expression> leftExpressions = new ArrayList<>();
+ leftExpression.removeWildcards(wildcardsRemover, leftExpressions);
+
+ List<Expression> rightExpressions = new ArrayList<>();
+ rightExpression.removeWildcards(wildcardsRemover, rightExpressions);
+
+ reconstruct(leftExpressions, rightExpressions, resultExpressions);
+ }
+
+ private void reconstruct(
+ List<Expression> leftExpressions,
+ List<Expression> rightExpressions,
+ List<Expression> resultExpressions) {
for (Expression le : leftExpressions) {
- for (Expression re : resultExpressions) {
+ for (Expression re : rightExpressions) {
switch (operator()) {
case "+":
resultExpressions.add(new AdditionExpression(le, re));
diff --git
a/server/src/main/java/org/apache/iotdb/db/query/expression/unary/FunctionExpression.java
b/server/src/main/java/org/apache/iotdb/db/query/expression/unary/FunctionExpression.java
index b5b4950..de337a0 100644
---
a/server/src/main/java/org/apache/iotdb/db/query/expression/unary/FunctionExpression.java
+++
b/server/src/main/java/org/apache/iotdb/db/query/expression/unary/FunctionExpression.java
@@ -20,9 +20,11 @@
package org.apache.iotdb.db.query.expression.unary;
import org.apache.iotdb.db.exception.metadata.MetadataException;
+import org.apache.iotdb.db.exception.query.LogicalOptimizeException;
import org.apache.iotdb.db.metadata.PartialPath;
import org.apache.iotdb.db.qp.constant.SQLConstant;
import org.apache.iotdb.db.qp.strategy.optimizer.ConcatPathOptimizer;
+import org.apache.iotdb.db.qp.utils.WildcardsRemover;
import org.apache.iotdb.db.query.expression.Expression;
import org.apache.iotdb.tsfile.exception.NotImplementedException;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
@@ -118,6 +120,15 @@ public class FunctionExpression extends Expression {
}
}
+ @Override
+ public void removeWildcards(WildcardsRemover wildcardsRemover,
List<Expression> resultExpressions)
+ throws LogicalOptimizeException {
+ for (List<Expression> functionExpression :
wildcardsRemover.removeWildcardsFrom(expressions)) {
+ resultExpressions.add(
+ new FunctionExpression(functionName, functionAttributes,
functionExpression));
+ }
+ }
+
public List<TSDataType> getDataTypes() throws MetadataException {
if (dataTypes == null) {
dataTypes = new ArrayList<>();
diff --git
a/server/src/main/java/org/apache/iotdb/db/query/expression/unary/MinusExpression.java
b/server/src/main/java/org/apache/iotdb/db/query/expression/unary/MinusExpression.java
index 3dd0a8f..9ad761d 100644
---
a/server/src/main/java/org/apache/iotdb/db/query/expression/unary/MinusExpression.java
+++
b/server/src/main/java/org/apache/iotdb/db/query/expression/unary/MinusExpression.java
@@ -20,7 +20,9 @@
package org.apache.iotdb.db.query.expression.unary;
import org.apache.iotdb.db.exception.metadata.MetadataException;
+import org.apache.iotdb.db.exception.query.LogicalOptimizeException;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.utils.WildcardsRemover;
import org.apache.iotdb.db.query.expression.Expression;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
@@ -54,6 +56,16 @@ public class MinusExpression extends Expression {
}
@Override
+ public void removeWildcards(WildcardsRemover wildcardsRemover,
List<Expression> resultExpressions)
+ throws LogicalOptimizeException {
+ List<Expression> resultExpressionsForRecursion = new ArrayList<>();
+ expression.removeWildcards(wildcardsRemover,
resultExpressionsForRecursion);
+ for (Expression resultExpression : resultExpressionsForRecursion) {
+ resultExpressions.add(new MinusExpression(resultExpression));
+ }
+ }
+
+ @Override
public String toString() {
return "-" + expression.toString();
}
diff --git
a/server/src/main/java/org/apache/iotdb/db/query/expression/unary/NumberLiteralOperand.java
b/server/src/main/java/org/apache/iotdb/db/query/expression/unary/NumberLiteralOperand.java
index e0868ac..7c5f3fc 100644
---
a/server/src/main/java/org/apache/iotdb/db/query/expression/unary/NumberLiteralOperand.java
+++
b/server/src/main/java/org/apache/iotdb/db/query/expression/unary/NumberLiteralOperand.java
@@ -20,6 +20,7 @@
package org.apache.iotdb.db.query.expression.unary;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.utils.WildcardsRemover;
import org.apache.iotdb.db.query.expression.Expression;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
@@ -44,6 +45,12 @@ public class NumberLiteralOperand extends Expression {
}
@Override
+ public void removeWildcards(
+ WildcardsRemover wildcardsRemover, List<Expression> resultExpressions) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
public String toString() {
return String.valueOf(literal);
}
diff --git
a/server/src/main/java/org/apache/iotdb/db/query/expression/unary/TimeSeriesOperand.java
b/server/src/main/java/org/apache/iotdb/db/query/expression/unary/TimeSeriesOperand.java
index 429e509..d2ba984 100644
---
a/server/src/main/java/org/apache/iotdb/db/query/expression/unary/TimeSeriesOperand.java
+++
b/server/src/main/java/org/apache/iotdb/db/query/expression/unary/TimeSeriesOperand.java
@@ -20,7 +20,9 @@
package org.apache.iotdb.db.query.expression.unary;
import org.apache.iotdb.db.exception.metadata.MetadataException;
+import org.apache.iotdb.db.exception.query.LogicalOptimizeException;
import org.apache.iotdb.db.metadata.PartialPath;
+import org.apache.iotdb.db.qp.utils.WildcardsRemover;
import org.apache.iotdb.db.query.expression.Expression;
import org.apache.iotdb.db.service.IoTDB;
import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
@@ -64,6 +66,14 @@ public class TimeSeriesOperand extends Expression {
}
@Override
+ public void removeWildcards(WildcardsRemover wildcardsRemover,
List<Expression> resultExpressions)
+ throws LogicalOptimizeException {
+ for (PartialPath actualPath : wildcardsRemover.removeWildcardFrom(path)) {
+ resultExpressions.add(new TimeSeriesOperand(actualPath));
+ }
+ }
+
+ @Override
public String toString() {
return path.toString();
}
diff --git
a/server/src/test/java/org/apache/iotdb/db/qp/logical/IndexLogicalPlanTest.java
b/server/src/test/java/org/apache/iotdb/db/qp/logical/IndexLogicalPlanTest.java
index 05e7d0a..ddba790 100644
---
a/server/src/test/java/org/apache/iotdb/db/qp/logical/IndexLogicalPlanTest.java
+++
b/server/src/test/java/org/apache/iotdb/db/qp/logical/IndexLogicalPlanTest.java
@@ -41,24 +41,19 @@ import static
org.apache.iotdb.db.index.common.IndexConstant.TOP_K;
public class IndexLogicalPlanTest {
- private LogicalGenerator generator;
-
@Before
- public void before() {
- generator = new LogicalGenerator();
- }
+ public void before() {}
@Test
public void testParseCreateIndexWholeMatching() {
String sqlStr =
"CREATE INDEX ON root.Ery.*.Glu WHERE time > 50 WITH INDEX=RTREE_PAA,
PAA_dim=8";
- Operator op = generator.generate(sqlStr, ZoneId.systemDefault());
+ Operator op = LogicalGenerator.generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(CreateIndexOperator.class, op.getClass());
CreateIndexOperator createOperator = (CreateIndexOperator) op;
Assert.assertEquals(OperatorType.CREATE_INDEX, createOperator.getType());
- Assert.assertNotNull(createOperator.getSelectedPaths());
- Assert.assertEquals("root.Ery.*.Glu",
createOperator.getSelectedPaths().get(0).toString());
- Assert.assertNull(createOperator.getFromOperator());
+ Assert.assertNotNull(createOperator.getPaths());
+ Assert.assertEquals("root.Ery.*.Glu",
createOperator.getPaths().get(0).toString());
Assert.assertEquals(IndexType.RTREE_PAA, createOperator.getIndexType());
Assert.assertEquals(50, createOperator.getTime());
Assert.assertEquals(1, createOperator.getProps().size());
@@ -68,14 +63,12 @@ public class IndexLogicalPlanTest {
@Test
public void testParseCreateIndexSubMatching() {
String sqlStr = "CREATE INDEX ON root.Wind.AZQ02.Speed WITH
INDEX=ELB_INDEX, BLOCK_SIZE=5";
- Operator op = generator.generate(sqlStr, ZoneId.systemDefault());
+ Operator op = LogicalGenerator.generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(CreateIndexOperator.class, op.getClass());
CreateIndexOperator createOperator = (CreateIndexOperator) op;
Assert.assertEquals(OperatorType.CREATE_INDEX, createOperator.getType());
- Assert.assertNotNull(createOperator.getSelectedPaths());
- Assert.assertEquals(
- "root.Wind.AZQ02.Speed",
createOperator.getSelectedPaths().get(0).toString());
- Assert.assertNull(createOperator.getFromOperator());
+ Assert.assertNotNull(createOperator.getPaths());
+ Assert.assertEquals("root.Wind.AZQ02.Speed",
createOperator.getPaths().get(0).toString());
Assert.assertEquals(IndexType.ELB_INDEX, createOperator.getIndexType());
Assert.assertEquals(1, createOperator.getProps().size());
Assert.assertEquals("5", createOperator.getProps().get(BLOCK_SIZE));
@@ -84,27 +77,24 @@ public class IndexLogicalPlanTest {
@Test
public void testParseDropIndexWholeMatching() {
String sqlStr = "DROP INDEX RTREE_PAA ON root.Ery.*.Glu";
- Operator op = generator.generate(sqlStr, ZoneId.systemDefault());
+ Operator op = LogicalGenerator.generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(DropIndexOperator.class, op.getClass());
DropIndexOperator dropIndexOperator = (DropIndexOperator) op;
Assert.assertEquals(OperatorType.DROP_INDEX, dropIndexOperator.getType());
- Assert.assertNotNull(dropIndexOperator.getSelectedPaths());
- Assert.assertEquals("root.Ery.*.Glu",
dropIndexOperator.getSelectedPaths().get(0).toString());
- Assert.assertNull(dropIndexOperator.getFromOperator());
+ Assert.assertNotNull(dropIndexOperator.getPaths());
+ Assert.assertEquals("root.Ery.*.Glu",
dropIndexOperator.getPaths().get(0).toString());
Assert.assertEquals(IndexType.RTREE_PAA, dropIndexOperator.getIndexType());
}
@Test
public void testParseDropIndexSubMatching() {
String sqlStr = "DROP INDEX ELB_INDEX ON root.Wind.AZQ02.Speed";
- Operator op = generator.generate(sqlStr, ZoneId.systemDefault());
+ Operator op = LogicalGenerator.generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(DropIndexOperator.class, op.getClass());
DropIndexOperator dropIndexOperator = (DropIndexOperator) op;
Assert.assertEquals(OperatorType.DROP_INDEX, dropIndexOperator.getType());
- Assert.assertNotNull(dropIndexOperator.getSelectedPaths());
- Assert.assertEquals(
- "root.Wind.AZQ02.Speed",
dropIndexOperator.getSelectedPaths().get(0).toString());
- Assert.assertNull(dropIndexOperator.getFromOperator());
+ Assert.assertNotNull(dropIndexOperator.getPaths());
+ Assert.assertEquals("root.Wind.AZQ02.Speed",
dropIndexOperator.getPaths().get(0).toString());
Assert.assertEquals(IndexType.ELB_INDEX, dropIndexOperator.getIndexType());
}
@@ -112,11 +102,13 @@ public class IndexLogicalPlanTest {
public void testParseQueryIndexWholeMatching() {
String sqlStr =
"SELECT TOP 2 Glu FROM root.Ery.* WHERE Glu LIKE (0, 120, 20, 80, 120,
100, 80, 0)";
- Operator op = generator.generate(sqlStr, ZoneId.systemDefault());
+ Operator op = LogicalGenerator.generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, op.getClass());
QueryOperator queryOperator = (QueryOperator) op;
Assert.assertEquals(OperatorType.QUERY, queryOperator.getType());
- Assert.assertEquals("Glu",
queryOperator.getExpressions().get(0).getFullPath());
+ Assert.assertEquals(
+ "Glu",
+
queryOperator.getSelectOperator().getResultColumns().get(0).getExpression().toString());
Assert.assertEquals(
"root.Ery.*",
queryOperator.getFromOperator().getPrefixPaths().get(0).getFullPath());
Assert.assertEquals(IndexType.RTREE_PAA, queryOperator.getIndexType());
@@ -134,11 +126,12 @@ public class IndexLogicalPlanTest {
+ "CONTAIN (15, 14, 12, 12, 12, 11) WITH TOLERANCE 1 "
+ "CONCAT (10, 20, 25, 24, 14, 8) WITH TOLERANCE 2 "
+ "CONCAT (8, 9, 10, 14, 15, 15) WITH TOLERANCE 1";
- Operator op = generator.generate(sqlStr, ZoneId.systemDefault());
+ Operator op = LogicalGenerator.generate(sqlStr, ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, op.getClass());
QueryOperator queryOperator = (QueryOperator) op;
Assert.assertEquals(OperatorType.QUERY, queryOperator.getType());
- Assert.assertEquals("Speed",
queryOperator.getExpressions().get(0).getFullPath());
+ Assert.assertEquals(
+ "Speed",
queryOperator.getSelectOperator().getResultColumns().get(0).toString());
Assert.assertEquals(
"root.Wind.AZQ02",
queryOperator.getFromOperator().getPrefixPaths().get(0).getFullPath());
Assert.assertEquals(IndexType.ELB_INDEX, queryOperator.getIndexType());
diff --git
a/server/src/test/java/org/apache/iotdb/db/qp/logical/LogicalPlanSmallTest.java
b/server/src/test/java/org/apache/iotdb/db/qp/logical/LogicalPlanSmallTest.java
index 218bf7d..d2e428d 100644
---
a/server/src/test/java/org/apache/iotdb/db/qp/logical/LogicalPlanSmallTest.java
+++
b/server/src/test/java/org/apache/iotdb/db/qp/logical/LogicalPlanSmallTest.java
@@ -33,7 +33,6 @@ import org.apache.iotdb.db.service.IoTDB;
import org.antlr.v4.runtime.misc.ParseCancellationException;
import org.junit.Assert;
-import org.junit.Before;
import org.junit.Test;
import java.time.ZoneId;
@@ -41,18 +40,11 @@ import java.util.ArrayList;
public class LogicalPlanSmallTest {
- private LogicalGenerator logicalGenerator;
-
- @Before
- public void before() {
- logicalGenerator = new LogicalGenerator();
- }
-
@Test
public void testLimit() {
String sqlStr = "select * from root.vehicle.d1 limit 10";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertEquals(10, ((QueryOperator) operator).getRowLimit());
Assert.assertEquals(0, ((QueryOperator) operator).getRowOffset());
@@ -64,7 +56,7 @@ public class LogicalPlanSmallTest {
public void testOffset() {
String sqlStr = "select * from root.vehicle.d1 limit 10 offset 20";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertEquals(10, ((QueryOperator) operator).getRowLimit());
Assert.assertEquals(20, ((QueryOperator) operator).getRowOffset());
@@ -76,7 +68,7 @@ public class LogicalPlanSmallTest {
public void testSlimit() {
String sqlStr = "select * from root.vehicle.d1 limit 10 slimit 1";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertEquals(10, ((QueryOperator) operator).getRowLimit());
Assert.assertEquals(0, ((QueryOperator) operator).getRowOffset());
@@ -89,7 +81,7 @@ public class LogicalPlanSmallTest {
String sqlStr =
"select * from root.vehicle.d1 where s1 < 20 and time <= now() limit
50 slimit 10 soffset 100";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertEquals(50, ((QueryOperator) operator).getRowLimit());
Assert.assertEquals(0, ((QueryOperator) operator).getRowOffset());
@@ -102,7 +94,7 @@ public class LogicalPlanSmallTest {
String sqlStr =
"select * from root.vehicle.d1 where s1 < 20 and timestamp <= now()
limit 50 slimit 10 soffset 100";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertEquals(50, ((QueryOperator) operator).getRowLimit());
Assert.assertEquals(0, ((QueryOperator) operator).getRowOffset());
@@ -115,7 +107,7 @@ public class LogicalPlanSmallTest {
String sqlStr =
"select * from root.vehicle.d1 where s1 < 20 and time <= now() limit
1111111111111111111111";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
// expected to throw SQLParserException: Out of range. LIMIT <N>: N should
be Int32.
}
@@ -123,7 +115,7 @@ public class LogicalPlanSmallTest {
public void testLimitNotPositive() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and time <=
now() limit 0";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
// expected to throw SQLParserException: LIMIT <N>: N should be greater
than 0.
}
@@ -133,7 +125,7 @@ public class LogicalPlanSmallTest {
"select * from root.vehicle.d1 where s1 < 20 and time <= now() "
+ "limit 1 offset 1111111111111111111111";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
// expected to throw SQLParserException: Out of range. OFFSET
<OFFSETValue>: OFFSETValue should
// be Int32.
}
@@ -143,7 +135,7 @@ public class LogicalPlanSmallTest {
String sqlStr =
"select * from root.vehicle.d1 where s1 < 20 and time <= now() limit 1
offset -1";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
// expected to throw SQLParserException: OFFSET <OFFSETValue>: OFFSETValue
should >= 0.
}
@@ -152,7 +144,7 @@ public class LogicalPlanSmallTest {
String sqlStr =
"select * from root.vehicle.d1 where s1 < 20 and time <= now() slimit
1111111111111111111111";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
// expected to throw SQLParserException: Out of range. SLIMIT <SN>: SN
should be Int32.
}
@@ -160,7 +152,7 @@ public class LogicalPlanSmallTest {
public void testSlimitNotPositive() {
String sqlStr = "select * from root.vehicle.d1 where s1 < 20 and time <=
now() slimit 0";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
// expected to throw SQLParserException: SLIMIT <SN>: SN should be greater
than 0.
}
@@ -170,7 +162,7 @@ public class LogicalPlanSmallTest {
"select * from root.vehicle.d1 where s1 < 20 and time <= now() "
+ "slimit 1 soffset 1111111111111111111111";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
// expected to throw SQLParserException: Out of range. SOFFSET
<SOFFSETValue>: SOFFSETValue
// should be Int32.
}
@@ -180,7 +172,7 @@ public class LogicalPlanSmallTest {
String sqlStr =
"select * from root.vehicle.d1 where s1 < 20 and time <= now() slimit
1 soffset 1";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
Assert.assertEquals(1, ((QueryOperator) operator).getSeriesOffset());
Assert.assertEquals(1, ((QueryOperator) operator).getSeriesLimit());
}
@@ -190,7 +182,7 @@ public class LogicalPlanSmallTest {
String sqlStr =
"select s1 from root.vehicle.d1 where s1 < 20 and time <= now() slimit
2 soffset 1";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
IoTDB.metaManager.init();
ConcatPathOptimizer concatPathOptimizer = new ConcatPathOptimizer();
concatPathOptimizer.transform(operator, 1000);
@@ -203,7 +195,7 @@ public class LogicalPlanSmallTest {
public void testDeleteStorageGroup() throws IllegalPathException {
String sqlStr = "delete storage group root.vehicle.d1";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (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));
@@ -213,7 +205,7 @@ public class LogicalPlanSmallTest {
public void testDisableAlign() {
String sqlStr = "select * from root.vehicle disable align";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertFalse(((QueryOperator) operator).isAlignByTime());
}
@@ -222,7 +214,7 @@ public class LogicalPlanSmallTest {
public void testNotDisableAlign() {
String sqlStr = "select * from root.vehicle";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
Assert.assertEquals(QueryOperator.class, operator.getClass());
Assert.assertTrue(((QueryOperator) operator).isAlignByTime());
}
@@ -231,23 +223,23 @@ public class LogicalPlanSmallTest {
public void testDisableAlignConflictAlignByDevice() {
String sqlStr = "select * from root.vehicle disable align align by device";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
+ (RootOperator) LogicalGenerator.generate(sqlStr,
ZoneId.systemDefault());
}
@Test
public void testChineseCharacter() throws IllegalPathException {
String sqlStr1 = "set storage group to root.一级";
RootOperator operator =
- (RootOperator) logicalGenerator.generate(sqlStr1,
ZoneId.systemDefault());
+ (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) logicalGenerator.generate(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("*"));
- Assert.assertEquals(paths, ((QueryOperator) operator).getExpressions());
+ Assert.assertEquals(paths, ((QueryOperator)
operator).getSelectOperator().getPaths());
}
@Test
@@ -263,7 +255,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 = logicalGenerator.generate(sql, ZoneId.systemDefault());
+ Operator op = LogicalGenerator.generate(sql, ZoneId.systemDefault());
Assert.assertEquals(DeleteDataOperator.class, op.getClass());
} catch (ParseCancellationException ignored) {
}
@@ -272,47 +264,47 @@ public class LogicalPlanSmallTest {
@Test
public void testRangeDelete() throws IllegalPathException {
String sql1 = "delete from root.d1.s1 where time>=1 and time < 3";
- Operator op = logicalGenerator.generate(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"));
- Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
+ Assert.assertEquals(paths, ((DeleteDataOperator) op).getPaths());
Assert.assertEquals(1, ((DeleteDataOperator) op).getStartTime());
Assert.assertEquals(2, ((DeleteDataOperator) op).getEndTime());
String sql2 = "delete from root.d1.s1 where time>=1";
- op = logicalGenerator.generate(sql2, ZoneId.systemDefault());
- Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
+ op = LogicalGenerator.generate(sql2, ZoneId.systemDefault());
+ Assert.assertEquals(paths, ((DeleteDataOperator) op).getPaths());
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 = logicalGenerator.generate(sql3, ZoneId.systemDefault());
- Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
+ op = LogicalGenerator.generate(sql3, ZoneId.systemDefault());
+ Assert.assertEquals(paths, ((DeleteDataOperator) op).getPaths());
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 = logicalGenerator.generate(sql4, ZoneId.systemDefault());
- Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
+ op = LogicalGenerator.generate(sql4, ZoneId.systemDefault());
+ Assert.assertEquals(paths, ((DeleteDataOperator) op).getPaths());
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 = logicalGenerator.generate(sql5, ZoneId.systemDefault());
- Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
+ op = LogicalGenerator.generate(sql5, ZoneId.systemDefault());
+ Assert.assertEquals(paths, ((DeleteDataOperator) op).getPaths());
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 = logicalGenerator.generate(sql6, ZoneId.systemDefault());
- Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
+ op = LogicalGenerator.generate(sql6, ZoneId.systemDefault());
+ Assert.assertEquals(paths, ((DeleteDataOperator) op).getPaths());
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 = logicalGenerator.generate(sql7, ZoneId.systemDefault());
- Assert.assertEquals(paths, ((DeleteDataOperator) op).getSelectedPaths());
+ op = LogicalGenerator.generate(sql7, ZoneId.systemDefault());
+ Assert.assertEquals(paths, ((DeleteDataOperator) op).getPaths());
Assert.assertEquals(6, ((DeleteDataOperator) op).getStartTime());
Assert.assertEquals(Long.MAX_VALUE, ((DeleteDataOperator)
op).getEndTime());
}
@@ -322,7 +314,7 @@ public class LogicalPlanSmallTest {
String sql = "delete from root.d1.s1 where time>=1 and time < 3 or time
>1";
String errorMsg = null;
try {
- logicalGenerator.generate(sql, ZoneId.systemDefault());
+ LogicalGenerator.generate(sql, ZoneId.systemDefault());
} catch (SQLParserException e) {
errorMsg = e.getMessage();
}
@@ -334,7 +326,7 @@ public class LogicalPlanSmallTest {
sql = "delete from root.d1.s1 where time>=1 or time < 3";
errorMsg = null;
try {
- logicalGenerator.generate(sql, ZoneId.systemDefault());
+ LogicalGenerator.generate(sql, ZoneId.systemDefault());
} catch (SQLParserException e) {
errorMsg = e.getMessage();
}
@@ -346,7 +338,7 @@ public class LogicalPlanSmallTest {
String sql7 = "delete from root.d1.s1 where time = 1 and time < -1";
errorMsg = null;
try {
- logicalGenerator.generate(sql7, ZoneId.systemDefault());
+ LogicalGenerator.generate(sql7, ZoneId.systemDefault());
} catch (RuntimeException e) {
errorMsg = e.getMessage();
}
@@ -355,7 +347,7 @@ public class LogicalPlanSmallTest {
sql = "delete from root.d1.s1 where time > 5 and time <= 0";
errorMsg = null;
try {
- logicalGenerator.generate(sql, ZoneId.systemDefault());
+ LogicalGenerator.generate(sql, ZoneId.systemDefault());
} catch (SQLParserException e) {
errorMsg = e.getMessage();
}
diff --git
a/server/src/test/java/org/apache/iotdb/db/query/dataset/UDTFAlignByTimeDataSetTest.java
b/server/src/test/java/org/apache/iotdb/db/query/dataset/UDTFAlignByTimeDataSetTest.java
index f8b8c50..47e7ade 100644
---
a/server/src/test/java/org/apache/iotdb/db/query/dataset/UDTFAlignByTimeDataSetTest.java
+++
b/server/src/test/java/org/apache/iotdb/db/query/dataset/UDTFAlignByTimeDataSetTest.java
@@ -171,10 +171,7 @@ public class UDTFAlignByTimeDataSetTest {
Path path = queryPlan.getPaths().get(i);
String columnName =
path == null
- ? queryPlan
- .getExecutorByOriginalOutputColumnIndex(i)
- .getExpression()
- .getColumnName()
+ ?
queryPlan.getExecutorByOriginalOutputColumnIndex(i).getExpression().toString()
: path.getFullPath();
originalIndex2FieldIndex.add(path2Index.get(columnName));
}
@@ -236,10 +233,7 @@ public class UDTFAlignByTimeDataSetTest {
Path path = queryPlan.getPaths().get(i);
String columnName =
path == null
- ? queryPlan
- .getExecutorByOriginalOutputColumnIndex(i)
- .getExpression()
- .getColumnName()
+ ?
queryPlan.getExecutorByOriginalOutputColumnIndex(i).getExpression().toString()
: path.getFullPath();
originalIndex2FieldIndex.add(path2Index.get(columnName));
}
@@ -286,10 +280,7 @@ public class UDTFAlignByTimeDataSetTest {
Path path = queryPlan.getPaths().get(i);
String columnName =
path == null
- ? queryPlan
- .getExecutorByOriginalOutputColumnIndex(i)
- .getExpression()
- .getColumnName()
+ ?
queryPlan.getExecutorByOriginalOutputColumnIndex(i).getExpression().toString()
: path.getFullPath();
originalIndex2FieldIndex.add(path2Index.get(columnName));
}
@@ -348,10 +339,7 @@ public class UDTFAlignByTimeDataSetTest {
Path path = queryPlan.getPaths().get(i);
String columnName =
path == null
- ? queryPlan
- .getExecutorByOriginalOutputColumnIndex(i)
- .getExpression()
- .getColumnName()
+ ?
queryPlan.getExecutorByOriginalOutputColumnIndex(i).getExpression().toString()
: path.getFullPath();
originalIndex2FieldIndex.add(path2Index.get(columnName));
}
@@ -424,10 +412,7 @@ public class UDTFAlignByTimeDataSetTest {
Path path = queryPlan.getPaths().get(i);
String columnName =
path == null
- ? queryPlan
- .getExecutorByOriginalOutputColumnIndex(i)
- .getExpression()
- .getColumnName()
+ ?
queryPlan.getExecutorByOriginalOutputColumnIndex(i).getExpression().toString()
: path.getFullPath();
originalIndex2FieldIndex.add(path2Index.get(columnName));
}
@@ -483,10 +468,7 @@ public class UDTFAlignByTimeDataSetTest {
Path path = queryPlan.getPaths().get(i);
String columnName =
path == null
- ? queryPlan
- .getExecutorByOriginalOutputColumnIndex(i)
- .getExpression()
- .getColumnName()
+ ?
queryPlan.getExecutorByOriginalOutputColumnIndex(i).getExpression().toString()
: path.getFullPath();
originalIndex2FieldIndex.add(path2Index.get(columnName));
}
@@ -551,10 +533,7 @@ public class UDTFAlignByTimeDataSetTest {
Path path = queryPlan.getPaths().get(i);
String columnName =
path == null
- ? queryPlan
- .getExecutorByOriginalOutputColumnIndex(i)
- .getExpression()
- .getColumnName()
+ ?
queryPlan.getExecutorByOriginalOutputColumnIndex(i).getExpression().toString()
: path.getFullPath();
originalIndex2FieldIndex.add(path2Index.get(columnName));
}
@@ -625,10 +604,7 @@ public class UDTFAlignByTimeDataSetTest {
Path path = queryPlan.getPaths().get(i);
String columnName =
path == null
- ? queryPlan
- .getExecutorByOriginalOutputColumnIndex(i)
- .getExpression()
- .getColumnName()
+ ?
queryPlan.getExecutorByOriginalOutputColumnIndex(i).getExpression().toString()
: path.getFullPath();
originalIndex2FieldIndex.add(path2Index.get(columnName));
}
@@ -681,10 +657,7 @@ public class UDTFAlignByTimeDataSetTest {
Path path = queryPlan.getPaths().get(i);
String columnName =
path == null
- ? queryPlan
- .getExecutorByOriginalOutputColumnIndex(i)
- .getExpression()
- .getColumnName()
+ ?
queryPlan.getExecutorByOriginalOutputColumnIndex(i).getExpression().toString()
: path.getFullPath();
originalIndex2FieldIndex.add(path2Index.get(columnName));
}
