Initial implementation of skeleton classes and methods.

Signed-off-by: currantw <taylor.curran@improving.com>

core/src/main/java/org/opensearch/sql/analysis/Analyzer.java

@@ -38,6 +38,7 @@
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 import org.opensearch.sql.DataSourceSchemaName;
+import org.opensearch.sql.analysis.symbol.Namespace;
 import org.opensearch.sql.analysis.symbol.Symbol;
 import org.opensearch.sql.ast.AbstractNodeVisitor;
 import org.opensearch.sql.ast.expression.Argument;
@@ -52,6 +53,7 @@
 import org.opensearch.sql.ast.tree.CloseCursor;
 import org.opensearch.sql.ast.tree.Dedupe;
 import org.opensearch.sql.ast.tree.Eval;
+import org.opensearch.sql.ast.tree.Expand;
 import org.opensearch.sql.ast.tree.FetchCursor;
 import org.opensearch.sql.ast.tree.FillNull;
 import org.opensearch.sql.ast.tree.Filter;
@@ -333,9 +335,11 @@ public LogicalPlan visitAggregation(Aggregation node, AnalysisContext context) {
     TypeEnvironment newEnv = context.peek();
     aggregators.forEach(
         aggregator ->
-            newEnv.define(new Symbol(FIELD_NAME, aggregator.getName()), aggregator.type()));
+            newEnv.define(
+                new Symbol(Namespace.FIELD_NAME, aggregator.getName()), aggregator.type()));
     groupBys.forEach(
-        group -> newEnv.define(new Symbol(FIELD_NAME, group.getNameOrAlias()), group.type()));
+        group ->
+            newEnv.define(new Symbol(Namespace.FIELD_NAME, group.getNameOrAlias()), group.type()));
     return new LogicalAggregation(child, aggregators, groupBys);
   }
 
@@ -360,8 +364,9 @@ public LogicalPlan visitRareTopN(RareTopN node, AnalysisContext context) {
     context.push();
     TypeEnvironment newEnv = context.peek();
     groupBys.forEach(
-        group -> newEnv.define(new Symbol(FIELD_NAME, group.toString()), group.type()));
-    fields.forEach(field -> newEnv.define(new Symbol(FIELD_NAME, field.toString()), field.type()));
+        group -> newEnv.define(new Symbol(Namespace.FIELD_NAME, group.toString()), group.type()));
+    fields.forEach(
+        field -> newEnv.define(new Symbol(Namespace.FIELD_NAME, field.toString()), field.type()));
 
     List<Argument> options = node.getNoOfResults();
     Integer noOfResults = (Integer) options.get(0).getValue().getValue();
@@ -427,7 +432,8 @@ public LogicalPlan visitProject(Project node, AnalysisContext context) {
     context.push();
     TypeEnvironment newEnv = context.peek();
     namedExpressions.forEach(
-        expr -> newEnv.define(new Symbol(FIELD_NAME, expr.getNameOrAlias()), expr.type()));
+        expr ->
+            newEnv.define(new Symbol(Namespace.FIELD_NAME, expr.getNameOrAlias()), expr.type()));
     List<NamedExpression> namedParseExpressions = context.getNamedParseExpressions();
     return new LogicalProject(child, namedExpressions, namedParseExpressions);
   }
@@ -449,6 +455,17 @@ public LogicalPlan visitEval(Eval node, AnalysisContext context) {
     return new LogicalEval(child, expressionsBuilder.build());
   }
 
+  /**
+   * Builds and returns a {@link org.opensearch.sql.planner.logical.logicalExpand} corresponding to
+   * the given expand node.
+   */
+  @Override
+  public LogicalPlan visitExpand(Expand node, AnalysisContext context) {
+
+    // TODO #3016: Implement expand command
+    return null;
+  }
+
   /**
    * Builds and returns a {@link org.opensearch.sql.planner.logical.LogicalFlatten} corresponding to
    * the given flatten node, and adds the new fields to the current type environment.

core/src/main/java/org/opensearch/sql/ast/AbstractNodeVisitor.java

@@ -44,6 +44,7 @@
 import org.opensearch.sql.ast.tree.CloseCursor;
 import org.opensearch.sql.ast.tree.Dedupe;
 import org.opensearch.sql.ast.tree.Eval;
+import org.opensearch.sql.ast.tree.Expand;
 import org.opensearch.sql.ast.tree.FetchCursor;
 import org.opensearch.sql.ast.tree.FillNull;
 import org.opensearch.sql.ast.tree.Filter;
@@ -104,6 +105,10 @@ public T visitRelationSubquery(RelationSubquery node, C context) {
     return visitChildren(node, context);
   }
 
+  public T visitExpand(Expand node, C context) {
+    return visitChildren(node, context);
+  }
+
   public T visitTableFunction(TableFunction node, C context) {
     return visitChildren(node, context);
   }

core/src/main/java/org/opensearch/sql/ast/dsl/AstDSL.java

@@ -49,6 +49,7 @@
 import org.opensearch.sql.ast.tree.Aggregation;
 import org.opensearch.sql.ast.tree.Dedupe;
 import org.opensearch.sql.ast.tree.Eval;
+import org.opensearch.sql.ast.tree.Expand;
 import org.opensearch.sql.ast.tree.FillNull;
 import org.opensearch.sql.ast.tree.Filter;
 import org.opensearch.sql.ast.tree.Flatten;
@@ -105,6 +106,10 @@ public static Eval eval(UnresolvedPlan input, Let... projectList) {
     return new Eval(Arrays.asList(projectList)).attach(input);
   }
 
+  public Expand expand(UnresolvedPlan input, Field field) {
+    return new Expand(field).attach(input);
+  }
+
   public Flatten flatten(UnresolvedPlan input, Field field) {
     return new Flatten(field).attach(input);
   }

core/src/main/java/org/opensearch/sql/ast/tree/Expand.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.ast.tree;
+
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+import org.opensearch.sql.ast.AbstractNodeVisitor;
+import org.opensearch.sql.ast.expression.Field;
+
+/** AST node representing an expand <field> operation. */
+@Getter
+@ToString
+@RequiredArgsConstructor
+public class Expand extends UnresolvedPlan {
+  private UnresolvedPlan child;
+
+  @Getter private final Field field;
+
+  @Override
+  public Expand attach(UnresolvedPlan child) {
+    this.child = child;
+    return this;
+  }
+
+  @Override
+  public List<UnresolvedPlan> getChild() {
+    return ImmutableList.of(child);
+  }
+
+  @Override
+  public <T, C> T accept(AbstractNodeVisitor<T, C> nodeVisitor, C context) {
+    return nodeVisitor.visitExpand(this, context);
+  }
+}

core/src/main/java/org/opensearch/sql/executor/Explain.java

@@ -22,6 +22,7 @@
 import org.opensearch.sql.planner.physical.AggregationOperator;
 import org.opensearch.sql.planner.physical.DedupeOperator;
 import org.opensearch.sql.planner.physical.EvalOperator;
+import org.opensearch.sql.planner.physical.ExpandOperator;
 import org.opensearch.sql.planner.physical.FilterOperator;
 import org.opensearch.sql.planner.physical.FlattenOperator;
 import org.opensearch.sql.planner.physical.LimitOperator;
@@ -161,6 +162,14 @@ public ExplainResponseNode visitEval(EvalOperator node, Object context) {
                 ImmutableMap.of("expressions", convertPairListToMap(node.getExpressionList()))));
   }
 
+  @Override
+  public ExplainResponseNode visitExpand(ExpandOperator node, Object context) {
+    return explain(
+        node,
+        context,
+        explainNode -> explainNode.setDescription(ImmutableMap.of("expandField", node.getField())));
+  }
+
   @Override
   public ExplainResponseNode visitFlatten(FlattenOperator node, Object context) {
     return explain(

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

@@ -10,6 +10,7 @@
 import org.opensearch.sql.planner.logical.LogicalCloseCursor;
 import org.opensearch.sql.planner.logical.LogicalDedupe;
 import org.opensearch.sql.planner.logical.LogicalEval;
+import org.opensearch.sql.planner.logical.LogicalExpand;
 import org.opensearch.sql.planner.logical.LogicalFetchCursor;
 import org.opensearch.sql.planner.logical.LogicalFilter;
 import org.opensearch.sql.planner.logical.LogicalFlatten;
@@ -31,6 +32,7 @@
 import org.opensearch.sql.planner.physical.CursorCloseOperator;
 import org.opensearch.sql.planner.physical.DedupeOperator;
 import org.opensearch.sql.planner.physical.EvalOperator;
+import org.opensearch.sql.planner.physical.ExpandOperator;
 import org.opensearch.sql.planner.physical.FilterOperator;
 import org.opensearch.sql.planner.physical.FlattenOperator;
 import org.opensearch.sql.planner.physical.LimitOperator;
@@ -101,6 +103,11 @@ public PhysicalPlan visitEval(LogicalEval node, C context) {
     return new EvalOperator(visitChild(node, context), node.getExpressions());
   }
 
+  @Override
+  public PhysicalPlan visitExpand(LogicalExpand node, C context) {
+    return new ExpandOperator(visitChild(node, context), node.getFieldRefExp());
+  }
+
   @Override
   public PhysicalPlan visitFlatten(LogicalFlatten node, C context) {
     return new FlattenOperator(visitChild(node, context), node.getFieldRefExp());

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.planner.logical;
+
+import java.util.Collections;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.ToString;
+import org.opensearch.sql.expression.ReferenceExpression;
+
+/** Logical plan that represent the flatten command. */
+@Getter
+@ToString
+@EqualsAndHashCode(callSuper = true)
+public class LogicalExpand extends LogicalPlan {
+  private final ReferenceExpression fieldRefExp;
+
+  public LogicalExpand(LogicalPlan child, ReferenceExpression fieldRefExp) {
+    super(Collections.singletonList(child));
+    this.fieldRefExp = fieldRefExp;
+  }
+
+  @Override
+  public <R, C> R accept(LogicalPlanNodeVisitor<R, C> visitor, C context) {
+    return visitor.visitExpand(this, context);
+  }
+}

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

@@ -97,6 +97,10 @@ public static LogicalPlan eval(
     return new LogicalEval(input, Arrays.asList(expressions));
   }
 
+  public LogicalPlan expand(LogicalPlan input, ReferenceExpression fieldRefExp) {
+    return new LogicalExpand(input, fieldRefExp);
+  }
+
   public LogicalPlan flatten(LogicalPlan input, ReferenceExpression fieldRefExp) {
     return new LogicalFlatten(input, fieldRefExp);
   }

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

@@ -72,6 +72,10 @@ public R visitEval(LogicalEval plan, C context) {
     return visitNode(plan, context);
   }
 
+  public R visitExpand(LogicalExpand plan, C context) {
+    return visitNode(plan, context);
+  }
+
   public R visitFlatten(LogicalFlatten plan, C context) {
     return visitNode(plan, context);
   }

core/src/main/java/org/opensearch/sql/planner/physical/ExpandOperator.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.planner.physical;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Pattern;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+import org.opensearch.sql.data.model.ExprValue;
+import org.opensearch.sql.data.model.ExprValueUtils;
+import org.opensearch.sql.expression.ReferenceExpression;
+
+/** Flattens the specified field from the input and returns the result. */
+@Getter
+@ToString
+@RequiredArgsConstructor
+@EqualsAndHashCode(callSuper = false)
+public class ExpandOperator extends PhysicalPlan {
+
+  private final PhysicalPlan input;
+  private final ReferenceExpression field;
+
+  private static final Pattern PATH_SEPARATOR_PATTERN = Pattern.compile(".", Pattern.LITERAL);
+
+  @Override
+  public <R, C> R accept(PhysicalPlanNodeVisitor<R, C> visitor, C context) {
+    return visitor.visitExpand(this, context);
+  }
+
+  @Override
+  public List<PhysicalPlan> getChild() {
+    return Collections.singletonList(input);
+  }
+
+  @Override
+  public boolean hasNext() {
+
+    // TODO #3016: Implement expand command
+    return false;
+  }
+
+  @Override
+  public ExprValue next() {
+
+    // TODO #3016: Implement expand command
+    return ExprValueUtils.nullValue();
+  }
+}

core/src/main/java/org/opensearch/sql/planner/physical/PhysicalPlanDSL.java

@@ -60,6 +60,10 @@ public static EvalOperator eval(
     return new EvalOperator(input, Arrays.asList(expressions));
   }
 
+  public ExpandOperator expand(PhysicalPlan input, ReferenceExpression fieldRefExp) {
+    return new ExpandOperator(input, fieldRefExp);
+  }
+
   public FlattenOperator flatten(PhysicalPlan input, ReferenceExpression fieldRefExp) {
     return new FlattenOperator(input, fieldRefExp);
   }

core/src/main/java/org/opensearch/sql/planner/physical/PhysicalPlanNodeVisitor.java

@@ -56,6 +56,10 @@ public R visitEval(EvalOperator node, C context) {
     return visitNode(node, context);
   }
 
+  public R visitExpand(ExpandOperator node, C context) {
+    return visitNode(node, context);
+  }
+
   public R visitFlatten(FlattenOperator node, C context) {
     return visitNode(node, context);
   }

core/src/test/java/org/opensearch/sql/executor/ExplainTest.java

@@ -11,6 +11,7 @@
 import static org.opensearch.sql.ast.tree.RareTopN.CommandType.TOP;
 import static org.opensearch.sql.ast.tree.Sort.SortOption.DEFAULT_ASC;
 import static org.opensearch.sql.ast.tree.Trendline.TrendlineType.SMA;
+import static org.opensearch.sql.data.type.ExprCoreType.ARRAY;
 import static org.opensearch.sql.data.type.ExprCoreType.DOUBLE;
 import static org.opensearch.sql.data.type.ExprCoreType.INTEGER;
 import static org.opensearch.sql.data.type.ExprCoreType.STRING;
@@ -56,6 +57,7 @@
 import org.opensearch.sql.expression.ReferenceExpression;
 import org.opensearch.sql.expression.aggregation.NamedAggregator;
 import org.opensearch.sql.expression.window.WindowDefinition;
+import org.opensearch.sql.planner.physical.ExpandOperator;
 import org.opensearch.sql.planner.physical.FlattenOperator;
 import org.opensearch.sql.planner.physical.PhysicalPlan;
 import org.opensearch.sql.planner.physical.TrendlineOperator;
@@ -301,6 +303,24 @@ void can_explain_trendline() {
         explain.apply(plan));
   }
 
+  @Test
+  void can_explain_expand() {
+    String fieldName = "field_name";
+    ReferenceExpression fieldReference = ref(fieldName, ARRAY);
+
+    PhysicalPlan plan = new ExpandOperator(tableScan, fieldReference);
+    ExplainResponse actual = explain.apply(plan);
+
+    ExplainResponse expected =
+        new ExplainResponse(
+            new ExplainResponseNode(
+                "ExpandOperator",
+                ImmutableMap.of("expandField", fieldReference),
+                singletonList(tableScan.explainNode())));
+
+    assertEquals(expected, actual, "explain expand");
+  }
+
   @Test
   void can_explain_flatten() {
     String fieldName = "field_name";