This is an automated email from the ASF dual-hosted git repository. kxiao pushed a commit to branch branch-2.0 in repository https://gitbox.apache.org/repos/asf/doris.git
commit 290ed0dab870aef017f28ee4332efe8c69d0f3ab 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]
