[Feature](Nereids) Data structure of comparison predicate

fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisLexer.g4

@@ -371,8 +371,7 @@ ZONE: 'ZONE';
 
 EQ  : '=' | '==';
 NSEQ: '<=>';
-NEQ : '<>';
-NEQJ: '!=';
+NEQ : '<>' | '!=';
 LT  : '<';
 LTE : '<=' | '!>';
 GT  : '>';

fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisParser.g4

@@ -170,7 +170,7 @@ constant
     ;
 
 comparisonOperator
-    : EQ | NEQ | NEQJ | LT | LTE | GT | GTE | NSEQ
+    : EQ | NEQ | LT | LTE | GT | GTE | NSEQ
     ;
 
 booleanValue

fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundAlias.java

@@ -29,9 +29,8 @@
 /**
  * Expression for unbound alias.
  */
-public class UnboundAlias<CHILD_TYPE extends Expression>
-        extends UnaryExpression<UnboundAlias<CHILD_TYPE>, CHILD_TYPE>
-        implements NamedExpression<UnboundAlias<CHILD_TYPE>> {
+public class UnboundAlias<CHILD_TYPE extends Expression> extends NamedExpression<UnboundAlias<CHILD_TYPE>>
+        implements UnaryExpression<UnboundAlias<CHILD_TYPE>, CHILD_TYPE> {
 
     public UnboundAlias(CHILD_TYPE child) {
         super(NodeType.UNBOUND_ALIAS, child);

fe/fe-core/src/main/java/org/apache/doris/nereids/analyzer/UnboundStar.java

@@ -29,7 +29,7 @@
 /**
  * Star expression.
  */
-public class UnboundStar extends LeafExpression<UnboundStar> implements NamedExpression<UnboundStar> {
+public class UnboundStar extends NamedExpression<UnboundStar> implements LeafExpression<UnboundStar> {
     private final List<String> target;
 
     public UnboundStar(List<String> target) {

fe/fe-core/src/main/java/org/apache/doris/nereids/parser/AstBuilder.java → fe/fe-core/src/main/java/org/apache/doris/nereids/parser/LogicalPlanBuilder.java

@@ -50,17 +50,24 @@
 import org.apache.doris.nereids.analyzer.UnboundSlot;
 import org.apache.doris.nereids.analyzer.UnboundStar;
 import org.apache.doris.nereids.trees.expressions.Alias;
-import org.apache.doris.nereids.trees.expressions.BinaryPredicate;
+import org.apache.doris.nereids.trees.expressions.EqualTo;
 import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.GreaterThan;
+import org.apache.doris.nereids.trees.expressions.GreaterThanEqual;
+import org.apache.doris.nereids.trees.expressions.LessThan;
+import org.apache.doris.nereids.trees.expressions.LessThanEqual;
 import org.apache.doris.nereids.trees.expressions.Literal;
 import org.apache.doris.nereids.trees.expressions.NamedExpression;
+import org.apache.doris.nereids.trees.expressions.Not;
+import org.apache.doris.nereids.trees.expressions.NullSafeEqual;
 import org.apache.doris.nereids.trees.plans.JoinType;
 import org.apache.doris.nereids.trees.plans.logical.LogicalFilter;
 import org.apache.doris.nereids.trees.plans.logical.LogicalJoin;
 import org.apache.doris.nereids.trees.plans.logical.LogicalPlan;
 import org.apache.doris.nereids.trees.plans.logical.LogicalProject;
 
-import com.clearspring.analytics.util.Lists;
+import com.google.common.collect.Lists;
+
 import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.RuleContext;
 import org.antlr.v4.runtime.tree.ParseTree;
@@ -74,9 +81,9 @@
 import java.util.stream.Collectors;
 
 /**
- * Build an AST that consisting of logical plans.
+ * Build an logical plan tree with unbounded nodes.
  */
-public class AstBuilder extends DorisParserBaseVisitor<Object> {
+public class LogicalPlanBuilder extends DorisParserBaseVisitor<Object> {
 
     /**
      * Create a logical plan using a where clause.
@@ -356,20 +363,19 @@ public Expression visitComparison(ComparisonContext ctx) {
         TerminalNode operator = (TerminalNode) ctx.comparisonOperator().getChild(0);
         switch (operator.getSymbol().getType()) {
             case DorisParser.EQ:
-                return new BinaryPredicate(left, right, BinaryPredicate.Operator.EQ);
-            case DorisParser.NSEQ:
-                return new BinaryPredicate(left, right, BinaryPredicate.Operator.NSEQ);
+                return new EqualTo(left, right);
+            case DorisParser.NEQ:
+                return new Not(new EqualTo(left, right));
             case DorisParser.LT:
-                return new BinaryPredicate(left, right, BinaryPredicate.Operator.LT);
+                return new LessThan(left, right);
             case DorisParser.GT:
-                return new BinaryPredicate(left, right, BinaryPredicate.Operator.GT);
+                return new GreaterThan(left, right);
             case DorisParser.LTE:
-                return new BinaryPredicate(left, right, BinaryPredicate.Operator.LE);
+                return new LessThanEqual(left, right);
             case DorisParser.GTE:
-                return new BinaryPredicate(left, right, BinaryPredicate.Operator.GE);
-            case DorisParser.NEQ:
-            case DorisParser.NEQJ:
-                return new BinaryPredicate(left, right, BinaryPredicate.Operator.EQ);
+                return new GreaterThanEqual(left, right);
+            case DorisParser.NSEQ:
+                return new NullSafeEqual(left, right);
             default:
                 return null;
         }

fe/fe-core/src/main/java/org/apache/doris/nereids/parser/SqlParser.java

@@ -63,7 +63,7 @@ public LogicalPlan parse(String sql) throws Exception {
             tree = parser.singleStatement();
         }
 
-        AstBuilder astBuilder = new AstBuilder();
-        return (LogicalPlan) astBuilder.visit(tree);
+        LogicalPlanBuilder logicalPlanBuilder = new LogicalPlanBuilder();
+        return (LogicalPlan) logicalPlanBuilder.visit(tree);
     }
 }

fe/fe-core/src/main/java/org/apache/doris/nereids/pattern/Patterns.java

@@ -25,8 +25,7 @@
 import org.apache.doris.nereids.trees.NodeType;
 import org.apache.doris.nereids.trees.TreeNode;
 import org.apache.doris.nereids.trees.expressions.Alias;
-import org.apache.doris.nereids.trees.expressions.BinaryPredicate;
-import org.apache.doris.nereids.trees.expressions.BinaryPredicate.Operator;
+import org.apache.doris.nereids.trees.expressions.EqualTo;
 import org.apache.doris.nereids.trees.expressions.Expression;
 import org.apache.doris.nereids.trees.expressions.Literal;
 import org.apache.doris.nereids.trees.expressions.SlotReference;
@@ -329,38 +328,28 @@ default PatternDescriptor<SlotReference, Expression> slotReference() {
     }
 
     /**
-     * create a binaryPredicate pattern.
+     * TODO create a ComparisonPredicate pattern.
      */
-    default PatternDescriptor<BinaryPredicate<Expression, Expression>, Expression> binaryPredicate() {
-        return new PatternDescriptor<>(
-                new Pattern<>(NodeType.BINARY_PREDICATE),
-                defaultPromise()
-        );
-    }
 
     /**
-     * create a binaryPredicate pattern with operator type.
+     * TODO create a ComparisonPredicate pattern with children patterns.
      */
-    default PatternDescriptor<BinaryPredicate<Expression, Expression>, Expression> binaryPredicate(Operator operator) {
-        return new PatternDescriptor<BinaryPredicate<Expression, Expression>, Expression>(
-                new Pattern<>(NodeType.BINARY_PREDICATE),
-                defaultPromise()
-        ).when(p -> p.getOperator() == operator);
+
+    /**
+     * create a equal to predicate pattern.
+     */
+    default PatternDescriptor<EqualTo<Expression, Expression>, Expression> equalTo() {
+        return new PatternDescriptor<>(new Pattern<>(NodeType.EQUAL_TO), defaultPromise());
     }
 
     /**
-     * create a binaryPredicate pattern with children patterns.
+     * create a equal to predicate pattern with children patterns.
      */
-    default <C1 extends Expression, C2 extends Expression> PatternDescriptor<BinaryPredicate<C1, C2>, Expression>
-            binaryPredicate(PatternDescriptor<C1, Expression> leftChildPattern,
-                PatternDescriptor<C2, Expression> rightChildPattern) {
+    default <C1 extends Expression, C2 extends Expression> PatternDescriptor<EqualTo<C1, C2>, Expression> equalTo(
+            PatternDescriptor<C1, Expression> leftChildPattern, PatternDescriptor<C2, Expression> rightChildPattern) {
         return new PatternDescriptor<>(
-                new Pattern<>(NodeType.BINARY_PREDICATE,
-                        leftChildPattern.pattern,
-                        rightChildPattern.pattern
-                ),
-                defaultPromise()
-        );
+                new Pattern<>(NodeType.EQUAL_TO, leftChildPattern.pattern, rightChildPattern.pattern),
+                defaultPromise());
     }
 
     /**

fe/fe-core/src/main/java/org/apache/doris/nereids/trees/NodeType.java

@@ -43,7 +43,14 @@ public enum NodeType {
     UNBOUND_STAR,
     LITERAL,
     SLOT_REFERENCE,
-    BINARY_PREDICATE,
+    COMPARISON_PREDICATE,
+    EQUAL_TO,
+    LESS_THAN,
+    GREATER_THAN,
+    LESS_THAN_EQUAL,
+    GREATER_THAN_EQUAL,
+    NULL_SAFE_EQUAL,
+    NOT,
     ALIAS,
 
     // pattern

fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/Alias.java

@@ -20,16 +20,15 @@
 import org.apache.doris.nereids.exceptions.UnboundException;
 import org.apache.doris.nereids.trees.NodeType;
 
-import com.clearspring.analytics.util.Lists;
+import com.google.common.collect.Lists;
 
 import java.util.List;
 
 /**
  * Expression for alias, such as col1 as c1.
  */
-public class Alias<CHILD_TYPE extends Expression>
-        extends UnaryExpression<Alias<CHILD_TYPE>, CHILD_TYPE>
-        implements NamedExpression<Alias<CHILD_TYPE>> {
+public class Alias<CHILD_TYPE extends Expression> extends NamedExpression<Alias<CHILD_TYPE>>
+        implements UnaryExpression<Alias<CHILD_TYPE>, CHILD_TYPE> {
 
     private final ExprId exprId;
     private final String name;
@@ -43,7 +42,7 @@ public class Alias<CHILD_TYPE extends Expression>
      */
     public Alias(CHILD_TYPE child, String name) {
         super(NodeType.ALIAS, child);
-        exprId = NamedExpressionUtils.newExprId();
+        exprId = NamedExpressionUtil.newExprId();
         this.name = name;
         qualifier = Lists.newArrayList();
     }

fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/BinaryExpression.java

@@ -21,26 +21,12 @@
 import org.apache.doris.nereids.trees.NodeType;
 
 /**
- * Abstract class for all expression that have two children.
+ * Interface for all expression that have two children.
  */
-public abstract class BinaryExpression<
+public interface BinaryExpression<
             EXPR_TYPE extends BinaryExpression<EXPR_TYPE, LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE>,
             LEFT_CHILD_TYPE extends Expression,
             RIGHT_CHILD_TYPE extends Expression>
-        extends AbstractExpression<EXPR_TYPE>
-        implements BinaryNode<EXPR_TYPE, LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> {
+        extends BinaryNode<EXPR_TYPE, LEFT_CHILD_TYPE, RIGHT_CHILD_TYPE> {
 
-    public BinaryExpression(NodeType type, LEFT_CHILD_TYPE left, RIGHT_CHILD_TYPE right) {
-        super(type, left, right);
-    }
-
-    @Override
-    public LEFT_CHILD_TYPE left() {
-        return BinaryNode.super.left();
-    }
-
-    @Override
-    public RIGHT_CHILD_TYPE right() {
-        return BinaryNode.super.right();
-    }
 }