You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by ja...@apache.org on 2022/07/27 08:34:41 UTC
[iotdb] branch master updated: [IOTDB-3952] Delete duplicated time filter in FilterOperator (#6780)
This is an automated email from the ASF dual-hosted git repository.
jackietien pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/master by this push:
new 9babfd35de [IOTDB-3952] Delete duplicated time filter in FilterOperator (#6780)
9babfd35de is described below
commit 9babfd35de59c16ce46829e2f15041eb9721361a
Author: Liao Lanyu <10...@users.noreply.github.com>
AuthorDate: Wed Jul 27 16:34:36 2022 +0800
[IOTDB-3952] Delete duplicated time filter in FilterOperator (#6780)
---
.../iotdb/db/mpp/plan/analyze/AnalyzeVisitor.java | 16 ++-
.../db/mpp/plan/analyze/ExpressionAnalyzer.java | 115 ++++++++++++++-------
.../iotdb/db/mpp/plan/expression/Expression.java | 4 +
.../expression/binary/CompareBinaryExpression.java | 5 +
.../iotdb/db/mpp/plan/analyze/AnalyzeTest.java | 103 ++++++++++++++++++
.../db/mpp/plan/plan/QueryLogicalPlanUtil.java | 26 ++---
6 files changed, 213 insertions(+), 56 deletions(-)
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeVisitor.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeVisitor.java
index 9bd86b0dda..69980a72f1 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeVisitor.java
@@ -39,6 +39,7 @@ import org.apache.iotdb.db.mpp.common.schematree.DeviceSchemaInfo;
import org.apache.iotdb.db.mpp.common.schematree.PathPatternTree;
import org.apache.iotdb.db.mpp.common.schematree.SchemaTree;
import org.apache.iotdb.db.mpp.plan.expression.Expression;
+import org.apache.iotdb.db.mpp.plan.expression.ExpressionType;
import org.apache.iotdb.db.mpp.plan.expression.leaf.TimeSeriesOperand;
import org.apache.iotdb.db.mpp.plan.expression.multi.FunctionExpression;
import org.apache.iotdb.db.mpp.plan.planner.plan.parameter.FillDescriptor;
@@ -51,6 +52,7 @@ import org.apache.iotdb.db.mpp.plan.statement.component.FillComponent;
import org.apache.iotdb.db.mpp.plan.statement.component.GroupByTimeComponent;
import org.apache.iotdb.db.mpp.plan.statement.component.Ordering;
import org.apache.iotdb.db.mpp.plan.statement.component.ResultColumn;
+import org.apache.iotdb.db.mpp.plan.statement.component.WhereCondition;
import org.apache.iotdb.db.mpp.plan.statement.crud.DeleteDataStatement;
import org.apache.iotdb.db.mpp.plan.statement.crud.InsertMultiTabletsStatement;
import org.apache.iotdb.db.mpp.plan.statement.crud.InsertRowStatement;
@@ -579,9 +581,19 @@ public class AnalyzeVisitor extends StatementVisitor<Analysis, MPPQueryContext>
Filter globalTimeFilter = null;
boolean hasValueFilter = false;
if (queryStatement.getWhereCondition() != null) {
+ Expression predicate = queryStatement.getWhereCondition().getPredicate();
+ WhereCondition whereCondition = queryStatement.getWhereCondition();
Pair<Filter, Boolean> resultPair =
- ExpressionAnalyzer.transformToGlobalTimeFilter(
- queryStatement.getWhereCondition().getPredicate());
+ ExpressionAnalyzer.transformToGlobalTimeFilter(predicate, true, true);
+ predicate = ExpressionAnalyzer.evaluatePredicate(predicate);
+
+ // set where condition to null if predicate is true
+ if (predicate.getExpressionType().equals(ExpressionType.CONSTANT)
+ && Boolean.parseBoolean(predicate.getExpressionString())) {
+ queryStatement.setWhereCondition(null);
+ } else {
+ whereCondition.setPredicate(predicate);
+ }
globalTimeFilter = resultPair.left;
hasValueFilter = resultPair.right;
}
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionAnalyzer.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionAnalyzer.java
index 3569ba75f1..584849ab36 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionAnalyzer.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionAnalyzer.java
@@ -29,14 +29,6 @@ import org.apache.iotdb.db.mpp.common.schematree.SchemaTree;
import org.apache.iotdb.db.mpp.plan.expression.Expression;
import org.apache.iotdb.db.mpp.plan.expression.ExpressionType;
import org.apache.iotdb.db.mpp.plan.expression.binary.BinaryExpression;
-import org.apache.iotdb.db.mpp.plan.expression.binary.EqualToExpression;
-import org.apache.iotdb.db.mpp.plan.expression.binary.GreaterEqualExpression;
-import org.apache.iotdb.db.mpp.plan.expression.binary.GreaterThanExpression;
-import org.apache.iotdb.db.mpp.plan.expression.binary.LessEqualExpression;
-import org.apache.iotdb.db.mpp.plan.expression.binary.LessThanExpression;
-import org.apache.iotdb.db.mpp.plan.expression.binary.LogicAndExpression;
-import org.apache.iotdb.db.mpp.plan.expression.binary.LogicOrExpression;
-import org.apache.iotdb.db.mpp.plan.expression.binary.NonEqualExpression;
import org.apache.iotdb.db.mpp.plan.expression.leaf.ConstantOperand;
import org.apache.iotdb.db.mpp.plan.expression.leaf.LeafOperand;
import org.apache.iotdb.db.mpp.plan.expression.leaf.TimeSeriesOperand;
@@ -45,14 +37,11 @@ import org.apache.iotdb.db.mpp.plan.expression.multi.FunctionExpression;
import org.apache.iotdb.db.mpp.plan.expression.ternary.BetweenExpression;
import org.apache.iotdb.db.mpp.plan.expression.ternary.TernaryExpression;
import org.apache.iotdb.db.mpp.plan.expression.unary.InExpression;
-import org.apache.iotdb.db.mpp.plan.expression.unary.IsNullExpression;
-import org.apache.iotdb.db.mpp.plan.expression.unary.LikeExpression;
-import org.apache.iotdb.db.mpp.plan.expression.unary.LogicNotExpression;
-import org.apache.iotdb.db.mpp.plan.expression.unary.RegularExpression;
import org.apache.iotdb.db.mpp.plan.expression.unary.UnaryExpression;
import org.apache.iotdb.db.mpp.plan.statement.component.ResultColumn;
import org.apache.iotdb.db.qp.constant.SQLConstant;
import org.apache.iotdb.tsfile.common.constant.TsFileConstant;
+import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
import org.apache.iotdb.tsfile.read.filter.TimeFilter;
import org.apache.iotdb.tsfile.read.filter.basic.Filter;
import org.apache.iotdb.tsfile.read.filter.factory.FilterFactory;
@@ -696,14 +685,34 @@ public class ExpressionAnalyzer {
* Extract global time filter from query filter.
*
* @param predicate raw query filter
+ * @param canRewrite determined by the father of current expression
+ * @param isFirstOr whether it is the first LogicOrExpression encountered
* @return global time filter
*/
- public static Pair<Filter, Boolean> transformToGlobalTimeFilter(Expression predicate) {
- if (predicate instanceof LogicAndExpression) {
+ public static Pair<Filter, Boolean> transformToGlobalTimeFilter(
+ Expression predicate, boolean canRewrite, boolean isFirstOr) {
+ if (predicate.getExpressionType().equals(ExpressionType.LOGIC_AND)) {
Pair<Filter, Boolean> leftResultPair =
- transformToGlobalTimeFilter(((BinaryExpression) predicate).getLeftExpression());
+ transformToGlobalTimeFilter(
+ ((BinaryExpression) predicate).getLeftExpression(), canRewrite, isFirstOr);
Pair<Filter, Boolean> rightResultPair =
- transformToGlobalTimeFilter(((BinaryExpression) predicate).getRightExpression());
+ transformToGlobalTimeFilter(
+ ((BinaryExpression) predicate).getRightExpression(), canRewrite, isFirstOr);
+
+ // rewrite predicate to avoid duplicate calculation on time filter
+ // If Left-child or Right-child does not contain value filter
+ // We can set it to true in Predicate Tree
+ if (canRewrite) {
+ if (leftResultPair.left != null && !leftResultPair.right) {
+ ((BinaryExpression) predicate)
+ .setLeftExpression(new ConstantOperand(TSDataType.BOOLEAN, "true"));
+ }
+ if (rightResultPair.left != null && !rightResultPair.right) {
+ ((BinaryExpression) predicate)
+ .setRightExpression(new ConstantOperand(TSDataType.BOOLEAN, "true"));
+ }
+ }
+
if (leftResultPair.left != null && rightResultPair.left != null) {
return new Pair<>(
FilterFactory.and(leftResultPair.left, rightResultPair.left),
@@ -714,27 +723,32 @@ public class ExpressionAnalyzer {
return new Pair<>(rightResultPair.left, true);
}
return new Pair<>(null, true);
- } else if (predicate instanceof LogicOrExpression) {
+ } else if (predicate.getExpressionType().equals(ExpressionType.LOGIC_OR)) {
Pair<Filter, Boolean> leftResultPair =
- transformToGlobalTimeFilter(((BinaryExpression) predicate).getLeftExpression());
+ transformToGlobalTimeFilter(
+ ((BinaryExpression) predicate).getLeftExpression(), false, false);
Pair<Filter, Boolean> rightResultPair =
- transformToGlobalTimeFilter(((BinaryExpression) predicate).getRightExpression());
+ transformToGlobalTimeFilter(
+ ((BinaryExpression) predicate).getRightExpression(), false, false);
+
if (leftResultPair.left != null && rightResultPair.left != null) {
+ if (isFirstOr && !leftResultPair.right && !rightResultPair.right) {
+ ((BinaryExpression) predicate)
+ .setLeftExpression(new ConstantOperand(TSDataType.BOOLEAN, "true"));
+ ((BinaryExpression) predicate)
+ .setRightExpression(new ConstantOperand(TSDataType.BOOLEAN, "true"));
+ }
return new Pair<>(
FilterFactory.or(leftResultPair.left, rightResultPair.left),
leftResultPair.right || rightResultPair.right);
}
return new Pair<>(null, true);
- } else if (predicate instanceof LogicNotExpression) {
+ } else if (predicate.getExpressionType().equals(ExpressionType.LOGIC_NOT)) {
Pair<Filter, Boolean> childResultPair =
- transformToGlobalTimeFilter(((UnaryExpression) predicate).getExpression());
+ transformToGlobalTimeFilter(
+ ((UnaryExpression) predicate).getExpression(), canRewrite, isFirstOr);
return new Pair<>(FilterFactory.not(childResultPair.left), childResultPair.right);
- } else if (predicate instanceof GreaterEqualExpression
- || predicate instanceof GreaterThanExpression
- || predicate instanceof LessEqualExpression
- || predicate instanceof LessThanExpression
- || predicate instanceof EqualToExpression
- || predicate instanceof NonEqualExpression) {
+ } else if (predicate.isCompareBinaryExpression()) {
Filter timeInLeftFilter =
constructTimeFilter(
predicate.getExpressionType(),
@@ -752,22 +766,23 @@ public class ExpressionAnalyzer {
return new Pair<>(timeInRightFilter, false);
}
return new Pair<>(null, true);
- } else if (predicate instanceof LikeExpression || predicate instanceof RegularExpression) {
+ } else if (predicate.getExpressionType().equals(ExpressionType.LIKE)
+ || predicate.getExpressionType().equals(ExpressionType.REGEXP)) {
return new Pair<>(null, true);
- } else if (predicate instanceof BetweenExpression) {
+ } else if (predicate.getExpressionType().equals(ExpressionType.BETWEEN)) {
Expression firstExpression = ((TernaryExpression) predicate).getFirstExpression();
Expression secondExpression = ((TernaryExpression) predicate).getSecondExpression();
Expression thirdExpression = ((TernaryExpression) predicate).getThirdExpression();
- if (firstExpression instanceof TimestampOperand) {
+ if (firstExpression.getExpressionType().equals(ExpressionType.TIMESTAMP)) {
return getPairFromBetweenTimeFirst(
secondExpression, thirdExpression, ((BetweenExpression) predicate).isNotBetween());
- } else if (secondExpression instanceof TimestampOperand) {
+ } else if (secondExpression.getExpressionType().equals(ExpressionType.TIMESTAMP)) {
if (checkConstantSatisfy(firstExpression, thirdExpression)) {
return getPairFromBetweenTimeSecond((BetweenExpression) predicate, firstExpression);
} else {
return new Pair<>(null, true); // TODO return Filter.True/False
}
- } else if (thirdExpression instanceof TimestampOperand) {
+ } else if (thirdExpression.getExpressionType().equals(ExpressionType.TIMESTAMP)) {
if (checkConstantSatisfy(secondExpression, firstExpression)) {
return getPairFromBetweenTimeThird((BetweenExpression) predicate, firstExpression);
} else {
@@ -775,11 +790,11 @@ public class ExpressionAnalyzer {
}
}
return new Pair<>(null, true);
- } else if (predicate instanceof IsNullExpression) {
+ } else if (predicate.getExpressionType().equals(ExpressionType.IS_NULL)) {
return new Pair<>(null, true);
- } else if (predicate instanceof InExpression) {
+ } else if (predicate.getExpressionType().equals(ExpressionType.IN)) {
Expression timeExpression = ((InExpression) predicate).getExpression();
- if (timeExpression instanceof TimestampOperand) {
+ if (timeExpression.getExpressionType().equals(ExpressionType.TIMESTAMP)) {
return new Pair<>(
TimeFilter.in(
((InExpression) predicate)
@@ -1092,4 +1107,34 @@ public class ExpressionAnalyzer {
"unsupported expression type: " + expression.getExpressionType());
}
}
+
+ public static Expression evaluatePredicate(Expression predicate) {
+ if (predicate.getExpressionType().equals(ExpressionType.LOGIC_AND)) {
+ Expression left = evaluatePredicate(((BinaryExpression) predicate).getLeftExpression());
+ Expression right = evaluatePredicate(((BinaryExpression) predicate).getRightExpression());
+ boolean isLeftTrue =
+ left.isConstantOperand() && Boolean.parseBoolean(left.getExpressionString());
+ boolean isRightTrue =
+ right.isConstantOperand() && Boolean.parseBoolean(right.getExpressionString());
+ if (isLeftTrue && isRightTrue) {
+ return new ConstantOperand(TSDataType.BOOLEAN, "true");
+ } else if (isLeftTrue) {
+ return right;
+ } else if (isRightTrue) {
+ return left;
+ }
+ return predicate;
+ } else if (predicate.getExpressionType().equals(ExpressionType.LOGIC_OR)) {
+ Expression left = evaluatePredicate(((BinaryExpression) predicate).getLeftExpression());
+ Expression right = evaluatePredicate(((BinaryExpression) predicate).getRightExpression());
+ boolean isLeftTrue =
+ left.isConstantOperand() && Boolean.parseBoolean(left.getExpressionString());
+ boolean isRightTrue =
+ right.isConstantOperand() && Boolean.parseBoolean(right.getExpressionString());
+ if (isRightTrue || isLeftTrue) {
+ return new ConstantOperand(TSDataType.BOOLEAN, "true");
+ }
+ }
+ return predicate;
+ }
}
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/Expression.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/Expression.java
index eae9d7320a..df6ab6cd18 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/Expression.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/Expression.java
@@ -91,6 +91,10 @@ public abstract class Expression {
return false;
}
+ public boolean isCompareBinaryExpression() {
+ return false;
+ }
+
/////////////////////////////////////////////////////////////////////////////////////////////////
// Operations for time series paths
/////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/CompareBinaryExpression.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/CompareBinaryExpression.java
index 5ea63fe7d1..ff7032af3d 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/CompareBinaryExpression.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/CompareBinaryExpression.java
@@ -82,4 +82,9 @@ public abstract class CompareBinaryExpression extends BinaryExpression {
return TSDataType.BOOLEAN;
}
+
+ @Override
+ public boolean isCompareBinaryExpression() {
+ return true;
+ }
}
diff --git a/server/src/test/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeTest.java b/server/src/test/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeTest.java
index 04b7fa534e..d081b194f3 100644
--- a/server/src/test/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/mpp/plan/analyze/AnalyzeTest.java
@@ -19,11 +19,24 @@
package org.apache.iotdb.db.mpp.plan.analyze;
+import org.apache.iotdb.commons.exception.IllegalPathException;
+import org.apache.iotdb.commons.path.PartialPath;
import org.apache.iotdb.db.mpp.common.MPPQueryContext;
import org.apache.iotdb.db.mpp.common.QueryId;
+import org.apache.iotdb.db.mpp.plan.expression.Expression;
+import org.apache.iotdb.db.mpp.plan.expression.binary.GreaterThanExpression;
+import org.apache.iotdb.db.mpp.plan.expression.binary.LessThanExpression;
+import org.apache.iotdb.db.mpp.plan.expression.binary.LogicAndExpression;
+import org.apache.iotdb.db.mpp.plan.expression.binary.LogicOrExpression;
+import org.apache.iotdb.db.mpp.plan.expression.leaf.ConstantOperand;
+import org.apache.iotdb.db.mpp.plan.expression.leaf.TimeSeriesOperand;
+import org.apache.iotdb.db.mpp.plan.expression.leaf.TimestampOperand;
import org.apache.iotdb.db.mpp.plan.parser.StatementGenerator;
import org.apache.iotdb.db.mpp.plan.statement.Statement;
+import org.apache.iotdb.db.mpp.plan.statement.crud.QueryStatement;
+import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
+import org.junit.Assert;
import org.junit.Test;
import java.time.ZonedDateTime;
@@ -37,6 +50,96 @@ public class AnalyzeTest {
// TODO: @lmh add UTs
}
+ @Test
+ public void testTimeFilterRewrite() throws IllegalPathException {
+ // Test whether time filter has been removed after extracting
+ String[] sqls =
+ new String[] {
+ "select s1 from root.sg.d1 where time>1 and time<3",
+ "select s1 from root.sg.d1 where time>1 and time<3 or time>100",
+ "select s1 from root.sg.d1 where time>1 or time<3",
+ "select s1 from root.sg.d1 where time>1 and time<3 and s1>1",
+ "select s1 from root.sg.d1 where time>1 and time<3 or s1>1",
+ "select s1 from root.sg.d1 where time>1 or time<3 or time >5",
+ "select s1 from root.sg.d1 where time>1 and time<3 and s1>1 and time>4",
+ "select s1 from root.sg.d1 where time>1 and time<3 or time >4 and time>5",
+ "select s1 from root.sg.d1 where time>1 or time<3 and s1>1",
+ "select s1 from root.sg.d1 where time>1 or time<3 or s1>1",
+ "select s1 from root.sg.d1 where time>1 or s1>1 and time<3",
+ "select s1 from root.sg.d1 where time>1 or s1>1 or time<3",
+ };
+
+ Expression[] predicates =
+ new Expression[] {
+ null,
+ null,
+ null,
+ new GreaterThanExpression(
+ new TimeSeriesOperand(new PartialPath("s1")),
+ new ConstantOperand(TSDataType.INT32, "1")),
+ new LogicOrExpression(
+ new LogicAndExpression(
+ new GreaterThanExpression(
+ new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "1")),
+ new LessThanExpression(
+ new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "3"))),
+ new GreaterThanExpression(
+ new TimeSeriesOperand(new PartialPath("s1")),
+ new ConstantOperand(TSDataType.INT32, "1"))),
+ null,
+ new GreaterThanExpression(
+ new TimeSeriesOperand(new PartialPath("s1")),
+ new ConstantOperand(TSDataType.INT32, "1")),
+ null,
+ new LogicOrExpression(
+ new GreaterThanExpression(
+ new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "1")),
+ new LogicAndExpression(
+ new LessThanExpression(
+ new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "3")),
+ new GreaterThanExpression(
+ new TimeSeriesOperand(new PartialPath("s1")),
+ new ConstantOperand(TSDataType.INT32, "1")))),
+ new LogicOrExpression(
+ new GreaterThanExpression(
+ new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "1")),
+ new LogicOrExpression(
+ new LessThanExpression(
+ new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "3")),
+ new GreaterThanExpression(
+ new TimeSeriesOperand(new PartialPath("s1")),
+ new ConstantOperand(TSDataType.INT32, "1")))),
+ new LogicOrExpression(
+ new GreaterThanExpression(
+ new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "1")),
+ new LogicAndExpression(
+ new GreaterThanExpression(
+ new TimeSeriesOperand(new PartialPath("s1")),
+ new ConstantOperand(TSDataType.INT32, "1")),
+ new LessThanExpression(
+ new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "3")))),
+ new LogicOrExpression(
+ new GreaterThanExpression(
+ new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "1")),
+ new LogicOrExpression(
+ new GreaterThanExpression(
+ new TimeSeriesOperand(new PartialPath("s1")),
+ new ConstantOperand(TSDataType.INT32, "1")),
+ new LessThanExpression(
+ new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "3")))),
+ };
+
+ for (int i = 0; i < sqls.length; i++) {
+ Analysis analysis = analyzeSQL(sqls[i]);
+ QueryStatement queryStatement = (QueryStatement) analysis.getStatement();
+ if (predicates[i] == null) {
+ Assert.assertNull(queryStatement.getWhereCondition());
+ } else {
+ Assert.assertEquals(predicates[i], queryStatement.getWhereCondition().getPredicate());
+ }
+ }
+ }
+
private Analysis analyzeSQL(String sql) {
try {
Statement statement =
diff --git a/server/src/test/java/org/apache/iotdb/db/mpp/plan/plan/QueryLogicalPlanUtil.java b/server/src/test/java/org/apache/iotdb/db/mpp/plan/plan/QueryLogicalPlanUtil.java
index 871fda2aed..b81ca42f63 100644
--- a/server/src/test/java/org/apache/iotdb/db/mpp/plan/plan/QueryLogicalPlanUtil.java
+++ b/server/src/test/java/org/apache/iotdb/db/mpp/plan/plan/QueryLogicalPlanUtil.java
@@ -214,9 +214,6 @@ public class QueryLogicalPlanUtil {
TimeJoinNode timeJoinNode =
new TimeJoinNode(queryId.genPlanNodeId(), Ordering.DESC, sourceNodeList);
- GreaterThanExpression timeFilter =
- new GreaterThanExpression(
- new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "100"));
GreaterThanExpression valueFilter1 =
new GreaterThanExpression(
new TimeSeriesOperand(schemaMap.get("root.sg.d1.s2")),
@@ -225,8 +222,9 @@ public class QueryLogicalPlanUtil {
new GreaterThanExpression(
new TimeSeriesOperand(schemaMap.get("root.sg.d2.s2")),
new ConstantOperand(TSDataType.INT32, "10"));
- LogicAndExpression predicate =
- new LogicAndExpression(timeFilter, new LogicAndExpression(valueFilter1, valueFilter2));
+
+ // Duplicate timeFilter has been removed, here only valueFilters are kept
+ LogicAndExpression predicate = new LogicAndExpression(valueFilter1, valueFilter2);
FilterNode filterNode =
new FilterNode(
@@ -274,14 +272,10 @@ public class QueryLogicalPlanUtil {
TimeJoinNode timeJoinNode1 =
new TimeJoinNode(queryId.genPlanNodeId(), Ordering.DESC, sourceNodeList1);
- GreaterThanExpression timeFilter =
- new GreaterThanExpression(
- new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "100"));
- GreaterThanExpression valueFilter1 =
+ GreaterThanExpression predicate1 =
new GreaterThanExpression(
new TimeSeriesOperand(schemaMap.get("root.sg.d1.s1")),
new ConstantOperand(TSDataType.INT64, "10"));
- LogicAndExpression predicate1 = new LogicAndExpression(timeFilter, valueFilter1);
FilterNode filterNode1 =
new FilterNode(
@@ -319,11 +313,10 @@ public class QueryLogicalPlanUtil {
TimeJoinNode timeJoinNode2 =
new TimeJoinNode(queryId.genPlanNodeId(), Ordering.DESC, sourceNodeList2);
- GreaterThanExpression valueFilter2 =
+ GreaterThanExpression predicate2 =
new GreaterThanExpression(
new TimeSeriesOperand(schemaMap.get("root.sg.d2.s1")),
new ConstantOperand(TSDataType.INT32, "10"));
- LogicAndExpression predicate2 = new LogicAndExpression(timeFilter, valueFilter2);
FilterNode filterNode2 =
new FilterNode(
@@ -903,14 +896,10 @@ public class QueryLogicalPlanUtil {
TimeJoinNode timeJoinNode1 =
new TimeJoinNode(queryId.genPlanNodeId(), Ordering.DESC, sourceNodeList1);
- GreaterThanExpression timeFilter =
- new GreaterThanExpression(
- new TimestampOperand(), new ConstantOperand(TSDataType.INT64, "100"));
- GreaterThanExpression valueFilter1 =
+ GreaterThanExpression predicate1 =
new GreaterThanExpression(
new TimeSeriesOperand(schemaMap.get("root.sg.d1.s2")),
new ConstantOperand(TSDataType.INT64, "10"));
- LogicAndExpression predicate1 = new LogicAndExpression(timeFilter, valueFilter1);
FilterNode filterNode1 =
new FilterNode(
@@ -965,11 +954,10 @@ public class QueryLogicalPlanUtil {
TimeJoinNode timeJoinNode2 =
new TimeJoinNode(queryId.genPlanNodeId(), Ordering.DESC, sourceNodeList2);
- GreaterThanExpression valueFilter2 =
+ GreaterThanExpression predicate2 =
new GreaterThanExpression(
new TimeSeriesOperand(schemaMap.get("root.sg.d2.s2")),
new ConstantOperand(TSDataType.INT32, "10"));
- LogicAndExpression predicate2 = new LogicAndExpression(timeFilter, valueFilter2);
FilterNode filterNode2 =
new FilterNode(