This is an automated email from the ASF dual-hosted git repository.
jakevin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new dd09e42ca9 [enhancement](Nereids): expression unify constructor by
using List (#22985)
dd09e42ca9 is described below
commit dd09e42ca9dde9416d942f0bb5b05c79f41ad9a6
Author: jakevin <[email protected]>
AuthorDate: Tue Aug 15 16:47:58 2023 +0800
[enhancement](Nereids): expression unify constructor by using List (#22985)
---
.../org/apache/doris/nereids/analyzer/UnboundAlias.java | 12 +++++++++---
.../org/apache/doris/nereids/analyzer/UnboundStar.java | 1 +
.../org/apache/doris/nereids/trees/expressions/Add.java | 9 +++++++--
.../nereids/trees/expressions/AggregateExpression.java | 4 ----
.../apache/doris/nereids/trees/expressions/Alias.java | 10 +++-------
.../org/apache/doris/nereids/trees/expressions/And.java | 9 +++++++--
.../nereids/trees/expressions/AssertNumRowsElement.java | 4 +++-
.../apache/doris/nereids/trees/expressions/Between.java | 12 ++++++++++--
.../nereids/trees/expressions/BinaryArithmetic.java | 6 ++++--
.../doris/nereids/trees/expressions/BinaryOperator.java | 4 ++--
.../apache/doris/nereids/trees/expressions/BitAnd.java | 9 +++++++--
.../apache/doris/nereids/trees/expressions/BitNot.java | 9 +++++++--
.../apache/doris/nereids/trees/expressions/BitOr.java | 9 +++++++--
.../apache/doris/nereids/trees/expressions/BitXor.java | 9 +++++++--
.../doris/nereids/trees/expressions/BoundStar.java | 2 +-
.../doris/nereids/trees/expressions/CaseWhen.java | 4 +---
.../apache/doris/nereids/trees/expressions/Cast.java | 8 +++++++-
.../nereids/trees/expressions/ComparisonPredicate.java | 12 ++++--------
.../nereids/trees/expressions/CompoundPredicate.java | 13 ++++---------
.../apache/doris/nereids/trees/expressions/Divide.java | 9 +++++++--
.../apache/doris/nereids/trees/expressions/EqualTo.java | 9 +++++++--
.../doris/nereids/trees/expressions/Expression.java | 4 ++--
.../doris/nereids/trees/expressions/GreaterThan.java | 11 ++++++++---
.../nereids/trees/expressions/GreaterThanEqual.java | 16 ++++++++--------
.../doris/nereids/trees/expressions/InPredicate.java | 2 +-
.../doris/nereids/trees/expressions/IntegralDivide.java | 9 +++++++--
.../apache/doris/nereids/trees/expressions/IsNull.java | 9 +++++++--
.../doris/nereids/trees/expressions/LessThan.java | 15 +++++++--------
.../doris/nereids/trees/expressions/LessThanEqual.java | 9 +++++++--
.../apache/doris/nereids/trees/expressions/Like.java | 9 +++++++--
.../apache/doris/nereids/trees/expressions/Match.java | 6 ++++--
.../doris/nereids/trees/expressions/MatchAll.java | 9 +++++++--
.../doris/nereids/trees/expressions/MatchAny.java | 9 +++++++--
.../doris/nereids/trees/expressions/MatchPhrase.java | 9 +++++++--
.../org/apache/doris/nereids/trees/expressions/Mod.java | 9 +++++++--
.../doris/nereids/trees/expressions/Multiply.java | 9 +++++++--
.../nereids/trees/expressions/NamedExpression.java | 2 +-
.../org/apache/doris/nereids/trees/expressions/Not.java | 6 +++++-
.../doris/nereids/trees/expressions/NullSafeEqual.java | 9 +++++++--
.../org/apache/doris/nereids/trees/expressions/Or.java | 9 +++++++--
.../apache/doris/nereids/trees/expressions/Regexp.java | 9 +++++++--
.../apache/doris/nereids/trees/expressions/Slot.java | 6 ++++++
.../nereids/trees/expressions/StringRegexPredicate.java | 11 ++---------
.../doris/nereids/trees/expressions/SubqueryExpr.java | 4 ++--
.../doris/nereids/trees/expressions/Subtract.java | 9 +++++++--
.../doris/nereids/trees/expressions/TVFProperties.java | 4 +++-
.../nereids/trees/expressions/TimestampArithmetic.java | 3 ++-
.../nereids/trees/expressions/UnaryArithmetic.java | 4 +++-
.../doris/nereids/trees/expressions/UnaryOperator.java | 2 +-
.../doris/nereids/trees/expressions/VariableDesc.java | 17 +++--------------
.../doris/nereids/trees/expressions/WhenClause.java | 8 ++++++--
.../nereids/trees/expressions/WindowExpression.java | 4 ++--
.../nereids/trees/expressions/literal/Interval.java | 6 +++++-
.../nereids/trees/expressions/literal/Literal.java | 3 +++
54 files changed, 270 insertions(+), 145 deletions(-)
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundAlias.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundAlias.java
index 7f40544860..2be2130aba 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundAlias.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundAlias.java
@@ -26,6 +26,7 @@ import
org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.DataType;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Optional;
@@ -38,15 +39,20 @@ public class UnboundAlias extends NamedExpression
implements UnaryExpression, Un
private Optional<String> alias;
public UnboundAlias(Expression child) {
- super(child);
+ super(ImmutableList.of(child));
this.alias = Optional.empty();
}
public UnboundAlias(Expression child, String alias) {
- super(child);
+ super(ImmutableList.of(child));
this.alias = Optional.of(alias);
}
+ private UnboundAlias(List<Expression> children, Optional<String> alias) {
+ super(children);
+ this.alias = alias;
+ }
+
@Override
public DataType getDataType() throws UnboundException {
return child().getDataType();
@@ -77,7 +83,7 @@ public class UnboundAlias extends NamedExpression implements
UnaryExpression, Un
@Override
public UnboundAlias withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 1);
- return new UnboundAlias(children.get(0));
+ return new UnboundAlias(children, alias);
}
public Optional<String> getAlias() {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundStar.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundStar.java
index d6c54dffce..4370561156 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundStar.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundStar.java
@@ -37,6 +37,7 @@ public class UnboundStar extends NamedExpression implements
LeafExpression, Unbo
private final List<String> qualifier;
public UnboundStar(List<String> qualifier) {
+ super(ImmutableList.of());
this.qualifier =
Objects.requireNonNull(ImmutableList.copyOf(qualifier), "qualifier can not be
null");
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Add.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Add.java
index 0327f21ec7..2633a23388 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Add.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Add.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.types.DataType;
import org.apache.doris.nereids.types.DecimalV3Type;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -33,13 +34,17 @@ import java.util.List;
public class Add extends BinaryArithmetic implements CheckOverflowNullable {
public Add(Expression left, Expression right) {
- super(left, right, Operator.ADD);
+ super(ImmutableList.of(left, right), Operator.ADD);
+ }
+
+ private Add(List<Expression> children) {
+ super(children, Operator.ADD);
}
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new Add(children.get(0), children.get(1));
+ return new Add(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/AggregateExpression.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/AggregateExpression.java
index cfe647ed5f..223d1798f0 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/AggregateExpression.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/AggregateExpression.java
@@ -97,10 +97,6 @@ public class AggregateExpression extends Expression
implements UnaryExpression {
}
}
- public AggregateExpression withAggregateParam(AggregateParam
aggregateParam) {
- return new AggregateExpression(function, aggregateParam, child());
- }
-
@Override
public String toSql() {
if (aggregateParam.aggMode.productAggregateBuffer) {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Alias.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Alias.java
index 05e0a513e8..fa58447012 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Alias.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Alias.java
@@ -48,13 +48,13 @@ public class Alias extends NamedExpression implements
UnaryExpression {
}
public Alias(ExprId exprId, Expression child, String name) {
- super(child);
+ super(ImmutableList.of(child));
this.exprId = exprId;
this.name = name;
this.qualifier = ImmutableList.of();
}
- private Alias(ExprId exprId, Expression child, String name, List<String>
qualifier) {
+ public Alias(ExprId exprId, List<Expression> child, String name,
List<String> qualifier) {
super(child);
this.exprId = exprId;
this.name = name;
@@ -127,11 +127,7 @@ public class Alias extends NamedExpression implements
UnaryExpression {
@Override
public Alias withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 1);
- return new Alias(exprId, children.get(0), name);
- }
-
- public Expression withQualifier(List<String> qualifier) {
- return new Alias(this.exprId, this.child(0), this.name, qualifier);
+ return new Alias(exprId, children, name, qualifier);
}
public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/And.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/And.java
index 966f8d5f74..5e76c3afa1 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/And.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/And.java
@@ -20,6 +20,7 @@ package org.apache.doris.nereids.trees.expressions;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -35,13 +36,17 @@ public class And extends CompoundPredicate {
* @param right right child of comparison predicate
*/
public And(Expression left, Expression right) {
- super(left, right, "AND");
+ super(ImmutableList.of(left, right), "AND");
+ }
+
+ private And(List<Expression> children) {
+ super(children, "AND");
}
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new And(children.get(0), children.get(1));
+ return new And(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/AssertNumRowsElement.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/AssertNumRowsElement.java
index 4a80d73e5d..48a7c6aee4 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/AssertNumRowsElement.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/AssertNumRowsElement.java
@@ -23,6 +23,7 @@ import
org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.util.Utils;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Objects;
@@ -49,6 +50,7 @@ public class AssertNumRowsElement extends Expression
implements LeafExpression,
public AssertNumRowsElement(long desiredNumOfRows, String subqueryString,
Assertion assertion) {
+ super(ImmutableList.of());
this.desiredNumOfRows = desiredNumOfRows;
this.subqueryString = subqueryString;
this.assertion = assertion;
@@ -68,7 +70,7 @@ public class AssertNumRowsElement extends Expression
implements LeafExpression,
@Override
public AssertNumRowsElement withChildren(List<Expression> children) {
- Preconditions.checkArgument(children.size() == 0);
+ Preconditions.checkArgument(children.isEmpty());
return this;
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Between.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Between.java
index 2d3942b217..5f5df284cc 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Between.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Between.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.types.BooleanType;
import org.apache.doris.nereids.types.DataType;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Objects;
@@ -46,12 +47,19 @@ public class Between extends Expression implements
TernaryExpression {
public Between(Expression compareExpr, Expression lowerBound,
Expression upperBound) {
- super(compareExpr, lowerBound, upperBound);
+ super(ImmutableList.of(compareExpr, lowerBound, upperBound));
this.compareExpr = compareExpr;
this.lowerBound = lowerBound;
this.upperBound = upperBound;
}
+ public Between(List<Expression> children) {
+ super(children);
+ this.compareExpr = children.get(0);
+ this.lowerBound = children.get(1);
+ this.upperBound = children.get(2);
+ }
+
@Override
public DataType getDataType() throws UnboundException {
return BooleanType.INSTANCE;
@@ -91,7 +99,7 @@ public class Between extends Expression implements
TernaryExpression {
@Override
public Between withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 3);
- return new Between(children.get(0), children.get(1), children.get(2));
+ return new Between(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryArithmetic.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryArithmetic.java
index 68a74e03cf..501af7470c 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryArithmetic.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryArithmetic.java
@@ -30,6 +30,8 @@ import org.apache.doris.nereids.util.TypeCoercionUtils;
import com.google.common.base.Preconditions;
+import java.util.List;
+
/**
* binary arithmetic operator. Such as +, -, *, /.
*/
@@ -37,8 +39,8 @@ public abstract class BinaryArithmetic extends BinaryOperator
implements Propaga
private final Operator legacyOperator;
- public BinaryArithmetic(Expression left, Expression right, Operator
legacyOperator) {
- super(left, right, legacyOperator.toString());
+ public BinaryArithmetic(List<Expression> children, Operator
legacyOperator) {
+ super(children, legacyOperator.toString());
this.legacyOperator = legacyOperator;
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryOperator.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryOperator.java
index 68e05db3a7..3327680137 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryOperator.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryOperator.java
@@ -33,8 +33,8 @@ public abstract class BinaryOperator extends Expression
implements BinaryExpress
protected final String symbol;
- public BinaryOperator(Expression left, Expression right, String symbol) {
- super(left, right);
+ public BinaryOperator(List<Expression> children, String symbol) {
+ super(children);
this.symbol = symbol;
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitAnd.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitAnd.java
index c1ebc7b89d..f2c353e6e0 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitAnd.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitAnd.java
@@ -21,6 +21,7 @@ import org.apache.doris.analysis.ArithmeticExpr.Operator;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -30,13 +31,17 @@ import java.util.List;
public class BitAnd extends BinaryArithmetic {
public BitAnd(Expression left, Expression right) {
- super(left, right, Operator.BITAND);
+ super(ImmutableList.of(left, right), Operator.BITAND);
+ }
+
+ private BitAnd(List<Expression> children) {
+ super(children, Operator.BITAND);
}
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new BitAnd(children.get(0), children.get(1));
+ return new BitAnd(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitNot.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitNot.java
index 889e7afea2..8fea0b0b3c 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitNot.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitNot.java
@@ -25,6 +25,7 @@ import
org.apache.doris.nereids.types.coercion.AbstractDataType;
import org.apache.doris.nereids.types.coercion.NumericType;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -33,14 +34,18 @@ import java.util.List;
*/
public class BitNot extends UnaryArithmetic {
- public BitNot(Expression child) {
+ private BitNot(List<Expression> child) {
super(child, Operator.BITNOT);
}
+ public BitNot(Expression child) {
+ super(ImmutableList.of(child), Operator.BITNOT);
+ }
+
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 1);
- return new BitNot(children.get(0));
+ return new BitNot(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitOr.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitOr.java
index 54b4575ba9..dd320b12ba 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitOr.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitOr.java
@@ -21,6 +21,7 @@ import org.apache.doris.analysis.ArithmeticExpr.Operator;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -30,13 +31,17 @@ import java.util.List;
public class BitOr extends BinaryArithmetic {
public BitOr(Expression left, Expression right) {
- super(left, right, Operator.BITOR);
+ super(ImmutableList.of(left, right), Operator.BITOR);
+ }
+
+ public BitOr(List<Expression> children) {
+ super(children, Operator.BITOR);
}
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new BitOr(children.get(0), children.get(1));
+ return new BitOr(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitXor.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitXor.java
index f5bd7fcfe9..6e53f701ca 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitXor.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BitXor.java
@@ -21,6 +21,7 @@ import org.apache.doris.analysis.ArithmeticExpr.Operator;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -30,13 +31,17 @@ import java.util.List;
public class BitXor extends BinaryArithmetic {
public BitXor(Expression left, Expression right) {
- super(left, right, Operator.BITXOR);
+ super(ImmutableList.of(left, right), Operator.BITXOR);
+ }
+
+ private BitXor(List<Expression> children) {
+ super(children, Operator.BITXOR);
}
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new BitXor(children.get(0), children.get(1));
+ return new BitXor(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BoundStar.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BoundStar.java
index 02a2d8338c..8b4bffad3f 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BoundStar.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BoundStar.java
@@ -29,7 +29,7 @@ import java.util.stream.Collectors;
/** BoundStar is used to wrap list of slots for temporary. */
public class BoundStar extends NamedExpression implements PropagateNullable {
public BoundStar(List<Slot> children) {
- super(children.toArray(new Slot[0]));
+ super((List) children);
Preconditions.checkArgument(children.stream().noneMatch(slot -> slot
instanceof UnboundSlot),
"BoundStar can not wrap UnboundSlot"
);
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/CaseWhen.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/CaseWhen.java
index 94468d80ff..1b0e9eb80f 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/CaseWhen.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/CaseWhen.java
@@ -51,9 +51,7 @@ public class CaseWhen extends Expression {
}
public CaseWhen(List<WhenClause> whenClauses, Expression defaultValue) {
- super(ImmutableList.<Expression>builder()
- .addAll(whenClauses).add(defaultValue).build()
- .toArray(new Expression[0]));
+
super(ImmutableList.<Expression>builder().addAll(whenClauses).add(defaultValue).build());
this.whenClauses =
ImmutableList.copyOf(Objects.requireNonNull(whenClauses));
this.defaultValue = Optional.of(Objects.requireNonNull(defaultValue));
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Cast.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Cast.java
index 295b22e3f0..c450e7f7a2 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Cast.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Cast.java
@@ -23,6 +23,7 @@ import
org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.DataType;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Objects;
@@ -35,6 +36,11 @@ public class Cast extends Expression implements
UnaryExpression {
private final DataType targetType;
public Cast(Expression child, DataType targetType) {
+ super(ImmutableList.of(child));
+ this.targetType = Objects.requireNonNull(targetType, "targetType can
not be null");
+ }
+
+ private Cast(List<Expression> child, DataType targetType) {
super(child);
this.targetType = Objects.requireNonNull(targetType, "targetType can
not be null");
}
@@ -66,7 +72,7 @@ public class Cast extends Expression implements
UnaryExpression {
@Override
public Cast withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 1);
- return new Cast(children.get(0), getDataType());
+ return new Cast(children, getDataType());
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/ComparisonPredicate.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/ComparisonPredicate.java
index 41c7e449ed..f00e2a6f78 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/ComparisonPredicate.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/ComparisonPredicate.java
@@ -25,20 +25,16 @@ import org.apache.doris.nereids.types.DataType;
import org.apache.doris.nereids.types.coercion.AbstractDataType;
import org.apache.doris.nereids.types.coercion.AnyDataType;
+import java.util.List;
+
/**
* Comparison predicate expression.
* Such as: "=", "<", "<=", ">", ">=", "<=>"
*/
public abstract class ComparisonPredicate extends BinaryOperator {
- /**
- * Constructor of ComparisonPredicate.
- *
- * @param left left child of comparison predicate
- * @param right right child of comparison predicate
- */
- public ComparisonPredicate(Expression left, Expression right, String
symbol) {
- super(left, right, symbol);
+ public ComparisonPredicate(List<Expression> children, String symbol) {
+ super(children, symbol);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/CompoundPredicate.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/CompoundPredicate.java
index 4b8c3b2464..6c9d133db9 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/CompoundPredicate.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/CompoundPredicate.java
@@ -23,21 +23,16 @@ import org.apache.doris.nereids.types.BooleanType;
import org.apache.doris.nereids.types.DataType;
import org.apache.doris.nereids.types.coercion.AbstractDataType;
+import java.util.List;
+
/**
* Compound predicate expression.
* Such as &&,||,AND,OR.
*/
public abstract class CompoundPredicate extends BinaryOperator {
- /**
- * Desc: Constructor for CompoundPredicate.
- *
- * @param left left child of comparison predicate
- * @param right right child of comparison predicate
- * @param symbol symbol used in sql
- */
- public CompoundPredicate(Expression left, Expression right, String symbol)
{
- super(left, right, symbol);
+ public CompoundPredicate(List<Expression> children, String symbol) {
+ super(children, symbol);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Divide.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Divide.java
index 4616b2686b..410e00a205 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Divide.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Divide.java
@@ -27,6 +27,7 @@ import org.apache.doris.nereids.types.DecimalV3Type;
import org.apache.doris.nereids.types.DoubleType;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -36,13 +37,17 @@ import java.util.List;
public class Divide extends BinaryArithmetic implements AlwaysNullable {
public Divide(Expression left, Expression right) {
- super(left, right, Operator.DIVIDE);
+ super(ImmutableList.of(left, right), Operator.DIVIDE);
+ }
+
+ private Divide(List<Expression> children) {
+ super(children, Operator.DIVIDE);
}
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new Divide(children.get(0), children.get(1));
+ return new Divide(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/EqualTo.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/EqualTo.java
index c4ddb89443..0fa23a57e0 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/EqualTo.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/EqualTo.java
@@ -22,6 +22,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.PropagateNullable;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -31,7 +32,11 @@ import java.util.List;
public class EqualTo extends ComparisonPredicate implements PropagateNullable {
public EqualTo(Expression left, Expression right) {
- super(left, right, "=");
+ super(ImmutableList.of(left, right), "=");
+ }
+
+ private EqualTo(List<Expression> children) {
+ super(children, "=");
}
@Override
@@ -47,7 +52,7 @@ public class EqualTo extends ComparisonPredicate implements
PropagateNullable {
@Override
public EqualTo withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new EqualTo(children.get(0), children.get(1));
+ return new EqualTo(children);
}
public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Expression.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Expression.java
index 0d2772d768..14b999b275 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Expression.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Expression.java
@@ -52,11 +52,11 @@ public abstract class Expression extends
AbstractTreeNode<Expression> implements
// Mask this expression is generated by rule, should be removed.
public boolean isGeneratedIsNotNull = false;
- public Expression(Expression... children) {
+ protected Expression(Expression... children) {
super(children);
}
- public Expression(List<Expression> children) {
+ protected Expression(List<Expression> children) {
super(Optional.empty(), children);
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/GreaterThan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/GreaterThan.java
index dc673f5318..1871781ca9 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/GreaterThan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/GreaterThan.java
@@ -22,6 +22,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.PropagateNullable;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -32,11 +33,15 @@ public class GreaterThan extends ComparisonPredicate
implements PropagateNullabl
/**
* Constructor of Greater Than ComparisonPredicate.
*
- * @param left left child of greater than
+ * @param left left child of greater than
* @param right right child of greater than
*/
public GreaterThan(Expression left, Expression right) {
- super(left, right, ">");
+ super(ImmutableList.of(left, right), ">");
+ }
+
+ private GreaterThan(List<Expression> children) {
+ super(children, ">");
}
@Override
@@ -52,7 +57,7 @@ public class GreaterThan extends ComparisonPredicate
implements PropagateNullabl
@Override
public GreaterThan withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new GreaterThan(children.get(0), children.get(1));
+ return new GreaterThan(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/GreaterThanEqual.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/GreaterThanEqual.java
index 0e1b5a45bc..e2995298e3 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/GreaterThanEqual.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/GreaterThanEqual.java
@@ -22,6 +22,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.PropagateNullable;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -29,14 +30,13 @@ import java.util.List;
* Greater than and equal expression: a >= b.
*/
public class GreaterThanEqual extends ComparisonPredicate implements
PropagateNullable {
- /**
- * Constructor of Greater Than And Equal.
- *
- * @param left left child of Greater Than And Equal
- * @param right right child of Greater Than And Equal
- */
+
public GreaterThanEqual(Expression left, Expression right) {
- super(left, right, ">=");
+ super(ImmutableList.of(left, right), ">=");
+ }
+
+ private GreaterThanEqual(List<Expression> children) {
+ super(children, ">=");
}
@Override
@@ -52,7 +52,7 @@ public class GreaterThanEqual extends ComparisonPredicate
implements PropagateNu
@Override
public GreaterThanEqual withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new GreaterThanEqual(children.get(0), children.get(1));
+ return new GreaterThanEqual(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/InPredicate.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/InPredicate.java
index 6968b38bff..d90ec7489e 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/InPredicate.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/InPredicate.java
@@ -42,7 +42,7 @@ public class InPredicate extends Expression {
private final List<Expression> options;
public InPredicate(Expression compareExpr, List<Expression> options) {
- super(new
Builder<Expression>().add(compareExpr).addAll(options).build().toArray(new
Expression[0]));
+ super(new
Builder<Expression>().add(compareExpr).addAll(options).build());
this.compareExpr = Objects.requireNonNull(compareExpr, "Compare Expr
cannot be null");
this.options = ImmutableList.copyOf(Objects.requireNonNull(options,
"In list cannot be null"));
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/IntegralDivide.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/IntegralDivide.java
index d1eebb0c15..38a4d89231 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/IntegralDivide.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/IntegralDivide.java
@@ -23,6 +23,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.AlwaysNullable;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -32,7 +33,11 @@ import java.util.List;
public class IntegralDivide extends BinaryArithmetic implements AlwaysNullable
{
public IntegralDivide(Expression left, Expression right) {
- super(left, right, Operator.INT_DIVIDE);
+ super(ImmutableList.of(left, right), Operator.INT_DIVIDE);
+ }
+
+ private IntegralDivide(List<Expression> children) {
+ super(children, Operator.INT_DIVIDE);
}
@Override
@@ -49,6 +54,6 @@ public class IntegralDivide extends BinaryArithmetic
implements AlwaysNullable {
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new IntegralDivide(children.get(0), children.get(1));
+ return new IntegralDivide(children);
}
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/IsNull.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/IsNull.java
index 35d3c2da2b..7bb8538fc7 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/IsNull.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/IsNull.java
@@ -25,6 +25,7 @@ import org.apache.doris.nereids.types.BooleanType;
import org.apache.doris.nereids.types.DataType;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Objects;
@@ -35,7 +36,11 @@ import java.util.Objects;
public class IsNull extends Expression implements UnaryExpression,
AlwaysNotNullable {
public IsNull(Expression e) {
- super(e);
+ super(ImmutableList.of(e));
+ }
+
+ private IsNull(List<Expression> children) {
+ super(children);
}
@Override
@@ -46,7 +51,7 @@ public class IsNull extends Expression implements
UnaryExpression, AlwaysNotNull
@Override
public IsNull withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 1);
- return new IsNull(children.get(0));
+ return new IsNull(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/LessThan.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/LessThan.java
index c682ef4678..4d34b50bb9 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/LessThan.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/LessThan.java
@@ -22,6 +22,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.PropagateNullable;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -29,14 +30,12 @@ import java.util.List;
* Less than expression: a < b.
*/
public class LessThan extends ComparisonPredicate implements PropagateNullable
{
- /**
- * Constructor of Less Than Comparison Predicate.
- *
- * @param left left child of Less Than
- * @param right right child of Less Than
- */
public LessThan(Expression left, Expression right) {
- super(left, right, "<");
+ super(ImmutableList.of(left, right), "<");
+ }
+
+ private LessThan(List<Expression> children) {
+ super(children, "<");
}
@Override
@@ -52,7 +51,7 @@ public class LessThan extends ComparisonPredicate implements
PropagateNullable {
@Override
public LessThan withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new LessThan(children.get(0), children.get(1));
+ return new LessThan(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/LessThanEqual.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/LessThanEqual.java
index 92389869de..4ac997d3ab 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/LessThanEqual.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/LessThanEqual.java
@@ -22,6 +22,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.PropagateNullable;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -36,7 +37,11 @@ public class LessThanEqual extends ComparisonPredicate
implements PropagateNulla
* @param right right child of Less Than And Equal
*/
public LessThanEqual(Expression left, Expression right) {
- super(left, right, "<=");
+ super(ImmutableList.of(left, right), "<=");
+ }
+
+ private LessThanEqual(List<Expression> children) {
+ super(children, "<=");
}
@Override
@@ -52,7 +57,7 @@ public class LessThanEqual extends ComparisonPredicate
implements PropagateNulla
@Override
public LessThanEqual withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new LessThanEqual(children.get(0), children.get(1));
+ return new LessThanEqual(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Like.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Like.java
index 34fa65aede..89a9c77971 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Like.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Like.java
@@ -20,6 +20,7 @@ package org.apache.doris.nereids.trees.expressions;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -29,13 +30,17 @@ import java.util.List;
public class Like extends StringRegexPredicate {
public Like(Expression left, Expression right) {
- super("like", left, right);
+ super("like", ImmutableList.of(left, right));
+ }
+
+ private Like(List<Expression> children) {
+ super("like", children);
}
@Override
public Like withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new Like(children.get(0), children.get(1));
+ return new Like(children);
}
public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Match.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Match.java
index 01241243bb..bc9837eafe 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Match.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Match.java
@@ -27,13 +27,15 @@ import org.apache.doris.nereids.types.DataType;
import org.apache.doris.nereids.types.coercion.AbstractDataType;
import org.apache.doris.nereids.types.coercion.AnyDataType;
+import java.util.List;
+
/**
* like expression: a MATCH 'hello'.
*/
public abstract class Match extends BinaryOperator implements
PropagateNullable {
- public Match(Expression left, Expression right, String symbol) {
- super(left, right, symbol);
+ public Match(List<Expression> children, String symbol) {
+ super(children, symbol);
}
/**
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchAll.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchAll.java
index c8ad36be4a..f3d334d9ed 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchAll.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchAll.java
@@ -20,6 +20,7 @@ package org.apache.doris.nereids.trees.expressions;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -28,13 +29,17 @@ import java.util.List;
*/
public class MatchAll extends Match {
public MatchAll(Expression left, Expression right) {
- super(left, right, "MATCH_ALL");
+ super(ImmutableList.of(left, right), "MATCH_ALL");
+ }
+
+ private MatchAll(List<Expression> children) {
+ super(children, "MATCH_ALL");
}
@Override
public MatchAll withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new MatchAll(children.get(0), children.get(1));
+ return new MatchAll(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchAny.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchAny.java
index f467c004cd..9f4b45370a 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchAny.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchAny.java
@@ -20,6 +20,7 @@ package org.apache.doris.nereids.trees.expressions;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -28,13 +29,17 @@ import java.util.List;
*/
public class MatchAny extends Match {
public MatchAny(Expression left, Expression right) {
- super(left, right, "MATCH_ANY");
+ super(ImmutableList.of(left, right), "MATCH_ANY");
+ }
+
+ private MatchAny(List<Expression> children) {
+ super(children, "MATCH_ANY");
}
@Override
public MatchAny withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new MatchAny(children.get(0), children.get(1));
+ return new MatchAny(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchPhrase.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchPhrase.java
index 113a43eee9..529e693400 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchPhrase.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/MatchPhrase.java
@@ -20,6 +20,7 @@ package org.apache.doris.nereids.trees.expressions;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -28,13 +29,17 @@ import java.util.List;
*/
public class MatchPhrase extends Match {
public MatchPhrase(Expression left, Expression right) {
- super(left, right, "MATCH_PHRASE");
+ super(ImmutableList.of(left, right), "MATCH_PHRASE");
+ }
+
+ private MatchPhrase(List<Expression> children) {
+ super(children, "MATCH_PHRASE");
}
@Override
public MatchPhrase withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new MatchPhrase(children.get(0), children.get(1));
+ return new MatchPhrase(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Mod.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Mod.java
index 8154d4afbc..9a28655091 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Mod.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Mod.java
@@ -24,6 +24,7 @@ import
org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.DecimalV3Type;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -33,13 +34,17 @@ import java.util.List;
public class Mod extends BinaryArithmetic implements AlwaysNullable {
public Mod(Expression left, Expression right) {
- super(left, right, Operator.MOD);
+ super(ImmutableList.of(left, right), Operator.MOD);
+ }
+
+ private Mod(List<Expression> children) {
+ super(children, Operator.MOD);
}
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new Mod(children.get(0), children.get(1));
+ return new Mod(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Multiply.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Multiply.java
index bb83db1c72..a42c3fa5c2 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Multiply.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Multiply.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.types.DataType;
import org.apache.doris.nereids.types.DecimalV3Type;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -33,13 +34,17 @@ import java.util.List;
public class Multiply extends BinaryArithmetic implements
CheckOverflowNullable {
public Multiply(Expression left, Expression right) {
- super(left, right, Operator.MULTIPLY);
+ super(ImmutableList.of(left, right), Operator.MULTIPLY);
+ }
+
+ public Multiply(List<Expression> children) {
+ super(children, Operator.MULTIPLY);
}
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new Multiply(children.get(0), children.get(1));
+ return new Multiply(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/NamedExpression.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/NamedExpression.java
index 2e376720f8..8707792da3 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/NamedExpression.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/NamedExpression.java
@@ -27,7 +27,7 @@ import java.util.List;
*/
public abstract class NamedExpression extends Expression {
- public NamedExpression(Expression... children) {
+ protected NamedExpression(List<Expression> children) {
super(children);
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Not.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Not.java
index 7c1a6c2d0f..f62b18a677 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Not.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Not.java
@@ -40,6 +40,10 @@ public class Not extends Expression implements
UnaryExpression, ExpectsInputType
public static final List<AbstractDataType> EXPECTS_INPUT_TYPES =
ImmutableList.of(BooleanType.INSTANCE);
public Not(Expression child) {
+ super(ImmutableList.of(child));
+ }
+
+ private Not(List<Expression> child) {
super(child);
}
@@ -88,7 +92,7 @@ public class Not extends Expression implements
UnaryExpression, ExpectsInputType
@Override
public Not withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 1);
- Not not = new Not(children.get(0));
+ Not not = new Not(children);
not.isGeneratedIsNotNull = this.isGeneratedIsNotNull;
return not;
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/NullSafeEqual.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/NullSafeEqual.java
index 6ed6847b35..c2b63aebbd 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/NullSafeEqual.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/NullSafeEqual.java
@@ -21,6 +21,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.AlwaysNotNullable;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -36,7 +37,11 @@ public class NullSafeEqual extends ComparisonPredicate
implements AlwaysNotNulla
* @param right right child of Null Safe Equal
*/
public NullSafeEqual(Expression left, Expression right) {
- super(left, right, "<=>");
+ super(ImmutableList.of(left, right), "<=>");
+ }
+
+ private NullSafeEqual(List<Expression> children) {
+ super(children, "<=>");
}
@Override
@@ -52,7 +57,7 @@ public class NullSafeEqual extends ComparisonPredicate
implements AlwaysNotNulla
@Override
public NullSafeEqual withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new NullSafeEqual(children.get(0), children.get(1));
+ return new NullSafeEqual(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Or.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Or.java
index f9385f59c7..61249fb91c 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Or.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Or.java
@@ -20,6 +20,7 @@ package org.apache.doris.nereids.trees.expressions;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -35,13 +36,17 @@ public class Or extends CompoundPredicate {
* @param right right child of comparison predicate
*/
public Or(Expression left, Expression right) {
- super(left, right, "OR");
+ super(ImmutableList.of(left, right), "OR");
+ }
+
+ private Or(List<Expression> children) {
+ super(children, "OR");
}
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new Or(children.get(0), children.get(1));
+ return new Or(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Regexp.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Regexp.java
index 11c9219dc2..253992c0eb 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Regexp.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Regexp.java
@@ -20,6 +20,7 @@ package org.apache.doris.nereids.trees.expressions;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -29,13 +30,17 @@ import java.util.List;
public class Regexp extends StringRegexPredicate {
public Regexp(Expression left, Expression right) {
- super("regexp", left, right);
+ super("regexp", ImmutableList.of(left, right));
+ }
+
+ private Regexp(List<Expression> children) {
+ super("regexp", children);
}
@Override
public Regexp withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new Regexp(children.get(0), children.get(1));
+ return new Regexp(children);
}
public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Slot.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Slot.java
index c5dc57018f..8b1f7628bf 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Slot.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Slot.java
@@ -19,6 +19,8 @@ package org.apache.doris.nereids.trees.expressions;
import org.apache.doris.nereids.trees.expressions.shape.LeafExpression;
+import com.google.common.collect.ImmutableList;
+
import java.util.List;
/**
@@ -26,6 +28,10 @@ import java.util.List;
*/
public abstract class Slot extends NamedExpression implements LeafExpression {
+ protected Slot() {
+ super(ImmutableList.of());
+ }
+
@Override
public Slot toSlot() {
return this;
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/StringRegexPredicate.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/StringRegexPredicate.java
index 37d243d059..4d31f200cd 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/StringRegexPredicate.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/StringRegexPredicate.java
@@ -41,15 +41,8 @@ public abstract class StringRegexPredicate extends
ScalarFunction
FunctionSignature.ret(BooleanType.INSTANCE).args(VarcharType.SYSTEM_DEFAULT,
VarcharType.SYSTEM_DEFAULT)
);
- /**
- * Constructor of StringRegexPredicate.
- *
- * @param left left child of string regex
- * @param right right child of string regex
- * @param name operator symbol
- */
- public StringRegexPredicate(String name, Expression left, Expression
right) {
- super(name, left, right);
+ protected StringRegexPredicate(String name, List<Expression> children) {
+ super(name, children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/SubqueryExpr.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/SubqueryExpr.java
index 44ea635d56..aa29c27f87 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/SubqueryExpr.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/SubqueryExpr.java
@@ -38,13 +38,13 @@ public abstract class SubqueryExpr extends Expression {
protected final List<Slot> correlateSlots;
protected final Optional<Expression> typeCoercionExpr;
- public SubqueryExpr(LogicalPlan subquery) {
+ protected SubqueryExpr(LogicalPlan subquery) {
this.queryPlan = Objects.requireNonNull(subquery, "subquery can not be
null");
this.correlateSlots = ImmutableList.of();
this.typeCoercionExpr = Optional.empty();
}
- public SubqueryExpr(LogicalPlan subquery, List<Slot> correlateSlots,
Optional<Expression> typeCoercionExpr) {
+ protected SubqueryExpr(LogicalPlan subquery, List<Slot> correlateSlots,
Optional<Expression> typeCoercionExpr) {
this.queryPlan = Objects.requireNonNull(subquery, "subquery can not be
null");
this.correlateSlots = ImmutableList.copyOf(correlateSlots);
this.typeCoercionExpr = typeCoercionExpr;
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Subtract.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Subtract.java
index 80898891bf..a7367142ec 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Subtract.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Subtract.java
@@ -24,6 +24,7 @@ import org.apache.doris.nereids.types.DataType;
import org.apache.doris.nereids.types.DecimalV3Type;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
@@ -33,13 +34,17 @@ import java.util.List;
public class Subtract extends BinaryArithmetic implements
CheckOverflowNullable {
public Subtract(Expression left, Expression right) {
- super(left, right, Operator.SUBTRACT);
+ super(ImmutableList.of(left, right), Operator.SUBTRACT);
+ }
+
+ private Subtract(List<Expression> children) {
+ super(children, Operator.SUBTRACT);
}
@Override
public Expression withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new Subtract(children.get(0), children.get(1));
+ return new Subtract(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/TVFProperties.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/TVFProperties.java
index f1a0e852f3..6a8cfc585d 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/TVFProperties.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/TVFProperties.java
@@ -23,6 +23,8 @@ import
org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.DataType;
import org.apache.doris.nereids.types.MapType;
+import com.google.common.collect.ImmutableList;
+
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
@@ -34,7 +36,7 @@ public class TVFProperties extends Expression implements
LeafExpression {
private final Map<String, String> keyValues;
public TVFProperties(Map<String, String> properties) {
- super();
+ super(ImmutableList.of());
this.keyValues = Objects.requireNonNull(properties, "properties can
not be null");
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/TimestampArithmetic.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/TimestampArithmetic.java
index b586a409b1..44828b5045 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/TimestampArithmetic.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/TimestampArithmetic.java
@@ -30,6 +30,7 @@ import org.apache.doris.nereids.types.DateType;
import org.apache.doris.nereids.types.DateV2Type;
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
import java.util.List;
import java.util.Objects;
@@ -57,7 +58,7 @@ public class TimestampArithmetic extends Expression
implements BinaryExpression,
*/
public TimestampArithmetic(String funcName, Operator op, Expression e1,
Expression e2, TimeUnit timeUnit,
boolean intervalFirst) {
- super(e1, e2);
+ super(ImmutableList.of(e1, e2));
Preconditions.checkState(op == Operator.ADD || op ==
Operator.SUBTRACT);
this.funcName = funcName;
this.op = op;
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryArithmetic.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryArithmetic.java
index 98bb81aad0..85ebe94879 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryArithmetic.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryArithmetic.java
@@ -23,6 +23,8 @@ import
org.apache.doris.nereids.trees.expressions.functions.PropagateNullable;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.DataType;
+import java.util.List;
+
/**
* binary arithmetic operator. Such as +, -, *, /.
*/
@@ -30,7 +32,7 @@ public abstract class UnaryArithmetic extends UnaryOperator
implements Propagate
private final Operator legacyOperator;
- public UnaryArithmetic(Expression child, Operator legacyOperator) {
+ protected UnaryArithmetic(List<Expression> child, Operator legacyOperator)
{
super(child, legacyOperator.toString());
this.legacyOperator = legacyOperator;
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryOperator.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryOperator.java
index 2e0d6a3d51..42059a7ef2 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryOperator.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/UnaryOperator.java
@@ -33,7 +33,7 @@ public abstract class UnaryOperator extends Expression
implements UnaryExpressio
protected final String symbol;
- public UnaryOperator(Expression child, String symbol) {
+ protected UnaryOperator(List<Expression> child, String symbol) {
super(child);
this.symbol = symbol;
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/VariableDesc.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/VariableDesc.java
index 1afceaba0d..38f23ee40f 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/VariableDesc.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/VariableDesc.java
@@ -22,6 +22,8 @@ import org.apache.doris.nereids.exceptions.UnboundException;
import org.apache.doris.nereids.trees.expressions.shape.LeafExpression;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
+import com.google.common.collect.ImmutableList;
+
import java.util.Objects;
/**
@@ -33,25 +35,12 @@ public class VariableDesc extends Expression implements
LeafExpression {
final String name;
public VariableDesc(boolean isSystemVariable, SetType setType, String
name) {
+ super(ImmutableList.of());
this.isSystemVariable = isSystemVariable;
this.setType = setType;
this.name = name;
}
- public VariableDesc(SetType setType, String name) {
- //Construct system variable
- this(true, setType, name);
- }
-
- public VariableDesc(String name) {
- //Construct user variable
- this(false, SetType.DEFAULT, name);
- }
-
- public boolean isSystemVariable() {
- return isSystemVariable;
- }
-
public String getName() {
return name;
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/WhenClause.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/WhenClause.java
index 1ef30448bb..147dc5f601 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/WhenClause.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/WhenClause.java
@@ -41,7 +41,11 @@ public class WhenClause extends Expression implements
BinaryExpression, ExpectsI
= ImmutableList.of(BooleanType.INSTANCE, AnyDataType.INSTANCE);
public WhenClause(Expression operand, Expression result) {
- super(operand, result);
+ super(ImmutableList.of(operand, result));
+ }
+
+ private WhenClause(List<Expression> children) {
+ super(children);
}
public Expression getOperand() {
@@ -60,7 +64,7 @@ public class WhenClause extends Expression implements
BinaryExpression, ExpectsI
@Override
public WhenClause withChildren(List<Expression> children) {
Preconditions.checkArgument(children.size() == 2);
- return new WhenClause(children.get(0), children.get(1));
+ return new WhenClause(children);
}
@Override
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/WindowExpression.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/WindowExpression.java
index d0a153e95f..c9531d61b6 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/WindowExpression.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/WindowExpression.java
@@ -52,7 +52,7 @@ public class WindowExpression extends Expression {
.add(function)
.addAll(partitionKeys)
.addAll(orderKeys)
- .build().toArray(new Expression[0]));
+ .build());
this.function = function;
this.partitionKeys = ImmutableList.copyOf(partitionKeys);
this.orderKeys = ImmutableList.copyOf(orderKeys);
@@ -67,7 +67,7 @@ public class WindowExpression extends Expression {
.addAll(partitionKeys)
.addAll(orderKeys)
.add(windowFrame)
- .build().toArray(new Expression[0]));
+ .build());
this.function = function;
this.partitionKeys = ImmutableList.copyOf(partitionKeys);
this.orderKeys = ImmutableList.copyOf(orderKeys);
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/Interval.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/Interval.java
index 101004abaf..8b823220e2 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/Interval.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/Interval.java
@@ -19,18 +19,22 @@ package org.apache.doris.nereids.trees.expressions.literal;
import org.apache.doris.nereids.trees.expressions.Expression;
import org.apache.doris.nereids.trees.expressions.functions.AlwaysNotNullable;
+import org.apache.doris.nereids.trees.expressions.shape.LeafExpression;
import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
import org.apache.doris.nereids.types.DataType;
import org.apache.doris.nereids.types.DateType;
+import com.google.common.collect.ImmutableList;
+
/**
* Interval for timestamp calculation.
*/
-public class Interval extends Expression implements AlwaysNotNullable {
+public class Interval extends Expression implements LeafExpression,
AlwaysNotNullable {
private final Expression value;
private final TimeUnit timeUnit;
public Interval(Expression value, String desc) {
+ super(ImmutableList.of());
this.value = value;
this.timeUnit = TimeUnit.valueOf(desc.toUpperCase());
}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/Literal.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/Literal.java
index 123aa618f4..605f236ef7 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/Literal.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/literal/Literal.java
@@ -34,6 +34,8 @@ import org.apache.doris.nereids.types.LargeIntType;
import org.apache.doris.nereids.types.StringType;
import org.apache.doris.nereids.types.VarcharType;
+import com.google.common.collect.ImmutableList;
+
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Locale;
@@ -53,6 +55,7 @@ public abstract class Literal extends Expression implements
LeafExpression, Comp
* @param dataType logical data type in Nereids
*/
public Literal(DataType dataType) {
+ super(ImmutableList.of());
this.dataType = Objects.requireNonNull(dataType);
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
