Added builder pattern

opendistro-for-elasticsearch · Apr 23, 2020 · acb1575 · acb1575
1 parent daf4767
commit acb1575
Show file tree

Hide file tree

Showing 7 changed files with 135 additions and 30 deletions.
diff --git a/ppl/src/main/java/com/amazon/opendistroforelasticsearch/sql/ppl/parser/AstBuilder.java b/ppl/src/main/java/com/amazon/opendistroforelasticsearch/sql/ppl/parser/AstBuilder.java
@@ -24,6 +24,7 @@
 import com.amazon.opendistroforelasticsearch.sql.ppl.plans.logical.UnresolvedPlan;
 import com.amazon.opendistroforelasticsearch.sql.ppl.plans.logical.Project;
 import com.amazon.opendistroforelasticsearch.sql.ppl.plans.logical.Relation;
+import com.amazon.opendistroforelasticsearch.sql.ppl.plans.logical.builder.UnresolvedPlanBuilder;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -55,8 +56,13 @@ public class AstBuilder extends OpenDistroPPLParserBaseVisitor<UnresolvedPlan> {
     @Override
     public UnresolvedPlan visitPplStatement(PplStatementContext ctx) {
         UnresolvedPlan search = visit(ctx.searchCommand());
-        UnresolvedPlan reduce = ctx.commands().stream().map(this::visit).reduce(search, (r, e) -> e.withInput(r));
-        return reduce;
+        return ctx
+                .commands()
+                .stream()
+                .map(this::visit)
+                .reduce(search,
+                        (r, e) -> createBuilder(e).attachPlan(r).build()
+                );
     }
 
     /** Search command */
@@ -67,12 +73,12 @@ public UnresolvedPlan visitSearchFrom(SearchFromContext ctx) {
 
     @Override
     public UnresolvedPlan visitSearchFromFilter(SearchFromFilterContext ctx) {
-        return new Filter(visitExpression(ctx.logicalExpression())).withInput(visit(ctx.fromClause()));
+        return new Filter.Builder(new Filter(visitExpression(ctx.logicalExpression()))).attachPlan(visit(ctx.fromClause())).build();
     }
 
     @Override
     public UnresolvedPlan visitSearchFilterFrom(SearchFilterFromContext ctx) {
-        return new Filter(visitExpression(ctx.logicalExpression())).withInput(visit(ctx.fromClause()));
+        return new Filter.Builder(new Filter(visitExpression(ctx.logicalExpression()))).attachPlan(visit(ctx.fromClause())).build();
     }
 
     /** Where command */
@@ -192,4 +198,22 @@ protected UnresolvedPlan aggregateResult(UnresolvedPlan aggregate, UnresolvedPla
         return aggregate;
     }
 
+    /**
+     * Create plan builder for accumulator in reduce
+     * @param plan UnresolvedPlan concrete subclass instance
+     * @return UnresolvedPlanBuilder concrete subclass instance or null
+     */
+    private UnresolvedPlanBuilder createBuilder(UnresolvedPlan plan) {
+        if (plan instanceof Filter) {
+            return new Filter.Builder((Filter) plan);
+        }
+        if (plan instanceof Project) {
+            return new Project.Builder((Project) plan);
+        }
+        if (plan instanceof Aggregation) {
+            return new Aggregation.Builder((Aggregation) plan);
+        }
+        return null;
+    }
+
 }
diff --git a/ppl/src/main/java/com/amazon/opendistroforelasticsearch/sql/ppl/plans/dsl/DSL.java b/ppl/src/main/java/com/amazon/opendistroforelasticsearch/sql/ppl/plans/dsl/DSL.java
@@ -41,20 +41,20 @@
 public class DSL {
 
     public static UnresolvedPlan filter(UnresolvedPlan input, Expression expression) {
-        return new Filter(expression).withInput(input);
+        return new Filter.Builder(new Filter(expression)).attachPlan(input).build();
     }
 
     public static UnresolvedPlan relation(String tableName) {
         return new Relation(tableName);
     }
 
     public static UnresolvedPlan project(UnresolvedPlan input, Expression... projectList) {
-        return new Project(Arrays.asList(projectList)).withInput(input);
+        return new Project.Builder(new Project(Arrays.asList(projectList))).attachPlan(input).build();
     }
 
     public static UnresolvedPlan agg(UnresolvedPlan input, List<Expression> aggList, List<Expression> sortList,
                                      List<Expression> groupList) {
-        return new Aggregation(aggList, sortList, groupList).withInput(input);
+        return new Aggregation.Builder(new Aggregation(aggList, sortList, groupList)).attachPlan(input).build();
     }
 
     public static Expression equalTo(Expression left, Expression right) {

diff --git a/...rc/main/java/com/amazon/opendistroforelasticsearch/sql/ppl/plans/logical/Aggregation.java b/...rc/main/java/com/amazon/opendistroforelasticsearch/sql/ppl/plans/logical/Aggregation.java
@@ -17,6 +17,7 @@
 
 import com.amazon.opendistroforelasticsearch.sql.ppl.node.AbstractNodeVisitor;
 import com.amazon.opendistroforelasticsearch.sql.ppl.plans.expression.Expression;
+import com.amazon.opendistroforelasticsearch.sql.ppl.plans.logical.builder.UnresolvedPlanBuilder;
 import com.google.common.collect.ImmutableList;
 import java.util.List;
 import lombok.AllArgsConstructor;
@@ -37,7 +38,7 @@ public class Aggregation extends UnresolvedPlan {
     private List<Expression> aggExprList;
     private List<Expression> sortExprList;
     private List<Expression> groupExprList;
-    private UnresolvedPlan input;
+    private UnresolvedPlan child;
 
     public Aggregation(List<Expression> aggExprList, List<Expression> sortExprList, List<Expression> groupExprList) {
         this.aggExprList = aggExprList;
@@ -47,11 +48,37 @@ public Aggregation(List<Expression> aggExprList, List<Expression> sortExprList,
 
     @Override
     public List<UnresolvedPlan> getChild() {
-        return ImmutableList.of(this.input);
+        return ImmutableList.of(this.child);
     }
 
     @Override
     public <T, C> T accept(AbstractNodeVisitor<T, C> nodeVisitor, C context) {
         return nodeVisitor.visitAggregation(this, context);
     }
+
+    private Aggregation(Builder builder) {
+        this.child = builder.child;
+    }
+
+    /**
+     * Aggregation plan builder
+     */
+    public static class Builder extends UnresolvedPlanBuilder<Aggregation> {
+        private UnresolvedPlan child;
+
+        public Builder(Aggregation plan) {
+            super(plan);
+        }
+
+        @Override
+        public UnresolvedPlanBuilder attachPlan(UnresolvedPlan attach) {
+            this.child = attach;
+            return this;
+        }
+
+        @Override
+        public Aggregation build() {
+            return new Aggregation(this);
+        }
+    }
 }
diff --git a/ppl/src/main/java/com/amazon/opendistroforelasticsearch/sql/ppl/plans/logical/Filter.java b/ppl/src/main/java/com/amazon/opendistroforelasticsearch/sql/ppl/plans/logical/Filter.java
@@ -17,6 +17,7 @@
 
 import com.amazon.opendistroforelasticsearch.sql.ppl.node.AbstractNodeVisitor;
 import com.amazon.opendistroforelasticsearch.sql.ppl.plans.expression.Expression;
+import com.amazon.opendistroforelasticsearch.sql.ppl.plans.logical.builder.UnresolvedPlanBuilder;
 import com.google.common.collect.ImmutableList;
 import java.util.List;
 import lombok.EqualsAndHashCode;
@@ -31,25 +32,45 @@
 @Getter
 public class Filter extends UnresolvedPlan {
     private Expression condition;
-    private UnresolvedPlan input;
+    private UnresolvedPlan child;
 
     public Filter(Expression condition) {
         this.condition = condition;
     }
 
-    @Override
-    public Filter withInput(UnresolvedPlan input) {
-        this.input = input;
-        return this;
-    }
-
     @Override
     public List<UnresolvedPlan> getChild() {
-        return ImmutableList.of(input);
+        return ImmutableList.of(child);
     }
 
     @Override
     public <T, C> T accept(AbstractNodeVisitor<T, C> nodeVisitor, C context) {
         return nodeVisitor.visitFilter(this, context);
     }
+
+    private Filter(Builder builder) {
+        this.child = builder.child;
+    }
+
+    /**
+     * Filter plan builder
+     */
+    public static class Builder extends UnresolvedPlanBuilder<Filter> {
+        UnresolvedPlan child;
+
+        public Builder(Filter plan) {
+            super(plan);
+        }
+
+        @Override
+        public Builder attachPlan(UnresolvedPlan attach) {
+            this.child = attach;
+            return this;
+        }
+
+        @Override
+        public Filter build() {
+            return new Filter(this);
+        }
+    }
 }
diff --git a/ppl/src/main/java/com/amazon/opendistroforelasticsearch/sql/ppl/plans/logical/Project.java b/ppl/src/main/java/com/amazon/opendistroforelasticsearch/sql/ppl/plans/logical/Project.java
@@ -17,6 +17,7 @@
 
 import com.amazon.opendistroforelasticsearch.sql.ppl.node.AbstractNodeVisitor;
 import com.amazon.opendistroforelasticsearch.sql.ppl.plans.expression.Expression;
+import com.amazon.opendistroforelasticsearch.sql.ppl.plans.logical.builder.UnresolvedPlanBuilder;
 import com.google.common.collect.ImmutableList;
 import java.util.List;
 import lombok.AllArgsConstructor;
@@ -35,20 +36,46 @@
 public class Project extends UnresolvedPlan {
     @Setter
     private List<Expression> projectList;
-    private UnresolvedPlan input;
+    private UnresolvedPlan child;
 
     public Project(List<Expression> projectList) {
         this.projectList = projectList;
     }
 
     @Override
     public List<UnresolvedPlan> getChild() {
-        return ImmutableList.of(this.input);
+        return ImmutableList.of(this.child);
     }
 
     @Override
     public <T, C> T accept(AbstractNodeVisitor<T, C> nodeVisitor, C context) {
-        this.input = (UnresolvedPlan) context;
+        this.child = (UnresolvedPlan) context;
         return nodeVisitor.visitProject(this, context);
     }
+
+    private Project(Builder builder) {
+        this.child = builder.child;
+    }
+
+    /**
+     * Project plan builder
+     */
+    public static class Builder extends UnresolvedPlanBuilder<Project> {
+        private UnresolvedPlan child;
+
+        public Builder(Project plan) {
+            super(plan);
+        }
+
+        @Override
+        public UnresolvedPlanBuilder attachPlan(UnresolvedPlan attach) {
+            this.child = attach;
+            return this;
+        }
+
+        @Override
+        public Project build() {
+            return new Project(this);
+        }
+    }
 }
diff --git a/...main/java/com/amazon/opendistroforelasticsearch/sql/ppl/plans/logical/UnresolvedPlan.java b/...main/java/com/amazon/opendistroforelasticsearch/sql/ppl/plans/logical/UnresolvedPlan.java
@@ -20,15 +20,14 @@
 import lombok.EqualsAndHashCode;
 import lombok.ToString;
 
+/**
+ * Abstract unresolved plan
+ */
 @EqualsAndHashCode(callSuper = false)
 @ToString
 public abstract class UnresolvedPlan extends Node {
     @Override
     public <T, C> T accept(AbstractNodeVisitor<T, C> nodeVisitor, C context) {
         return nodeVisitor.visitChildren(this, context);
     }
-
-    public UnresolvedPlan withInput(UnresolvedPlan input) {
-        return this;
-    }
 }
diff --git a/...earch/sql/ppl/plans/logical/HasInput.java → ...ogical/builder/UnresolvedPlanBuilder.java b/...earch/sql/ppl/plans/logical/HasInput.java → ...ogical/builder/UnresolvedPlanBuilder.java
@@ -13,13 +13,20 @@
  *   permissions and limitations under the License.
  */
 
-package com.amazon.opendistroforelasticsearch.sql.ppl.plans.logical;
+package com.amazon.opendistroforelasticsearch.sql.ppl.plans.logical.builder;
+
+import com.amazon.opendistroforelasticsearch.sql.ppl.plans.logical.UnresolvedPlan;
+import lombok.AllArgsConstructor;
 
 /**
- * The interface to set the parent for current UnresolvedPlan/Expression node
- * @param <T> type of parent node
- * @param <R> type of current node
+ * Abstract builder for unresolved plans
+ * @param <T> UnresolvedPlan subclass
  */
-public interface HasInput<T, R> {
-    R withInput(T input);
+@AllArgsConstructor
+public abstract class UnresolvedPlanBuilder<T extends UnresolvedPlan> {
+    private T plan;
+
+    public abstract UnresolvedPlan build();
+
+    public abstract UnresolvedPlanBuilder attachPlan(UnresolvedPlan attach);
 }