diff --git a/build.sbt b/build.sbt index b882d133b..593542e5c 100644 --- a/build.sbt +++ b/build.sbt @@ -151,7 +151,9 @@ lazy val pplSparkIntegration = (project in file("ppl-spark-integration")) "org.scalatest" %% "scalatest-flatspec" % "3.2.15" % "test", "org.scalatestplus" %% "mockito-4-6" % "3.2.15.0" % "test", "com.stephenn" %% "scalatest-json-jsonassert" % "0.2.5" % "test", - "com.github.sbt" % "junit-interface" % "0.13.3" % "test"), + "com.github.sbt" % "junit-interface" % "0.13.3" % "test", + "org.projectlombok" % "lombok" % "1.18.30", + ), libraryDependencies ++= deps(sparkVersion), // ANTLR settings Antlr4 / antlr4Version := "4.8", diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/Node.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/Node.java index 710142ea0..aa2d2be6e 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/Node.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/Node.java @@ -5,9 +5,14 @@ package org.opensearch.sql.ast; +import lombok.EqualsAndHashCode; +import lombok.ToString; + import java.util.List; /** AST node. */ +@EqualsAndHashCode +@ToString public abstract class Node { public R accept(AbstractNodeVisitor visitor, C context) { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AggregateFunction.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AggregateFunction.java index b912ef686..fda342eb8 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AggregateFunction.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AggregateFunction.java @@ -5,6 +5,9 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Collections; @@ -16,6 +19,9 @@ * Expression node of aggregate functions. Params include aggregate function name (AVG, SUM, MAX * etc.) and the field to aggregate. */ +@Getter +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class AggregateFunction extends UnresolvedExpression { private final String funcName; private final UnresolvedExpression field; @@ -51,37 +57,11 @@ public AggregateFunction(String funcName, UnresolvedExpression field, Boolean di this.distinct = distinct; } - public AggregateFunction(String funcName, UnresolvedExpression field, List argList) { - this.funcName = funcName; - this.field = field; - this.argList = argList; - } - @Override public List getChild() { return Collections.singletonList(field); } - public String getFuncName() { - return funcName; - } - - public UnresolvedExpression getField() { - return field; - } - - public List getArgList() { - return argList; - } - - public UnresolvedExpression getCondition() { - return condition; - } - - public Boolean getDistinct() { - return distinct; - } - @Override public R accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitAggregateFunction(this, context); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Alias.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Alias.java index 83e08330f..7b3078629 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Alias.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Alias.java @@ -5,6 +5,11 @@ package org.opensearch.sql.ast.expression; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; /** @@ -13,40 +18,22 @@ * eventually. This can avoid restoring the info in toString() method which is inaccurate because * original info is already lost. */ +@AllArgsConstructor +@EqualsAndHashCode(callSuper = false) +@Getter +@RequiredArgsConstructor +@ToString public class Alias extends UnresolvedExpression { /** Original field name. */ - private String name; + private final String name; /** Expression aliased. */ - private UnresolvedExpression delegated; + private final UnresolvedExpression delegated; /** Optional field alias. */ private String alias; - public Alias(String name, UnresolvedExpression delegated, String alias) { - this.name = name; - this.delegated = delegated; - this.alias = alias; - } - - public Alias(String name, UnresolvedExpression delegated) { - this.name = name; - this.delegated = delegated; - } - - public String getName() { - return name; - } - - public UnresolvedExpression getDelegated() { - return delegated; - } - - public String getAlias() { - return alias; - } - @Override public T accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitAlias(this, context); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AllFields.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AllFields.java index eb4a16efa..c3f206ca1 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AllFields.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AllFields.java @@ -5,6 +5,8 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.Node; @@ -12,6 +14,8 @@ import java.util.List; /** Represent the All fields which is been used in SELECT *. */ +@ToString +@EqualsAndHashCode(callSuper = false) public class AllFields extends UnresolvedExpression { public static final AllFields INSTANCE = new AllFields(); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/And.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/And.java index f783aabb7..f52787a24 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/And.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/And.java @@ -5,18 +5,19 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; -import java.util.Arrays; -import java.util.List; - /** Expression node of logic AND. */ +@ToString +@EqualsAndHashCode(callSuper = true) public class And extends BinaryExpression { public And(UnresolvedExpression left, UnresolvedExpression right) { - super(left,right); + super(left, right); } - + @Override public R accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitAnd(this, context); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Argument.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Argument.java index 35ded8d8b..049c3556d 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Argument.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Argument.java @@ -5,35 +5,30 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Arrays; import java.util.List; /** Argument. */ +@Getter +@ToString +@RequiredArgsConstructor +@EqualsAndHashCode(callSuper = false) public class Argument extends UnresolvedExpression { private final String name; private final Literal value; - public Argument(String name, Literal value) { - this.name = name; - this.value = value; - } - // private final DataType valueType; @Override public List getChild() { return Arrays.asList(value); } - public String getName() { - return name; - } - - public Literal getValue() { - return value; - } - @Override public R accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitArgument(this, context); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AttributeList.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AttributeList.java index c08265ea8..4a0337cd8 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AttributeList.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/AttributeList.java @@ -6,13 +6,21 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.List; /** Expression node that includes a list of Expression nodes. */ +@Getter +@ToString +@EqualsAndHashCode(callSuper = false) +@AllArgsConstructor public class AttributeList extends UnresolvedExpression { - private List attrList; + private final List attrList; @Override public List getChild() { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Between.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Between.java index c936da71c..eb02c2983 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Between.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Between.java @@ -5,6 +5,11 @@ package org.opensearch.sql.ast.expression; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.Node; @@ -12,6 +17,11 @@ import java.util.List; /** Unresolved expression for BETWEEN. */ +@Getter +@Setter +@AllArgsConstructor +@EqualsAndHashCode(callSuper = false) +@ToString public class Between extends UnresolvedExpression { /** Value for range check. */ @@ -23,12 +33,6 @@ public class Between extends UnresolvedExpression { /** Upper bound of the range (inclusive). */ private UnresolvedExpression upperBound; - public Between(UnresolvedExpression value, UnresolvedExpression lowerBound, UnresolvedExpression upperBound) { - this.value = value; - this.lowerBound = lowerBound; - this.upperBound = upperBound; - } - @Override public List getChild() { return Arrays.asList(value, lowerBound, upperBound); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/BinaryExpression.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/BinaryExpression.java index 9f0ee7b45..5d930c7a0 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/BinaryExpression.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/BinaryExpression.java @@ -5,30 +5,22 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; + import java.util.Arrays; import java.util.List; +@Getter +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public abstract class BinaryExpression extends UnresolvedExpression { - private UnresolvedExpression left; - private UnresolvedExpression right; - - public BinaryExpression(UnresolvedExpression left, UnresolvedExpression right) { - this.left = left; - this.right = right; - } + private final UnresolvedExpression left; + private final UnresolvedExpression right; @Override public List getChild() { return Arrays.asList(left, right); } - - public UnresolvedExpression getLeft() { - return left; - } - - public UnresolvedExpression getRight() { - return right; - } - } - diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Case.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Case.java index 2419cf744..9ac5397b7 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Case.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Case.java @@ -6,12 +6,20 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.Node; import java.util.List; /** AST node that represents CASE clause similar as Switch statement in programming language. */ +@AllArgsConstructor +@EqualsAndHashCode(callSuper = false) +@Getter +@ToString public class Case extends UnresolvedExpression { /** Value to be compared by WHEN statements. Null in the case of CASE WHEN conditions. */ @@ -26,24 +34,6 @@ public class Case extends UnresolvedExpression { /** Expression that represents ELSE statement result. */ private UnresolvedExpression elseClause; - public Case(UnresolvedExpression caseValue, List whenClauses, UnresolvedExpression elseClause) { - this.caseValue =caseValue; - this.whenClauses = whenClauses; - this.elseClause = elseClause; - } - - public UnresolvedExpression getCaseValue() { - return caseValue; - } - - public List getWhenClauses() { - return whenClauses; - } - - public UnresolvedExpression getElseClause() { - return elseClause; - } - @Override public List getChild() { ImmutableList.Builder children = ImmutableList.builder(); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Compare.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Compare.java index d623612e8..309df600d 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Compare.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Compare.java @@ -5,39 +5,29 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Arrays; import java.util.List; +@Getter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class Compare extends UnresolvedExpression { - private String operator; - private UnresolvedExpression left; - private UnresolvedExpression right; - - public Compare(String operator, UnresolvedExpression left, UnresolvedExpression right) { - this.operator = operator; - this.left = left; - this.right = right; - } + private final String operator; + private final UnresolvedExpression left; + private final UnresolvedExpression right; @Override public List getChild() { return Arrays.asList(left, right); } - public String getOperator() { - return operator; - } - - public UnresolvedExpression getLeft() { - return left; - } - - public UnresolvedExpression getRight() { - return right; - } - @Override public R accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitCompare(this, context); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/DataType.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/DataType.java index 516106705..9843158b4 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/DataType.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/DataType.java @@ -5,10 +5,13 @@ package org.opensearch.sql.ast.expression; +import lombok.Getter; +import lombok.RequiredArgsConstructor; import org.opensearch.sql.data.type.ExprCoreType; /** The DataType defintion in AST. Question, could we use {@link ExprCoreType} directly in AST? */ +@RequiredArgsConstructor public enum DataType { TYPE_ERROR(ExprCoreType.UNKNOWN), NULL(ExprCoreType.UNDEFINED), @@ -26,13 +29,5 @@ public enum DataType { TIMESTAMP(ExprCoreType.TIMESTAMP), INTERVAL(ExprCoreType.INTERVAL); - private final ExprCoreType coreType; - - DataType(ExprCoreType type) { - this.coreType = type; - } - - public ExprCoreType getCoreType() { - return coreType; - } + @Getter private final ExprCoreType coreType; } diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/EqualTo.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/EqualTo.java index b06ced60f..d966bd4b2 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/EqualTo.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/EqualTo.java @@ -5,29 +5,24 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Arrays; import java.util.List; /** Expression node of binary operator or comparison relation EQUAL. */ +@ToString +@Getter +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class EqualTo extends UnresolvedExpression { private final UnresolvedExpression left; private final UnresolvedExpression right; - public EqualTo(UnresolvedExpression left, UnresolvedExpression right) { - this.left = left; - this.right = right; - } - - public UnresolvedExpression getLeft() { - return left; - } - - public UnresolvedExpression getRight() { - return right; - } - @Override public List getChild() { return Arrays.asList(left, right); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Field.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Field.java index a8ec28d0e..e77430400 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Field.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Field.java @@ -6,11 +6,17 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Collections; import java.util.List; +@Getter +@ToString +@EqualsAndHashCode(callSuper = false) public class Field extends UnresolvedExpression { private final QualifiedName field; private final List fieldArgs; @@ -26,14 +32,6 @@ public Field(QualifiedName field, List fieldArgs) { this.fieldArgs = fieldArgs; } - public QualifiedName getField() { - return field; - } - - public List getFieldArgs() { - return fieldArgs; - } - public boolean hasArgument() { return !fieldArgs.isEmpty(); } diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/FieldsMapping.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/FieldsMapping.java index 37d31b822..a53b1e130 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/FieldsMapping.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/FieldsMapping.java @@ -1,16 +1,17 @@ package org.opensearch.sql.ast.expression; +import lombok.Getter; +import lombok.RequiredArgsConstructor; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.List; +@Getter +@RequiredArgsConstructor public class FieldsMapping extends UnresolvedExpression { private final List fieldsMappingList; - public FieldsMapping(List fieldsMappingList) { - this.fieldsMappingList = fieldsMappingList; - } public List getChild() { return fieldsMappingList; } diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Function.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Function.java index c546d001d..54af537be 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Function.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Function.java @@ -5,6 +5,9 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Collections; @@ -15,15 +18,12 @@ * Expression node of scalar function. Params include function name (@funcName) and function * arguments (@funcArgs) */ - +@Getter +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class Function extends UnresolvedExpression { - private String funcName; - private List funcArgs; - - public Function(String funcName, List funcArgs) { - this.funcName = funcName; - this.funcArgs = funcArgs; - } + private final String funcName; + private final List funcArgs; @Override public List getChild() { @@ -35,14 +35,6 @@ public R accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitFunction(this, context); } - public String getFuncName() { - return funcName; - } - - public List getFuncArgs() { - return funcArgs; - } - @Override public String toString() { return String.format( diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/In.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/In.java index 16a75963e..d555d0dbc 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/In.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/In.java @@ -5,6 +5,10 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Arrays; @@ -15,15 +19,13 @@ * wildcard field expression, nested field expression (@field). And the values that the field is * mapped to (@valueList). */ - +@Getter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class In extends UnresolvedExpression { - private UnresolvedExpression field; - private List valueList; - - public In(UnresolvedExpression field, List valueList) { - this.field = field; - this.valueList = valueList; - } + private final UnresolvedExpression field; + private final List valueList; @Override public List getChild() { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Interval.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Interval.java index 92b5ca333..fc09ec2f5 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Interval.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Interval.java @@ -5,21 +5,24 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Collections; import java.util.List; - +@Getter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class Interval extends UnresolvedExpression { private final UnresolvedExpression value; private final IntervalUnit unit; - public Interval(UnresolvedExpression value, IntervalUnit unit) { - this.value = value; - this.unit = unit; - } public Interval(UnresolvedExpression value, String unit) { this.value = value; this.unit = IntervalUnit.of(unit); @@ -30,14 +33,6 @@ public List getChild() { return Collections.singletonList(value); } - public UnresolvedExpression getValue() { - return value; - } - - public IntervalUnit getUnit() { - return unit; - } - @Override public R accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitInterval(this, context); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/IntervalUnit.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/IntervalUnit.java index 14c7e0d45..a7e983473 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/IntervalUnit.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/IntervalUnit.java @@ -6,10 +6,13 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.Getter; +import lombok.RequiredArgsConstructor; import java.util.List; - +@Getter +@RequiredArgsConstructor public enum IntervalUnit { UNKNOWN, diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/IsEmpty.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/IsEmpty.java index 9b2e368a2..0374d1c90 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/IsEmpty.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/IsEmpty.java @@ -1,16 +1,19 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.List; +@Getter +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class IsEmpty extends UnresolvedExpression { - private Case caseValue; - - public IsEmpty(Case caseValue) { - this.caseValue = caseValue; - } + private final Case caseValue; @Override public List getChild() { @@ -22,10 +25,6 @@ public R accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitIsEmpty(this, context); } - public Case getCaseValue() { - return caseValue; - } - @Override public String toString() { return String.format( diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Let.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Let.java index 85c5f45de..b17730be0 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Let.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Let.java @@ -6,6 +6,10 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.List; @@ -13,24 +17,13 @@ /** * Represent the assign operation. e.g. velocity = distance/speed. */ - - +@Getter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class Let extends UnresolvedExpression { - private Field var; - private UnresolvedExpression expression; - - public Let(Field var, UnresolvedExpression expression) { - this.var = var; - this.expression = expression; - } - - public Field getVar() { - return var; - } - - public UnresolvedExpression getExpression() { - return expression; - } + private final Field var; + private final UnresolvedExpression expression; @Override public List getChild() { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Literal.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Literal.java index e7f1937ba..4751d72b0 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Literal.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Literal.java @@ -6,6 +6,9 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.List; @@ -14,16 +17,13 @@ * Expression node of literal type Params include literal value (@value) and literal data type * (@type) which can be selected from {@link DataType}. */ - +@Getter +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class Literal extends UnresolvedExpression { - private Object value; - private DataType type; - - public Literal(Object value, DataType dataType) { - this.value = value; - this.type = dataType; - } + private final Object value; + private final DataType type; @Override public List getChild() { @@ -35,14 +35,6 @@ public R accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitLiteral(this, context); } - public Object getValue() { - return value; - } - - public DataType getType() { - return type; - } - @Override public String toString() { return String.valueOf(value); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Map.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Map.java index 825a0f184..43ed06433 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Map.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Map.java @@ -5,29 +5,23 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Arrays; import java.util.List; /** Expression node of one-to-one mapping relation. */ - +@Getter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class Map extends UnresolvedExpression { - private UnresolvedExpression origin; - private UnresolvedExpression target; - - public Map(UnresolvedExpression origin, UnresolvedExpression target) { - this.origin = origin; - this.target = target; - } - - public UnresolvedExpression getOrigin() { - return origin; - } - - public UnresolvedExpression getTarget() { - return target; - } + private final UnresolvedExpression origin; + private final UnresolvedExpression target; @Override public List getChild() { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Not.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Not.java index f55433774..8a71e7b1b 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Not.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Not.java @@ -5,29 +5,28 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Arrays; import java.util.List; /** Expression node of the logic NOT. */ - +@Getter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class Not extends UnresolvedExpression { - private UnresolvedExpression expression; - - public Not(UnresolvedExpression expression) { - this.expression = expression; - } + private final UnresolvedExpression expression; @Override public List getChild() { return Arrays.asList(expression); } - public UnresolvedExpression getExpression() { - return expression; - } - @Override public R accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitNot(this, context); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Or.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Or.java index d76cda695..f4dc2935f 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Or.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Or.java @@ -5,16 +5,19 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Arrays; import java.util.List; /** Expression node of the logic OR. */ - +@ToString +@EqualsAndHashCode(callSuper = true) public class Or extends BinaryExpression { public Or(UnresolvedExpression left, UnresolvedExpression right) { - super(left,right); + super(left, right); } @Override public R accept(AbstractNodeVisitor nodeVisitor, C context) { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/ParseMethod.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/ParseMethod.java index 2ae3235a9..8cffa3b4b 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/ParseMethod.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/ParseMethod.java @@ -5,14 +5,15 @@ package org.opensearch.sql.ast.expression; +import lombok.Getter; +import lombok.RequiredArgsConstructor; + +@Getter +@RequiredArgsConstructor public enum ParseMethod { REGEX("regex"), GROK("grok"), PATTERNS("patterns"); - private final String name; - - ParseMethod(String name) { - this.name = name; - } + private final String name; } diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/QualifiedName.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/QualifiedName.java index 133edf3ff..0b4f039f8 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/QualifiedName.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/QualifiedName.java @@ -6,19 +6,22 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; -import java.util.Objects; import java.util.Optional; import java.util.stream.StreamSupport; import static java.util.Objects.requireNonNull; import static java.util.stream.Collectors.toList; +@Getter +@EqualsAndHashCode(callSuper = false) public class QualifiedName extends UnresolvedExpression { private final List parts; @@ -35,10 +38,6 @@ public QualifiedName(Iterable parts) { this.parts = partsList; } - public List getParts() { - return parts; - } - /** Construct {@link QualifiedName} from list of string. */ public static QualifiedName of(String first, String... rest) { requireNonNull(first); @@ -108,17 +107,4 @@ public List getChild() { public R accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitQualifiedName(this, context); } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - QualifiedName that = (QualifiedName) o; - return Objects.equals(parts, that.parts); - } - - @Override - public int hashCode() { - return Objects.hashCode(parts); - } } diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Scope.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Scope.java index 3fbe53cd2..fb18b8c1e 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Scope.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Scope.java @@ -1,6 +1,11 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.ToString; + /** Scope expression node. Params include field expression and the scope value. */ +@ToString +@EqualsAndHashCode(callSuper = true) public class Scope extends Span { public Scope(UnresolvedExpression field, UnresolvedExpression value, SpanUnit unit) { super(field, value, unit); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Span.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Span.java index b68edbc62..8d4cce4e2 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Span.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Span.java @@ -6,33 +6,23 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.List; /** Span expression node. Params include field expression and the span value. */ +@Getter +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor +@ToString public class Span extends UnresolvedExpression { - private UnresolvedExpression field; - private UnresolvedExpression value; - private SpanUnit unit; - - public Span(UnresolvedExpression field, UnresolvedExpression value, SpanUnit unit) { - this.field = field; - this.value = value; - this.unit = unit; - } - - public UnresolvedExpression getField() { - return field; - } - - public UnresolvedExpression getValue() { - return value; - } - - public SpanUnit getUnit() { - return unit; - } + private final UnresolvedExpression field; + private final UnresolvedExpression value; + private final SpanUnit unit; @Override public List getChild() { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/SpanUnit.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/SpanUnit.java index d8bacc2f9..c3a0835e0 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/SpanUnit.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/SpanUnit.java @@ -6,10 +6,13 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.Getter; +import lombok.RequiredArgsConstructor; import java.util.List; - +@Getter +@RequiredArgsConstructor public enum SpanUnit { UNKNOWN("unknown"), NONE(""), @@ -40,10 +43,6 @@ public enum SpanUnit { SPAN_UNITS = builder.add(SpanUnit.values()).build(); } - SpanUnit(String name) { - this.name = name; - } - /** Util method to get span unit given the unit name. */ public static SpanUnit of(String unit) { switch (unit) { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedArgument.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedArgument.java index 38daa476b..cd3e626a2 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedArgument.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedArgument.java @@ -5,22 +5,24 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Arrays; import java.util.List; /** Argument. */ - +@Getter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class UnresolvedArgument extends UnresolvedExpression { private final String argName; private final UnresolvedExpression value; - public UnresolvedArgument(String argName, UnresolvedExpression value) { - this.argName = argName; - this.value = value; - } - @Override public List getChild() { return Arrays.asList(value); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedAttribute.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedAttribute.java index 043d1dd02..c0c37e536 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedAttribute.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedAttribute.java @@ -6,6 +6,10 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.List; @@ -14,13 +18,11 @@ * Expression node, representing the syntax that is not resolved to any other expression nodes yet * but non-negligible This expression is often created as the index name, field name etc. */ - +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor +@Getter public class UnresolvedAttribute extends UnresolvedExpression { - private String attr; - - public UnresolvedAttribute(String attr) { - this.attr = attr; - } @Override public List getChild() { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedExpression.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedExpression.java index 25029e07d..9b2d530b7 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedExpression.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/UnresolvedExpression.java @@ -5,9 +5,13 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.Node; +@EqualsAndHashCode(callSuper = false) +@ToString public abstract class UnresolvedExpression extends Node { @Override public T accept(AbstractNodeVisitor nodeVisitor, C context) { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/When.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/When.java index 455722e29..14ebfe9ac 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/When.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/When.java @@ -6,32 +6,27 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.Node; import java.util.List; /** AST node that represents WHEN clause. */ +@EqualsAndHashCode(callSuper = false) +@Getter +@RequiredArgsConstructor +@ToString public class When extends UnresolvedExpression { /** WHEN condition, either a search condition or compare value if case value present. */ - private UnresolvedExpression condition; + private final UnresolvedExpression condition; /** Result to return if condition matched. */ - private UnresolvedExpression result; - - public When(UnresolvedExpression condition, UnresolvedExpression result) { - this.condition = condition; - this.result = result; - } - - public UnresolvedExpression getCondition() { - return condition; - } - - public UnresolvedExpression getResult() { - return result; - } + private final UnresolvedExpression result; @Override public List getChild() { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/WindowFunction.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/WindowFunction.java index eccf5c6e7..ba9a354d4 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/WindowFunction.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/WindowFunction.java @@ -6,6 +6,11 @@ package org.opensearch.sql.ast.expression; import com.google.common.collect.ImmutableList; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.apache.commons.lang3.tuple.Pair; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.Node; @@ -13,17 +18,16 @@ import java.util.List; +@AllArgsConstructor +@EqualsAndHashCode(callSuper = false) +@Getter +@RequiredArgsConstructor +@ToString public class WindowFunction extends UnresolvedExpression { - private UnresolvedExpression function; + private final UnresolvedExpression function; private List partitionByList; private List> sortList; - public WindowFunction(UnresolvedExpression function, List partitionByList, List> sortList) { - this.function = function; - this.partitionByList = partitionByList; - this.sortList = sortList; - } - @Override public List getChild() { ImmutableList.Builder children = ImmutableList.builder(); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Xor.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Xor.java index 9f618a067..6b31398fa 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Xor.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/expression/Xor.java @@ -5,19 +5,20 @@ package org.opensearch.sql.ast.expression; +import lombok.EqualsAndHashCode; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.Arrays; import java.util.List; /** Expression node of the logic XOR. */ - +@ToString +@EqualsAndHashCode(callSuper = true) public class Xor extends BinaryExpression { - private UnresolvedExpression left; - private UnresolvedExpression right; public Xor(UnresolvedExpression left, UnresolvedExpression right) { - super(left,right); + super(left, right); } @Override diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/statement/Explain.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/statement/Explain.java index 4968668ac..5ee260c13 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/statement/Explain.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/statement/Explain.java @@ -8,20 +8,16 @@ package org.opensearch.sql.ast.statement; +import lombok.Data; +import lombok.EqualsAndHashCode; import org.opensearch.sql.ast.AbstractNodeVisitor; /** Explain Statement. */ +@Data +@EqualsAndHashCode(callSuper = false) public class Explain extends Statement { - private Statement statement; - - public Explain(Query statement) { - this.statement = statement; - } - - public Statement getStatement() { - return statement; - } + private final Statement statement; @Override public R accept(AbstractNodeVisitor visitor, C context) { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/statement/Query.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/statement/Query.java index 6a7ac1530..6366451b7 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/statement/Query.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/statement/Query.java @@ -8,23 +8,24 @@ package org.opensearch.sql.ast.statement; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.Setter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.tree.UnresolvedPlan; /** Query Statement. */ +@Getter +@Setter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class Query extends Statement { - protected UnresolvedPlan plan; - protected int fetchSize; - - public Query(UnresolvedPlan plan, int fetchSize) { - this.plan = plan; - this.fetchSize = fetchSize; - } - - public UnresolvedPlan getPlan() { - return plan; - } + protected final UnresolvedPlan plan; + protected final int fetchSize; @Override public R accept(AbstractNodeVisitor visitor, C context) { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Aggregation.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Aggregation.java index 825c6d340..4f4824fb8 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Aggregation.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Aggregation.java @@ -6,6 +6,10 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.Argument; import org.opensearch.sql.ast.expression.UnresolvedExpression; @@ -14,6 +18,10 @@ import java.util.List; /** Logical plan node of Aggregation, the interface for building aggregation actions in queries. */ +@Getter +@Setter +@ToString +@EqualsAndHashCode(callSuper = false) public class Aggregation extends UnresolvedPlan { private List aggExprList; private List sortExprList; @@ -44,26 +52,6 @@ public Aggregation( this.argExprList = argExprList; } - public List getAggExprList() { - return aggExprList; - } - - public List getSortExprList() { - return sortExprList; - } - - public List getGroupExprList() { - return groupExprList; - } - - public UnresolvedExpression getSpan() { - return span; - } - - public List getArgExprList() { - return argExprList; - } - public boolean hasArgument() { return !aggExprList.isEmpty(); } diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Correlation.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Correlation.java index 0a49bbb6c..f7bd8ad9a 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Correlation.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Correlation.java @@ -1,6 +1,10 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.Node; import org.opensearch.sql.ast.expression.FieldsMapping; @@ -10,7 +14,10 @@ import java.util.List; /** Logical plan node of correlation , the interface for building the searching sources. */ - +@ToString +@Getter +@RequiredArgsConstructor +@EqualsAndHashCode(callSuper = false) public class Correlation extends UnresolvedPlan { private final CorrelationType correlationType; private final List fieldsList; @@ -40,27 +47,9 @@ public Correlation attach(UnresolvedPlan child) { return this; } - public CorrelationType getCorrelationType() { - return correlationType; - } - - public List getFieldsList() { - return fieldsList; - } - - public Scope getScope() { - return scope; - } - - public FieldsMapping getMappingListContext() { - return mappingListContext; - } - public enum CorrelationType { self, exact, approximate } - - } diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Dedupe.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Dedupe.java index a428e68ad..dcfc1f277 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Dedupe.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Dedupe.java @@ -6,6 +6,12 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.Setter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.Argument; import org.opensearch.sql.ast.expression.Field; @@ -13,20 +19,16 @@ import java.util.List; /** AST node represent Dedupe operation. */ +@Getter +@Setter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor +@AllArgsConstructor public class Dedupe extends UnresolvedPlan { private UnresolvedPlan child; - private List options; - private List fields; - - public Dedupe(UnresolvedPlan child, List options, List fields) { - this.child = child; - this.options = options; - this.fields = fields; - } - public Dedupe(List options, List fields) { - this.options = options; - this.fields = fields; - } + private final List options; + private final List fields; @Override public Dedupe attach(UnresolvedPlan child) { @@ -34,14 +36,6 @@ public Dedupe attach(UnresolvedPlan child) { return this; } - public List getOptions() { - return options; - } - - public List getFields() { - return fields; - } - @Override public List getChild() { return ImmutableList.of(this.child); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/DescribeRelation.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/DescribeRelation.java index 5fd237bcb..b513d01bf 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/DescribeRelation.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/DescribeRelation.java @@ -5,11 +5,13 @@ package org.opensearch.sql.ast.tree; +import lombok.ToString; import org.opensearch.sql.ast.expression.UnresolvedExpression; /** * Extend Relation to describe the table itself */ +@ToString public class DescribeRelation extends Relation{ public DescribeRelation(UnresolvedExpression tableName) { super(tableName); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Eval.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Eval.java index 24a6bb428..0cc27b6a9 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Eval.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Eval.java @@ -6,24 +6,26 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.Setter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.Let; import java.util.List; /** AST node represent Eval operation. */ +@Getter +@Setter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class Eval extends UnresolvedPlan { - private List expressionList; + private final List expressionList; private UnresolvedPlan child; - public Eval(List expressionList) { - this.expressionList = expressionList; - } - - public List getExpressionList() { - return expressionList; - } - @Override public Eval attach(UnresolvedPlan child) { this.child = child; diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Filter.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Filter.java index 244181653..e37b8b163 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Filter.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Filter.java @@ -6,13 +6,18 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.UnresolvedExpression; import java.util.List; /** Logical plan node of Filter, the interface for building filters in queries. */ - +@ToString +@EqualsAndHashCode(callSuper = false) +@Getter public class Filter extends UnresolvedPlan { private UnresolvedExpression condition; private UnresolvedPlan child; @@ -27,10 +32,6 @@ public Filter attach(UnresolvedPlan child) { return this; } - public UnresolvedExpression getCondition() { - return condition; - } - @Override public List getChild() { return ImmutableList.of(child); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Head.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Head.java index 560ffda6e..1e64045e9 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Head.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Head.java @@ -6,28 +6,28 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.Setter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.List; /** AST node represent Head operation. */ - +@Getter +@Setter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor +@AllArgsConstructor public class Head extends UnresolvedPlan { private UnresolvedPlan child; - private Integer size; - private Integer from; - - public Head(UnresolvedPlan child, Integer size, Integer from) { - this.child = child; - this.size = size; - this.from = from; - } - - public Head(Integer size, Integer from) { - this.size = size; - this.from = from; - } + private final Integer size; + private final Integer from; @Override public Head attach(UnresolvedPlan child) { @@ -35,14 +35,6 @@ public Head attach(UnresolvedPlan child) { return this; } - public Integer getSize() { - return size; - } - - public Integer getFrom() { - return from; - } - @Override public List getChild() { return ImmutableList.of(this.child); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Join.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Join.java index 327ef62c2..89f787d34 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Join.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Join.java @@ -8,13 +8,20 @@ import com.google.common.collect.ImmutableList; import java.util.List; import java.util.Map; -import java.util.Objects; import java.util.Optional; import com.google.common.collect.ImmutableMap; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.UnresolvedExpression; +@ToString +@Getter +@RequiredArgsConstructor +@EqualsAndHashCode(callSuper = false) public class Join extends UnresolvedPlan { private UnresolvedPlan left; private final UnresolvedPlan right; @@ -24,21 +31,6 @@ public class Join extends UnresolvedPlan { private final Optional joinCondition; private final JoinHint joinHint; - public Join( - UnresolvedPlan right, - String leftAlias, - String rightAlias, - JoinType joinType, - Optional joinCondition, - JoinHint joinHint) { - this.right = right; - this.leftAlias = leftAlias; - this.rightAlias = rightAlias; - this.joinType = joinType; - this.joinCondition = joinCondition; - this.joinHint = joinHint; - } - @Override public UnresolvedPlan attach(UnresolvedPlan child) { this.left = new SubqueryAlias(leftAlias, child); @@ -65,56 +57,13 @@ public enum JoinType { FULL } - public UnresolvedPlan getRight() { - return right; - } - - public String getLeftAlias() { - return leftAlias; - } - - public String getRightAlias() { - return rightAlias; - } - - public JoinType getJoinType() { - return joinType; - } - - public Optional getJoinCondition() { - return joinCondition; - } - - public JoinHint getJoinHint() { - return joinHint; - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - Join join = (Join) o; - return Objects.equals(left, join.left) && Objects.equals(right, join.right) && Objects.equals(leftAlias, join.leftAlias) && Objects.equals(rightAlias, join.rightAlias) && joinType == join.joinType && Objects.equals(joinCondition, join.joinCondition) && Objects.equals(joinHint, join.joinHint); - } - - @Override - public int hashCode() { - return Objects.hash(left, right, leftAlias, rightAlias, joinType, joinCondition, joinHint); - } - + @Getter + @RequiredArgsConstructor public static class JoinHint { private final Map hints; public JoinHint() { this.hints = ImmutableMap.of(); } - - public JoinHint(Map hints) { - this.hints = hints; - } - - public Map getHints() { - return hints; - } } } \ No newline at end of file diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Kmeans.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Kmeans.java index 6e3e67eaa..3c4bc2624 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Kmeans.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Kmeans.java @@ -7,20 +7,28 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.Setter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.Literal; import java.util.List; import java.util.Map; +@Getter +@Setter +@ToString +@EqualsAndHashCode(callSuper = true) +@RequiredArgsConstructor +@AllArgsConstructor public class Kmeans extends UnresolvedPlan { private UnresolvedPlan child; - private Map arguments; - - public Kmeans(ImmutableMap arguments) { - this.arguments = arguments; - } + private final Map arguments; @Override public UnresolvedPlan attach(UnresolvedPlan child) { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Limit.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Limit.java index 3fce9c0aa..78b543a92 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Limit.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Limit.java @@ -6,19 +6,22 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.List; +@RequiredArgsConstructor +@Getter +@ToString +@EqualsAndHashCode(callSuper = false) public class Limit extends UnresolvedPlan { private UnresolvedPlan child; - private Integer limit; - private Integer offset; - - public Limit(Integer limit, Integer offset) { - this.limit = limit; - this.offset = offset; - } + private final Integer limit; + private final Integer offset; @Override public Limit attach(UnresolvedPlan child) { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Lookup.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Lookup.java index 631aa93f7..40a6710cb 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Lookup.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Lookup.java @@ -6,6 +6,10 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.Node; import org.opensearch.sql.ast.expression.Alias; @@ -18,24 +22,23 @@ import java.util.stream.Collectors; /** AST node represent Lookup operation. */ +@ToString +@Getter +@RequiredArgsConstructor +@EqualsAndHashCode(callSuper = false) public class Lookup extends UnresolvedPlan { private UnresolvedPlan child; private final UnresolvedPlan lookupRelation; private final Map lookupMappingMap; private final OutputStrategy outputStrategy; + /** + * Output candidate field map. + * Format: Key -> Alias(outputFieldName, inputField), Value -> Field(outputField). For example: + * 1. When output candidate is "name AS cName", the key will be Alias("cName", Field(name)), the value will be Field(cName) + * 2. When output candidate is "dept", the key is Alias("dept", Field(dept)), value is Field(dept) + */ private final Map outputCandidateMap; - public Lookup( - UnresolvedPlan lookupRelation, - Map lookupMappingMap, - OutputStrategy outputStrategy, - Map outputCandidateMap) { - this.lookupRelation = lookupRelation; - this.lookupMappingMap = lookupMappingMap; - this.outputStrategy = outputStrategy; - this.outputCandidateMap = outputCandidateMap; - } - @Override public UnresolvedPlan attach(UnresolvedPlan child) { this.child = new SubqueryAlias(child, "_s"); // add a auto generated alias name @@ -57,10 +60,6 @@ public enum OutputStrategy { REPLACE } - public UnresolvedPlan getLookupRelation() { - return lookupRelation; - } - public String getLookupSubqueryAliasName() { return ((SubqueryAlias) lookupRelation).getAlias(); } @@ -87,20 +86,6 @@ public Map getLookupMappingMap() { LinkedHashMap::new)); } - public OutputStrategy getOutputStrategy() { - return outputStrategy; - } - - /** - * Output candidate field map. - * Format: Key -> Alias(outputFieldName, inputField), Value -> Field(outputField). For example: - * 1. When output candidate is "name AS cName", the key will be Alias("cName", Field(name)), the value will be Field(cName) - * 2. When output candidate is "dept", the key is Alias("dept", Field(dept)), value is Field(dept) - */ - public Map getOutputCandidateMap() { - return outputCandidateMap; - } - /** Return a new input field list with source side SubqueryAlias */ public List getFieldListWithSourceSubqueryAlias() { return getOutputCandidateMap().values().stream().map(f -> diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Parse.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Parse.java index 4b2d6e9c1..9281460a2 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Parse.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Parse.java @@ -6,6 +6,12 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.Setter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.Literal; import org.opensearch.sql.ast.expression.ParseMethod; @@ -15,55 +21,28 @@ import java.util.Map; /** AST node represent Parse with regex operation. */ - +@Getter +@Setter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor +@AllArgsConstructor public class Parse extends UnresolvedPlan { /** Method used to parse a field. */ - private ParseMethod parseMethod; + private final ParseMethod parseMethod; /** Field. */ - private UnresolvedExpression sourceField; + private final UnresolvedExpression sourceField; /** Pattern. */ - private Literal pattern; + private final Literal pattern; /** Optional arguments. */ - private Map arguments; + private final Map arguments; /** Child Plan. */ private UnresolvedPlan child; - public Parse(ParseMethod parseMethod, UnresolvedExpression sourceField, Literal pattern, Map arguments, UnresolvedPlan child) { - this.parseMethod = parseMethod; - this.sourceField = sourceField; - this.pattern = pattern; - this.arguments = arguments; - this.child = child; - } - - public Parse(ParseMethod parseMethod, UnresolvedExpression sourceField, Literal pattern, Map arguments) { - - this.parseMethod = parseMethod; - this.sourceField = sourceField; - this.pattern = pattern; - this.arguments = arguments; - } - - public ParseMethod getParseMethod() { - return parseMethod; - } - - public UnresolvedExpression getSourceField() { - return sourceField; - } - - public Literal getPattern() { - return pattern; - } - - public Map getArguments() { - return arguments; - } - @Override public Parse attach(UnresolvedPlan child) { this.child = child; diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Project.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Project.java index 6237f6b4c..47e83ca5f 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Project.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Project.java @@ -6,6 +6,10 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.Setter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.Argument; import org.opensearch.sql.ast.expression.UnresolvedExpression; @@ -14,8 +18,11 @@ import java.util.List; /** Logical plan node of Project, the interface for building the list of searching fields. */ +@ToString +@Getter +@EqualsAndHashCode(callSuper = false) public class Project extends UnresolvedPlan { - private List projectList; + @Setter private List projectList; private List argExprList; private UnresolvedPlan child; @@ -29,14 +36,6 @@ public Project(List projectList, List argExprLis this.argExprList = argExprList; } - public List getProjectList() { - return projectList; - } - - public List getArgExprList() { - return argExprList; - } - public boolean hasArgument() { return !argExprList.isEmpty(); } diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/RareAggregation.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/RareAggregation.java index 55b2e4c43..d5a637f3d 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/RareAggregation.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/RareAggregation.java @@ -5,12 +5,16 @@ package org.opensearch.sql.ast.tree; +import lombok.EqualsAndHashCode; +import lombok.ToString; import org.opensearch.sql.ast.expression.UnresolvedExpression; import java.util.Collections; import java.util.List; /** Logical plan node of Rare (Aggregation) command, the interface for building aggregation actions in queries. */ +@ToString +@EqualsAndHashCode(callSuper = true) public class RareAggregation extends Aggregation { /** Aggregation Constructor without span and argument. */ public RareAggregation( @@ -19,5 +23,4 @@ public RareAggregation( List groupExprList) { super(aggExprList, sortExprList, groupExprList, null, Collections.emptyList()); } - } diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/RareTopN.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/RareTopN.java index 6b05288cc..148e204b3 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/RareTopN.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/RareTopN.java @@ -5,6 +5,12 @@ package org.opensearch.sql.ast.tree; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.Setter; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.Argument; import org.opensearch.sql.ast.expression.Field; @@ -14,21 +20,19 @@ import java.util.List; /** AST node represent RareTopN operation. */ - +@Getter +@Setter +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor +@AllArgsConstructor public class RareTopN extends UnresolvedPlan { private UnresolvedPlan child; - private CommandType commandType; - private List noOfResults; - private List fields; - private List groupExprList; - - public RareTopN( CommandType commandType, List noOfResults, List fields, List groupExprList) { - this.commandType = commandType; - this.noOfResults = noOfResults; - this.fields = fields; - this.groupExprList = groupExprList; - } + private final CommandType commandType; + private final List noOfResults; + private final List fields; + private final List groupExprList; @Override public RareTopN attach(UnresolvedPlan child) { @@ -36,22 +40,6 @@ public RareTopN attach(UnresolvedPlan child) { return this; } - public CommandType getCommandType() { - return commandType; - } - - public List getNoOfResults() { - return noOfResults; - } - - public List getFields() { - return fields; - } - - public List getGroupExprList() { - return groupExprList; - } - @Override public List getChild() { return Collections.singletonList(this.child); diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Relation.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Relation.java index 6a482db67..cb9bbd64d 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Relation.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Relation.java @@ -6,6 +6,10 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.QualifiedName; import org.opensearch.sql.ast.expression.UnresolvedExpression; @@ -15,7 +19,10 @@ import java.util.stream.Collectors; /** Logical plan node of Relation, the interface for building the searching sources. */ - +@AllArgsConstructor +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class Relation extends UnresolvedPlan { private static final String COMMA = ","; @@ -25,10 +32,6 @@ public Relation(UnresolvedExpression tableName) { this(tableName, null); } - public Relation(List tableName) { - this.tableName = tableName; - } - public Relation(UnresolvedExpression tableName, String alias) { this.tableName = Arrays.asList(tableName); this.alias = alias; @@ -46,7 +49,6 @@ public List getTableName() { return tableName.stream().map(Object::toString).collect(Collectors.toList()); } - /** * Return alias. * diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Rename.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Rename.java index c3f215177..2cc2a3e73 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Rename.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Rename.java @@ -6,11 +6,19 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.Map; import java.util.List; +@ToString +@EqualsAndHashCode(callSuper = false) +@Getter +@RequiredArgsConstructor public class Rename extends UnresolvedPlan { private final List renameList; private UnresolvedPlan child; @@ -20,14 +28,6 @@ public Rename(List renameList, UnresolvedPlan child) { this.child = child; } - public Rename(List renameList) { - this.renameList = renameList; - } - - public List getRenameList() { - return renameList; - } - @Override public Rename attach(UnresolvedPlan child) { if (null == this.child) { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Sort.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Sort.java index e502662f4..ab1740cef 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Sort.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Sort.java @@ -6,6 +6,12 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.Field; @@ -19,19 +25,14 @@ /** * AST node for Sort {@link Sort#sortList} represent a list of sort expression and sort options. */ - - +@ToString +@EqualsAndHashCode(callSuper = false) +@Getter +@RequiredArgsConstructor +@AllArgsConstructor public class Sort extends UnresolvedPlan { private UnresolvedPlan child; - private List sortList; - - public Sort(List sortList) { - this.sortList = sortList; - } - public Sort(UnresolvedPlan child, List sortList) { - this.child = child; - this.sortList = sortList; - } + private final List sortList; @Override public Sort attach(UnresolvedPlan child) { @@ -49,14 +50,10 @@ public T accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitSort(this, context); } - public List getSortList() { - return sortList; - } - /** * Sort Options. */ - + @Data public static class SortOption { /** @@ -69,13 +66,8 @@ public static class SortOption { */ public static SortOption DEFAULT_DESC = new SortOption(DESC, NULL_LAST); - private SortOrder sortOrder; - private NullOrder nullOrder; - - public SortOption(SortOrder sortOrder, NullOrder nullOrder) { - this.sortOrder = sortOrder; - this.nullOrder = nullOrder; - } + private final SortOrder sortOrder; + private final NullOrder nullOrder; } public enum SortOrder { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/SubqueryAlias.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/SubqueryAlias.java index 804d5224b..29c3d4b90 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/SubqueryAlias.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/SubqueryAlias.java @@ -6,20 +6,24 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import java.util.List; import java.util.Objects; +@AllArgsConstructor +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor +@ToString public class SubqueryAlias extends UnresolvedPlan { - private final String alias; + @Getter private final String alias; private UnresolvedPlan child; - public SubqueryAlias(String alias, UnresolvedPlan child) { - this.alias = alias; - this.child = child; - } - /** * Create an alias (SubqueryAlias) for a sub-query with a default alias name */ @@ -28,10 +32,6 @@ public SubqueryAlias(UnresolvedPlan child, String suffix) { this.child = child; } - public String getAlias() { - return alias; - } - public List getChild() { return ImmutableList.of(child); } @@ -46,17 +46,4 @@ public UnresolvedPlan attach(UnresolvedPlan child) { public T accept(AbstractNodeVisitor nodeVisitor, C context) { return nodeVisitor.visitSubqueryAlias(this, context); } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - SubqueryAlias alias1 = (SubqueryAlias) o; - return Objects.equals(alias, alias1.alias) && Objects.equals(child, alias1.child); - } - - @Override - public int hashCode() { - return Objects.hash(alias, child); - } } diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/TableFunction.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/TableFunction.java index 823c975e9..1d4a27065 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/TableFunction.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/TableFunction.java @@ -6,6 +6,10 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.expression.QualifiedName; import org.opensearch.sql.ast.expression.UnresolvedExpression; @@ -15,22 +19,14 @@ /** * AST Node for Table Function. */ - - +@ToString +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class TableFunction extends UnresolvedPlan { - private UnresolvedExpression functionName; - - private List arguments; + private final UnresolvedExpression functionName; - public TableFunction(UnresolvedExpression functionName, List arguments) { - this.functionName = functionName; - this.arguments = arguments; - } - - public List getArguments() { - return arguments; - } + @Getter private final List arguments; public QualifiedName getFunctionName() { return (QualifiedName) functionName; diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/TopAggregation.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/TopAggregation.java index 451446cc3..e87a3b0b0 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/TopAggregation.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/TopAggregation.java @@ -5,6 +5,10 @@ package org.opensearch.sql.ast.tree; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.expression.Literal; import org.opensearch.sql.ast.expression.UnresolvedExpression; @@ -13,6 +17,9 @@ import java.util.Optional; /** Logical plan node of Top (Aggregation) command, the interface for building aggregation actions in queries. */ +@ToString +@Getter +@EqualsAndHashCode(callSuper = true) public class TopAggregation extends Aggregation { private final Optional results; @@ -25,8 +32,4 @@ public TopAggregation( super(aggExprList, sortExprList, groupExprList, null, Collections.emptyList()); this.results = results; } - - public Optional getResults() { - return results; - } } diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/UnresolvedPlan.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/UnresolvedPlan.java index 2de40e53a..3074303b0 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/UnresolvedPlan.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/UnresolvedPlan.java @@ -5,12 +5,14 @@ package org.opensearch.sql.ast.tree; +import lombok.EqualsAndHashCode; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.Node; /** Abstract unresolved plan. */ - - +@EqualsAndHashCode(callSuper = false) +@ToString public abstract class UnresolvedPlan extends Node { @Override public T accept(AbstractNodeVisitor nodeVisitor, C context) { diff --git a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Values.java b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Values.java index d6af4b6be..3cc393f39 100644 --- a/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Values.java +++ b/ppl-spark-integration/src/main/java/org/opensearch/sql/ast/tree/Values.java @@ -6,6 +6,10 @@ package org.opensearch.sql.ast.tree; import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.RequiredArgsConstructor; +import lombok.ToString; import org.opensearch.sql.ast.AbstractNodeVisitor; import org.opensearch.sql.ast.Node; import org.opensearch.sql.ast.expression.Literal; @@ -15,16 +19,13 @@ /** * AST node class for a sequence of literal values. */ - - +@ToString +@Getter +@EqualsAndHashCode(callSuper = false) +@RequiredArgsConstructor public class Values extends UnresolvedPlan { - private List> values; - - public Values(List list) { - - } - + private final List> values; @Override public UnresolvedPlan attach(UnresolvedPlan child) {