This is an automated email from the ASF dual-hosted git repository. hui pushed a commit to branch lmh/TypeProviderOpt in repository https://gitbox.apache.org/repos/asf/iotdb.git
commit 13f6ac54a781b19ec3eb4d77ca10b454a45ec681 Author: Minghui Liu <[email protected]> AuthorDate: Tue Sep 6 10:52:45 2022 +0800 finish ExpressionTypeAnalyzer --- .../apache/iotdb/db/mpp/plan/analyze/Analysis.java | 4 + .../mpp/plan/analyze/ExpressionTypeAnalyzer.java | 230 ++++++++++++++++++++- .../binary/ArithmeticBinaryExpression.java | 6 + .../expression/binary/CompareBinaryExpression.java | 6 + .../expression/binary/LogicBinaryExpression.java | 6 + .../plan/expression/ternary/BetweenExpression.java | 6 +- .../db/mpp/plan/expression/unary/InExpression.java | 6 + .../plan/expression/unary/IsNullExpression.java | 6 + .../mpp/plan/expression/unary/LikeExpression.java | 6 + .../plan/expression/unary/LogicNotExpression.java | 6 + .../plan/expression/unary/NegationExpression.java | 6 + .../plan/expression/unary/RegularExpression.java | 6 + .../plan/expression/visitor/ExpressionVisitor.java | 63 +++++- 13 files changed, 342 insertions(+), 15 deletions(-) diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/Analysis.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/Analysis.java index ae27b02122..2e61ba99e5 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/Analysis.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/Analysis.java @@ -460,4 +460,8 @@ public class Analysis { public void setRelatedTemplateInfo(Map<Integer, Template> relatedTemplateInfo) { this.relatedTemplateInfo = relatedTemplateInfo; } + + public void addTypes(Map<NodeRef<Expression>, TSDataType> types) { + this.expressionTypes.putAll(types); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionTypeAnalyzer.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionTypeAnalyzer.java index a14103bbf3..98d193dccc 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionTypeAnalyzer.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/analyze/ExpressionTypeAnalyzer.java @@ -19,36 +19,61 @@ package org.apache.iotdb.db.mpp.plan.analyze; +import org.apache.iotdb.db.exception.sql.SemanticException; import org.apache.iotdb.db.mpp.common.NodeRef; import org.apache.iotdb.db.mpp.plan.expression.Expression; +import org.apache.iotdb.db.mpp.plan.expression.binary.ArithmeticBinaryExpression; +import org.apache.iotdb.db.mpp.plan.expression.binary.CompareBinaryExpression; +import org.apache.iotdb.db.mpp.plan.expression.binary.LogicBinaryExpression; +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.expression.multi.FunctionExpression; +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.NegationExpression; +import org.apache.iotdb.db.mpp.plan.expression.unary.RegularExpression; import org.apache.iotdb.db.mpp.plan.expression.visitor.ExpressionVisitor; +import org.apache.iotdb.db.mpp.transformation.dag.udf.UDTFInformationInferrer; +import org.apache.iotdb.db.utils.TypeInferenceUtils; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; +import java.util.Arrays; import java.util.LinkedHashMap; +import java.util.List; import java.util.Map; +import java.util.stream.Collectors; + +import static com.google.common.base.Preconditions.checkArgument; public class ExpressionTypeAnalyzer { private final Map<NodeRef<Expression>, TSDataType> expressionTypes = new LinkedHashMap<>(); - private ExpressionTypeAnalyzer(Analysis analysis, TypeProvider types) {} + private ExpressionTypeAnalyzer() {} public static void analyzeExpression(Analysis analysis, Expression expression) { - ExpressionTypeAnalyzer analyzer = new ExpressionTypeAnalyzer(analysis, TypeProvider.empty()); + ExpressionTypeAnalyzer analyzer = new ExpressionTypeAnalyzer(); analyzer.analyze(expression); updateAnalysis(analysis, analyzer); } - private static void updateAnalysis(Analysis analysis, ExpressionTypeAnalyzer analyzer) {} + private static void updateAnalysis(Analysis analysis, ExpressionTypeAnalyzer analyzer) { + analysis.addTypes(analyzer.getExpressionTypes()); + } public TSDataType analyze(Expression expression) { Visitor visitor = new Visitor(); return visitor.process(expression, null); } + public Map<NodeRef<Expression>, TSDataType> getExpressionTypes() { + return expressionTypes; + } + private class Visitor extends ExpressionVisitor<TSDataType, Void> { @Override @@ -63,21 +88,206 @@ public class ExpressionTypeAnalyzer { @Override public TSDataType visitExpression(Expression expression, Void context) { - throw new UnsupportedOperationException( - "Unsupported expression type: " + expression.getClass().getName()); + throw new UnsupportedOperationException( + "Unsupported expression type: " + expression.getClass().getName()); } @Override - public TSDataType visitTimeSeriesOperand(TimeSeriesOperand timeSeriesOperand, Void context) { - expressionTypes.put(NodeRef.of(timeSeriesOperand), TSDataType.INT64); - return timeSeriesOperand.getPath().getSeriesType(); + public TSDataType visitInExpression(InExpression inExpression, Void context) { + process(inExpression.getExpression(), null); + return setExpressionType(inExpression, TSDataType.BOOLEAN); + } + + @Override + public TSDataType visitIsNullExpression(IsNullExpression isNullExpression, Void context) { + process(isNullExpression.getExpression(), null); + return setExpressionType(isNullExpression, TSDataType.BOOLEAN); + } + + @Override + public TSDataType visitLikeExpression(LikeExpression likeExpression, Void context) { + checkInputExpressionDataType( + likeExpression.getExpression().toString(), + process(likeExpression.getExpression(), null), + TSDataType.TEXT); + return setExpressionType(likeExpression, TSDataType.BOOLEAN); + } + + @Override + public TSDataType visitRegularExpression(RegularExpression regularExpression, Void context) { + checkInputExpressionDataType( + regularExpression.getExpression().toString(), + process(regularExpression.getExpression(), null), + TSDataType.TEXT); + return setExpressionType(regularExpression, TSDataType.BOOLEAN); + } + + @Override + public TSDataType visitLogicNotExpression(LogicNotExpression logicNotExpression, Void context) { + checkInputExpressionDataType( + logicNotExpression.getExpression().toString(), + process(logicNotExpression.getExpression(), null), + TSDataType.BOOLEAN); + return setExpressionType(logicNotExpression, TSDataType.BOOLEAN); + } + + @Override + public TSDataType visitNegationExpression(NegationExpression negationExpression, Void context) { + TSDataType inputExpressionType = process(negationExpression.getExpression(), null); + checkInputExpressionDataType( + negationExpression.getExpression().toString(), + inputExpressionType, + TSDataType.INT32, + TSDataType.INT64, + TSDataType.FLOAT, + TSDataType.DOUBLE); + return setExpressionType(negationExpression, inputExpressionType); + } + + @Override + public TSDataType visitArithmeticBinaryExpression( + ArithmeticBinaryExpression arithmeticBinaryExpression, Void context) { + checkInputExpressionDataType( + arithmeticBinaryExpression.getLeftExpression().toString(), + process(arithmeticBinaryExpression.getLeftExpression(), null), + TSDataType.INT32, + TSDataType.INT64, + TSDataType.FLOAT, + TSDataType.DOUBLE); + checkInputExpressionDataType( + arithmeticBinaryExpression.getRightExpression().toString(), + process(arithmeticBinaryExpression.getRightExpression(), null), + TSDataType.INT32, + TSDataType.INT64, + TSDataType.FLOAT, + TSDataType.DOUBLE); + return setExpressionType(arithmeticBinaryExpression, TSDataType.DOUBLE); + } + + @Override + public TSDataType visitLogicBinaryExpression( + LogicBinaryExpression logicBinaryExpression, Void context) { + checkInputExpressionDataType( + logicBinaryExpression.getLeftExpression().toString(), + process(logicBinaryExpression.getLeftExpression(), null), + TSDataType.BOOLEAN); + checkInputExpressionDataType( + logicBinaryExpression.getRightExpression().toString(), + process(logicBinaryExpression.getRightExpression(), null), + TSDataType.BOOLEAN); + return setExpressionType(logicBinaryExpression, TSDataType.BOOLEAN); + } + + @Override + public TSDataType visitCompareBinaryExpression( + CompareBinaryExpression compareBinaryExpression, Void context) { + final TSDataType leftExpressionDataType = + process(compareBinaryExpression.getLeftExpression(), null); + final TSDataType rightExpressionDataType = + process(compareBinaryExpression.getRightExpression(), null); + + if (!leftExpressionDataType.equals(rightExpressionDataType)) { + final String leftExpressionString = compareBinaryExpression.getLeftExpression().toString(); + final String rightExpressionString = + compareBinaryExpression.getRightExpression().toString(); + + if (TSDataType.BOOLEAN.equals(leftExpressionDataType) + || TSDataType.BOOLEAN.equals(rightExpressionDataType)) { + checkInputExpressionDataType( + leftExpressionString, leftExpressionDataType, TSDataType.BOOLEAN); + checkInputExpressionDataType( + rightExpressionString, rightExpressionDataType, TSDataType.BOOLEAN); + } else if (TSDataType.TEXT.equals(leftExpressionDataType) + || TSDataType.TEXT.equals(rightExpressionDataType)) { + checkInputExpressionDataType( + leftExpressionString, leftExpressionDataType, TSDataType.TEXT); + checkInputExpressionDataType( + rightExpressionString, rightExpressionDataType, TSDataType.TEXT); + } else { + checkInputExpressionDataType( + leftExpressionString, + leftExpressionDataType, + TSDataType.INT32, + TSDataType.INT64, + TSDataType.FLOAT, + TSDataType.DOUBLE); + checkInputExpressionDataType( + rightExpressionString, + rightExpressionDataType, + TSDataType.INT32, + TSDataType.INT64, + TSDataType.FLOAT, + TSDataType.DOUBLE); + } + } + + return setExpressionType(compareBinaryExpression, TSDataType.BOOLEAN); + } + + @Override + public TSDataType visitFunctionExpression(FunctionExpression functionExpression, Void context) { + List<Expression> inputExpressions = functionExpression.getExpressions(); + for (Expression expression : inputExpressions) { + process(expression, null); + } + + if (functionExpression.isBuiltInAggregationFunctionExpression()) { + checkArgument( + inputExpressions.size() == 1, + String.format( + "Builtin aggregation function only accepts 1 input expression. Actual %d input expressions.", + inputExpressions.size())); + return setExpressionType( + functionExpression, + TypeInferenceUtils.getAggrDataType( + functionExpression.getFunctionName(), + expressionTypes.get(NodeRef.of(inputExpressions.get(0))))); + } else { + return setExpressionType( + functionExpression, + new UDTFInformationInferrer(functionExpression.getFunctionName()) + .inferOutputType( + inputExpressions.stream() + .map(Expression::toString) + .collect(Collectors.toList()), + inputExpressions.stream() + .map(f -> expressionTypes.get(NodeRef.of(f))) + .collect(Collectors.toList()), + functionExpression.getFunctionAttributes())); + } } @Override public TSDataType visitTimeStampOperand(TimestampOperand timestampOperand, Void context) { - expressionTypes.put(NodeRef.of(timestampOperand), TSDataType.INT64); - return TSDataType.INT64; + return setExpressionType(timestampOperand, TSDataType.INT64); + } + + @Override + public TSDataType visitTimeSeriesOperand(TimeSeriesOperand timeSeriesOperand, Void context) { + return setExpressionType(timeSeriesOperand, timeSeriesOperand.getPath().getSeriesType()); + } + + @Override + public TSDataType visitConstantOperand(ConstantOperand constantOperand, Void context) { + return setExpressionType(constantOperand, constantOperand.getDataType()); + } + + private TSDataType setExpressionType(Expression expression, TSDataType type) { + expressionTypes.put(NodeRef.of(expression), type); + return type; } + private void checkInputExpressionDataType( + String expressionString, TSDataType actual, TSDataType... expected) { + for (TSDataType type : expected) { + if (actual.equals(type)) { + return; + } + } + throw new SemanticException( + String.format( + "Invalid input expression data type. expression: %s, actual data type: %s, expected data type(s): %s.", + expressionString, actual.name(), Arrays.toString(expected))); + } } } diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/ArithmeticBinaryExpression.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/ArithmeticBinaryExpression.java index 3fdd5659a9..cb7d7eacec 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/ArithmeticBinaryExpression.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/ArithmeticBinaryExpression.java @@ -21,6 +21,7 @@ package org.apache.iotdb.db.mpp.plan.expression.binary; import org.apache.iotdb.db.mpp.plan.analyze.TypeProvider; import org.apache.iotdb.db.mpp.plan.expression.Expression; +import org.apache.iotdb.db.mpp.plan.expression.visitor.ExpressionVisitor; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; import java.nio.ByteBuffer; @@ -57,4 +58,9 @@ public abstract class ArithmeticBinaryExpression extends BinaryExpression { } return TSDataType.DOUBLE; } + + @Override + public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) { + return visitor.visitArithmeticBinaryExpression(this, context); + } } 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 ff7032af3d..850d89b3df 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 @@ -21,6 +21,7 @@ package org.apache.iotdb.db.mpp.plan.expression.binary; import org.apache.iotdb.db.mpp.plan.analyze.TypeProvider; import org.apache.iotdb.db.mpp.plan.expression.Expression; +import org.apache.iotdb.db.mpp.plan.expression.visitor.ExpressionVisitor; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; import java.nio.ByteBuffer; @@ -87,4 +88,9 @@ public abstract class CompareBinaryExpression extends BinaryExpression { public boolean isCompareBinaryExpression() { return true; } + + @Override + public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) { + return visitor.visitCompareBinaryExpression(this, context); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/LogicBinaryExpression.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/LogicBinaryExpression.java index b4d644f681..05bcd06fd2 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/LogicBinaryExpression.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/binary/LogicBinaryExpression.java @@ -21,6 +21,7 @@ package org.apache.iotdb.db.mpp.plan.expression.binary; import org.apache.iotdb.db.mpp.plan.analyze.TypeProvider; import org.apache.iotdb.db.mpp.plan.expression.Expression; +import org.apache.iotdb.db.mpp.plan.expression.visitor.ExpressionVisitor; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; import java.nio.ByteBuffer; @@ -47,4 +48,9 @@ public abstract class LogicBinaryExpression extends BinaryExpression { } return TSDataType.BOOLEAN; } + + @Override + public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) { + return visitor.visitLogicBinaryExpression(this, context); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/ternary/BetweenExpression.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/ternary/BetweenExpression.java index 2b6f9c79e3..3f3be2e947 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/ternary/BetweenExpression.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/ternary/BetweenExpression.java @@ -24,6 +24,7 @@ package org.apache.iotdb.db.mpp.plan.expression.ternary; import org.apache.iotdb.db.mpp.plan.analyze.TypeProvider; 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.visitor.ExpressionVisitor; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; import org.apache.iotdb.tsfile.utils.ReadWriteIOUtils; @@ -96,7 +97,8 @@ public class BetweenExpression extends TernaryExpression { ReadWriteIOUtils.write(isNotBetween, stream); } - public Expression getExpression() { - return this; + @Override + public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) { + return visitor.visitBetweenExpression(this, context); } } diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/InExpression.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/InExpression.java index 8dde1583a1..8de05ba5d7 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/InExpression.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/InExpression.java @@ -25,6 +25,7 @@ import org.apache.iotdb.db.mpp.plan.expression.ExpressionType; 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.multi.FunctionExpression; +import org.apache.iotdb.db.mpp.plan.expression.visitor.ExpressionVisitor; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; import org.apache.iotdb.tsfile.utils.ReadWriteIOUtils; @@ -123,4 +124,9 @@ public class InExpression extends UnaryExpression { ReadWriteIOUtils.write(value, stream); } } + + @Override + public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) { + return visitor.visitInExpression(this, context); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/IsNullExpression.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/IsNullExpression.java index 2a862e2f75..57062b3531 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/IsNullExpression.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/IsNullExpression.java @@ -22,6 +22,7 @@ package org.apache.iotdb.db.mpp.plan.expression.unary; import org.apache.iotdb.db.mpp.plan.analyze.TypeProvider; 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.visitor.ExpressionVisitor; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; import org.apache.iotdb.tsfile.utils.ReadWriteIOUtils; @@ -82,4 +83,9 @@ public class IsNullExpression extends UnaryExpression { super.serialize(stream); ReadWriteIOUtils.write(isNot, stream); } + + @Override + public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) { + return visitor.visitIsNullExpression(this, context); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/LikeExpression.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/LikeExpression.java index 004b56c507..5d65547011 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/LikeExpression.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/LikeExpression.java @@ -23,6 +23,7 @@ import org.apache.iotdb.db.exception.sql.SemanticException; import org.apache.iotdb.db.mpp.plan.analyze.TypeProvider; 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.visitor.ExpressionVisitor; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; import org.apache.iotdb.tsfile.utils.ReadWriteIOUtils; @@ -154,4 +155,9 @@ public class LikeExpression extends UnaryExpression { super.serialize(stream); ReadWriteIOUtils.write(patternString, stream); } + + @Override + public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) { + return visitor.visitLikeExpression(this, context); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/LogicNotExpression.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/LogicNotExpression.java index c1b1a7f5ef..05800326ae 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/LogicNotExpression.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/LogicNotExpression.java @@ -26,6 +26,7 @@ import org.apache.iotdb.db.mpp.plan.expression.ExpressionType; 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.multi.FunctionExpression; +import org.apache.iotdb.db.mpp.plan.expression.visitor.ExpressionVisitor; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; import java.nio.ByteBuffer; @@ -69,4 +70,9 @@ public class LogicNotExpression extends UnaryExpression { public ExpressionType getExpressionType() { return ExpressionType.LOGIC_NOT; } + + @Override + public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) { + return visitor.visitLogicNotExpression(this, context); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/NegationExpression.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/NegationExpression.java index 30473ddeac..68f902e360 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/NegationExpression.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/NegationExpression.java @@ -26,6 +26,7 @@ import org.apache.iotdb.db.mpp.plan.expression.ExpressionType; 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.multi.FunctionExpression; +import org.apache.iotdb.db.mpp.plan.expression.visitor.ExpressionVisitor; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; import java.nio.ByteBuffer; @@ -76,4 +77,9 @@ public class NegationExpression extends UnaryExpression { public ExpressionType getExpressionType() { return ExpressionType.NEGATION; } + + @Override + public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) { + return visitor.visitNegationExpression(this, context); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/RegularExpression.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/RegularExpression.java index 7759b29f68..579ffa0b2c 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/RegularExpression.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/unary/RegularExpression.java @@ -23,6 +23,7 @@ import org.apache.iotdb.db.exception.sql.SemanticException; import org.apache.iotdb.db.mpp.plan.analyze.TypeProvider; 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.visitor.ExpressionVisitor; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; import org.apache.iotdb.tsfile.utils.ReadWriteIOUtils; @@ -101,4 +102,9 @@ public class RegularExpression extends UnaryExpression { super.serialize(stream); ReadWriteIOUtils.write(patternString, stream); } + + @Override + public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) { + return visitor.visitRegularExpression(this, context); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/visitor/ExpressionVisitor.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/visitor/ExpressionVisitor.java index a210c13c16..7ebc074a99 100644 --- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/visitor/ExpressionVisitor.java +++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/expression/visitor/ExpressionVisitor.java @@ -20,12 +20,23 @@ package org.apache.iotdb.db.mpp.plan.expression.visitor; import org.apache.iotdb.db.mpp.plan.expression.Expression; +import org.apache.iotdb.db.mpp.plan.expression.binary.ArithmeticBinaryExpression; import org.apache.iotdb.db.mpp.plan.expression.binary.BinaryExpression; +import org.apache.iotdb.db.mpp.plan.expression.binary.CompareBinaryExpression; +import org.apache.iotdb.db.mpp.plan.expression.binary.LogicBinaryExpression; 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; import org.apache.iotdb.db.mpp.plan.expression.leaf.TimestampOperand; 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.NegationExpression; +import org.apache.iotdb.db.mpp.plan.expression.unary.RegularExpression; import org.apache.iotdb.db.mpp.plan.expression.unary.UnaryExpression; /** @@ -47,27 +58,73 @@ public abstract class ExpressionVisitor<R, C> { return visitExpression(unaryExpression, context); } + public R visitInExpression(InExpression inExpression, C context) { + return visitUnaryExpression(inExpression, context); + } + + public R visitIsNullExpression(IsNullExpression isNullExpression, C context) { + return visitUnaryExpression(isNullExpression, context); + } + + public R visitLikeExpression(LikeExpression likeExpression, C context) { + return visitUnaryExpression(likeExpression, context); + } + + public R visitRegularExpression(RegularExpression regularExpression, C context) { + return visitUnaryExpression(regularExpression, context); + } + + public R visitLogicNotExpression(LogicNotExpression logicNotExpression, C context) { + return visitUnaryExpression(logicNotExpression, context); + } + + public R visitNegationExpression(NegationExpression negationExpression, C context) { + return visitUnaryExpression(negationExpression, context); + } + public R visitBinaryExpression(BinaryExpression binaryExpression, C context) { return visitExpression(binaryExpression, context); } + public R visitArithmeticBinaryExpression( + ArithmeticBinaryExpression arithmeticBinaryExpression, C context) { + return visitBinaryExpression(arithmeticBinaryExpression, context); + } + + public R visitLogicBinaryExpression(LogicBinaryExpression logicBinaryExpression, C context) { + return visitBinaryExpression(logicBinaryExpression, context); + } + + public R visitCompareBinaryExpression( + CompareBinaryExpression compareBinaryExpression, C context) { + return visitBinaryExpression(compareBinaryExpression, context); + } + public R visitTernaryExpression(TernaryExpression ternaryExpression, C context) { return visitExpression(ternaryExpression, context); } + public R visitBetweenExpression(BetweenExpression betweenExpression, C context) { + return visitTernaryExpression(betweenExpression, context); + } + public R visitFunctionExpression(FunctionExpression functionExpression, C context) { return visitExpression(functionExpression, context); } + public R visitLeafOperand(LeafOperand leafOperand, C context) { + return visitExpression(leafOperand, context); + } + public R visitTimeStampOperand(TimestampOperand timestampOperand, C context) { - return visitExpression(timestampOperand, context); + return visitLeafOperand(timestampOperand, context); } public R visitTimeSeriesOperand(TimeSeriesOperand timeSeriesOperand, C context) { - return visitExpression(timeSeriesOperand, context); + return visitLeafOperand(timeSeriesOperand, context); } public R visitConstantOperand(ConstantOperand constantOperand, C context) { - return visitExpression(constantOperand, context); + return visitLeafOperand(constantOperand, context); } }
