Revert "Applying Google Java code format changes to core/src/main/java/org/opensearch/sql/planner core/src/main/java/org/opensearch/sql/storage core/src/main/java/org/opensearch/sql/utils"

This reverts commit 8bb4117.

Author: MitchellGale

core/src/main/java/org/opensearch/sql/planner/DefaultImplementor.java

@@ -45,12 +45,13 @@
 
 /**
  * Default implementor for implementing logical to physical translation. "Default" here means all
- * logical operator will be translated to correspondent physical operator to pipeline operations in
- * post-processing style in memory. Different storage can override methods here to optimize default
- * pipelining operator, for example a storage has the flexibility to override visitFilter and
- * visitRelation to push down filtering operation and return a single physical index scan operator.
+ * logical operator will be translated to correspondent physical operator to pipeline operations
+ * in post-processing style in memory.
+ * Different storage can override methods here to optimize default pipelining operator, for example
+ * a storage has the flexibility to override visitFilter and visitRelation to push down filtering
+ * operation and return a single physical index scan operator.
  *
- * @param <C> context type
+ * @param <C>   context type
  */
 public class DefaultImplementor<C> extends LogicalPlanNodeVisitor<PhysicalPlan, C> {
 
@@ -61,7 +62,8 @@ public PhysicalPlan visitRareTopN(LogicalRareTopN node, C context) {
         node.getCommandType(),
         node.getNoOfResults(),
         node.getFieldList(),
-        node.getGroupByList());
+        node.getGroupByList()
+    );
   }
 
   @Override
@@ -76,14 +78,16 @@ public PhysicalPlan visitDedupe(LogicalDedupe node, C context) {
 
   @Override
   public PhysicalPlan visitProject(LogicalProject node, C context) {
-    return new ProjectOperator(
-        visitChild(node, context), node.getProjectList(), node.getNamedParseExpressions());
+    return new ProjectOperator(visitChild(node, context), node.getProjectList(),
+        node.getNamedParseExpressions());
   }
 
   @Override
   public PhysicalPlan visitWindow(LogicalWindow node, C context) {
     return new WindowOperator(
-        visitChild(node, context), node.getWindowFunction(), node.getWindowDefinition());
+        visitChild(node, context),
+        node.getWindowFunction(),
+        node.getWindowDefinition());
   }
 
   @Override
@@ -144,9 +148,8 @@ public PhysicalPlan visitTableWriteBuilder(TableWriteBuilder plan, C context) {
 
   @Override
   public PhysicalPlan visitRelation(LogicalRelation node, C context) {
-    throw new UnsupportedOperationException(
-        "Storage engine is responsible for "
-            + "implementing and optimizing logical plan with relation involved");
+    throw new UnsupportedOperationException("Storage engine is responsible for "
+        + "implementing and optimizing logical plan with relation involved");
   }
 
   @Override

core/src/main/java/org/opensearch/sql/planner/PlanContext.java

@@ -9,10 +9,13 @@
 import lombok.Getter;
 import org.opensearch.sql.storage.split.Split;
 
-/** Plan context hold planning related information. */
+/**
+ * Plan context hold planning related information.
+ */
 public class PlanContext {
 
-  @Getter private final Optional<Split> split;
+  @Getter
+  private final Optional<Split> split;
 
   public PlanContext(Split split) {
     this.split = Optional.of(split);

core/src/main/java/org/opensearch/sql/planner/PlanNode.java

@@ -3,11 +3,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+
 package org.opensearch.sql.planner;
 
 import java.util.List;
 
-/** The definition of Plan Node. */
+/**
+ * The definition of Plan Node.
+ */
 public interface PlanNode<T extends PlanNode> {
 
   /**

core/src/main/java/org/opensearch/sql/planner/Planner.java

@@ -3,8 +3,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+
 package org.opensearch.sql.planner;
 
+
 import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.opensearch.sql.planner.logical.LogicalPlan;
@@ -14,16 +16,18 @@
 import org.opensearch.sql.planner.physical.PhysicalPlan;
 import org.opensearch.sql.storage.Table;
 
-/** Planner that plans and chooses the optimal physical plan. */
+/**
+ * Planner that plans and chooses the optimal physical plan.
+ */
 @RequiredArgsConstructor
 public class Planner {
 
   private final LogicalPlanOptimizer logicalOptimizer;
 
   /**
-   * Generate optimal physical plan for logical plan. If no table involved, translate logical plan
-   * to physical by default implementor. TODO: for now just delegate entire logical plan to storage
-   * engine.
+   * Generate optimal physical plan for logical plan. If no table involved,
+   * translate logical plan to physical by default implementor.
+   * TODO: for now just delegate entire logical plan to storage engine.
    *
    * @param plan logical plan
    * @return optimal physical plan
@@ -33,28 +37,28 @@ public PhysicalPlan plan(LogicalPlan plan) {
     if (table == null) {
       return plan.accept(new DefaultImplementor<>(), null);
     }
-    return table.implement(table.optimize(optimize(plan)));
+    return table.implement(
+        table.optimize(optimize(plan)));
   }
 
   private Table findTable(LogicalPlan plan) {
-    return plan.accept(
-        new LogicalPlanNodeVisitor<Table, Object>() {
-
-          @Override
-          public Table visitNode(LogicalPlan node, Object context) {
-            List<LogicalPlan> children = node.getChild();
-            if (children.isEmpty()) {
-              return null;
-            }
-            return children.get(0).accept(this, context);
-          }
-
-          @Override
-          public Table visitRelation(LogicalRelation node, Object context) {
-            return node.getTable();
-          }
-        },
-        null);
+    return plan.accept(new LogicalPlanNodeVisitor<Table, Object>() {
+
+      @Override
+      public Table visitNode(LogicalPlan node, Object context) {
+        List<LogicalPlan> children = node.getChild();
+        if (children.isEmpty()) {
+          return null;
+        }
+        return children.get(0).accept(this, context);
+      }
+
+      @Override
+      public Table visitRelation(LogicalRelation node, Object context) {
+        return node.getTable();
+      }
+
+    }, null);
   }
 
   private LogicalPlan optimize(LogicalPlan plan) {

core/src/main/java/org/opensearch/sql/planner/SerializablePlan.java

@@ -10,37 +10,36 @@
 /**
  * All subtypes of PhysicalPlan which needs to be serialized (in cursor, for pagination feature)
  * should follow one of the following options.
- *
  * <ul>
  *   <li>Both:
- *       <ul>
- *         <li>Override both methods from {@link Externalizable}.
- *         <li>Define a public no-arg constructor.
- *       </ul>
- *   <li>Overwrite {@link #getPlanForSerialization} to return another instance of {@link
- *       SerializablePlan}.
+ *     <ul>
+ *       <li>Override both methods from {@link Externalizable}.</li>
+ *       <li>Define a public no-arg constructor.</li>
+ *     </ul>
+ *   </li>
+ *   <li>
+ *     Overwrite {@link #getPlanForSerialization} to return
+ *     another instance of {@link SerializablePlan}.
+ *   </li>
  * </ul>
  */
 public interface SerializablePlan extends Externalizable {
 
   /**
-   * Override to return child or delegated plan, so parent plan should skip this one for
-   * serialization, but it should try to serialize grandchild plan. Imagine plan structure like this
-   *
+   * Override to return child or delegated plan, so parent plan should skip this one
+   * for serialization, but it should try to serialize grandchild plan.
+   * Imagine plan structure like this
    * <pre>
    *    A         -> this
    *    `- B      -> child
    *      `- C    -> this
    * </pre>
+   * In that case only plans A and C should be attempted to serialize.
+   * It is needed to skip a `ResourceMonitorPlan` instance only, actually.
    *
-   * In that case only plans A and C should be attempted to serialize. It is needed to skip a
-   * `ResourceMonitorPlan` instance only, actually.
-   *
-   * <pre>{@code
-   * * A.writeObject(B.getPlanForSerialization());
-   *
-   * }</pre>
-   *
+   *  <pre>{@code
+   *    * A.writeObject(B.getPlanForSerialization());
+   *  }</pre>
    * @return Next plan for serialization.
    */
   default SerializablePlan getPlanForSerialization() {

core/src/main/java/org/opensearch/sql/planner/logical/LogicalAD.java

@@ -18,7 +18,6 @@ public class LogicalAD extends LogicalPlan {
 
   /**
    * Constructor of LogicalAD.
-   *
    * @param child child logical plan
    * @param arguments arguments of the algorithm
    */

core/src/main/java/org/opensearch/sql/planner/logical/LogicalAggregation.java

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+
 package org.opensearch.sql.planner.logical;
 
 import java.util.Collections;
@@ -13,18 +14,26 @@
 import org.opensearch.sql.expression.NamedExpression;
 import org.opensearch.sql.expression.aggregation.NamedAggregator;
 
-/** Logical Aggregation. */
+/**
+ * Logical Aggregation.
+ */
 @ToString
 @EqualsAndHashCode(callSuper = true)
 public class LogicalAggregation extends LogicalPlan {
 
-  @Getter private final List<NamedAggregator> aggregatorList;
+  @Getter
+  private final List<NamedAggregator> aggregatorList;
 
-  @Getter private final List<NamedExpression> groupByList;
+  @Getter
+  private final List<NamedExpression> groupByList;
 
-  /** Constructor of LogicalAggregation. */
+  /**
+   * Constructor of LogicalAggregation.
+   */
   public LogicalAggregation(
-      LogicalPlan child, List<NamedAggregator> aggregatorList, List<NamedExpression> groupByList) {
+      LogicalPlan child,
+      List<NamedAggregator> aggregatorList,
+      List<NamedExpression> groupByList) {
     super(Collections.singletonList(child));
     this.aggregatorList = aggregatorList;
     this.groupByList = groupByList;

core/src/main/java/org/opensearch/sql/planner/logical/LogicalCloseCursor.java

@@ -10,8 +10,8 @@
 import lombok.ToString;
 
 /**
- * A logical plan node which wraps {@link org.opensearch.sql.planner.LogicalCursor} and represent a
- * cursor close operation.
+ * A logical plan node which wraps {@link org.opensearch.sql.planner.LogicalCursor}
+ * and represent a cursor close operation.
  */
 @ToString
 @EqualsAndHashCode(callSuper = false)

core/src/main/java/org/opensearch/sql/planner/logical/LogicalDedupe.java

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+
 package org.opensearch.sql.planner.logical;
 
 import java.util.Arrays;
@@ -12,7 +13,9 @@
 import lombok.ToString;
 import org.opensearch.sql.expression.Expression;
 
-/** Logical Dedupe Plan. */
+/**
+ * Logical Dedupe Plan.
+ */
 @Getter
 @ToString
 @EqualsAndHashCode(callSuper = true)
@@ -23,12 +26,12 @@ public class LogicalDedupe extends LogicalPlan {
   private final Boolean keepEmpty;
   private final Boolean consecutive;
 
-  /** Constructor of LogicalDedupe. */
+  /**
+   * Constructor of LogicalDedupe.
+   */
   public LogicalDedupe(
       LogicalPlan child,
-      List<Expression> dedupeList,
-      Integer allowedDuplication,
-      Boolean keepEmpty,
+      List<Expression> dedupeList, Integer allowedDuplication, Boolean keepEmpty,
       Boolean consecutive) {
     super(Arrays.asList(child));
     this.dedupeList = dedupeList;

core/src/main/java/org/opensearch/sql/planner/logical/LogicalEval.java

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+
 package org.opensearch.sql.planner.logical;
 
 import java.util.Collections;
@@ -23,10 +24,15 @@
 @EqualsAndHashCode(callSuper = true)
 public class LogicalEval extends LogicalPlan {
 
-  @Getter private final List<Pair<ReferenceExpression, Expression>> expressions;
+  @Getter
+  private final List<Pair<ReferenceExpression, Expression>> expressions;
 
-  /** Constructor of LogicalEval. */
-  public LogicalEval(LogicalPlan child, List<Pair<ReferenceExpression, Expression>> expressions) {
+  /**
+   * Constructor of LogicalEval.
+   */
+  public LogicalEval(
+      LogicalPlan child,
+      List<Pair<ReferenceExpression, Expression>> expressions) {
     super(Collections.singletonList(child));
     this.expressions = expressions;
   }

core/src/main/java/org/opensearch/sql/planner/logical/LogicalFetchCursor.java

@@ -9,17 +9,25 @@
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.ToString;
+import org.opensearch.sql.planner.logical.LogicalPlan;
+import org.opensearch.sql.planner.logical.LogicalPlanNodeVisitor;
 import org.opensearch.sql.storage.StorageEngine;
 
-/** A plan node which represents operation of fetching a next page from the cursor. */
+/**
+ * A plan node which represents operation of fetching a next page from the cursor.
+ */
 @EqualsAndHashCode(callSuper = false)
 @ToString
 public class LogicalFetchCursor extends LogicalPlan {
-  @Getter private final String cursor;
+  @Getter
+  private final String cursor;
 
-  @Getter private final StorageEngine engine;
+  @Getter
+  private final StorageEngine engine;
 
-  /** LogicalCursor constructor. Does not have child plans. */
+  /**
+   * LogicalCursor constructor. Does not have child plans.
+   */
   public LogicalFetchCursor(String cursor, StorageEngine engine) {
     super(List.of());
     this.cursor = cursor;