Add parse command to PPL

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

@@ -6,7 +6,11 @@
 
 package org.opensearch.sql.analysis;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
+import lombok.Getter;
+import org.opensearch.sql.expression.NamedExpression;
 
 /**
  * The context used for Analyzer.
@@ -16,13 +20,16 @@ public class AnalysisContext {
    * Environment stack for symbol scope management.
    */
   private TypeEnvironment environment;
+  @Getter
+  private final List<NamedExpression> namedParseExpressions;
 
   public AnalysisContext() {
-    this.environment = new TypeEnvironment(null);
+    this(new TypeEnvironment(null));
   }
 
   public AnalysisContext(TypeEnvironment environment) {
     this.environment = environment;
+    this.namedParseExpressions = new ArrayList<>();
   }
 
   /**

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

@@ -37,6 +37,7 @@
 import org.opensearch.sql.ast.tree.Filter;
 import org.opensearch.sql.ast.tree.Head;
 import org.opensearch.sql.ast.tree.Limit;
+import org.opensearch.sql.ast.tree.Parse;
 import org.opensearch.sql.ast.tree.Project;
 import org.opensearch.sql.ast.tree.RareTopN;
 import org.opensearch.sql.ast.tree.Relation;
@@ -47,11 +48,13 @@
 import org.opensearch.sql.ast.tree.UnresolvedPlan;
 import org.opensearch.sql.ast.tree.Values;
 import org.opensearch.sql.data.model.ExprMissingValue;
+import org.opensearch.sql.data.type.ExprCoreType;
 import org.opensearch.sql.exception.SemanticCheckException;
 import org.opensearch.sql.expression.DSL;
 import org.opensearch.sql.expression.Expression;
 import org.opensearch.sql.expression.LiteralExpression;
 import org.opensearch.sql.expression.NamedExpression;
+import org.opensearch.sql.expression.ParseExpression;
 import org.opensearch.sql.expression.ReferenceExpression;
 import org.opensearch.sql.expression.aggregation.Aggregator;
 import org.opensearch.sql.expression.aggregation.NamedAggregator;
@@ -70,6 +73,7 @@
 import org.opensearch.sql.planner.logical.LogicalValues;
 import org.opensearch.sql.storage.StorageEngine;
 import org.opensearch.sql.storage.Table;
+import org.opensearch.sql.utils.ParseUtils;
 
 /**
  * Analyze the {@link UnresolvedPlan} in the {@link AnalysisContext} to construct the {@link
@@ -286,7 +290,8 @@ public LogicalPlan visitProject(Project node, AnalysisContext context) {
     TypeEnvironment newEnv = context.peek();
     namedExpressions.forEach(expr -> newEnv.define(new Symbol(Namespace.FIELD_NAME,
         expr.getNameOrAlias()), expr.type()));
-    return new LogicalProject(child, namedExpressions);
+    List<NamedExpression> namedParseExpressions = context.getNamedParseExpressions();
+    return new LogicalProject(child, namedExpressions, namedParseExpressions);
   }
 
   /**
@@ -308,6 +313,25 @@ public LogicalPlan visitEval(Eval node, AnalysisContext context) {
     return new LogicalEval(child, expressionsBuilder.build());
   }
 
+  /**
+   * Build {@link ParseExpression} to context and skip to child nodes.
+   */
+  @Override
+  public LogicalPlan visitParse(Parse node, AnalysisContext context) {
+    LogicalPlan child = node.getChild().get(0).accept(this, context);
+    Expression expression = expressionAnalyzer.analyze(node.getExpression(), context);
+    String pattern = (String) node.getPattern().getValue();
+    Expression patternExpression = DSL.literal(pattern);
+
+    TypeEnvironment curEnv = context.peek();
+    ParseUtils.getNamedGroupCandidates(pattern).forEach(group -> {
+      curEnv.define(new Symbol(Namespace.FIELD_NAME, group), ExprCoreType.STRING);
+      context.getNamedParseExpressions().add(new NamedExpression(group,
+          new ParseExpression(expression, patternExpression, DSL.literal(group))));
+    });
+    return child;
+  }
+
   /**
    * Build {@link LogicalSort}.
    */

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

@@ -47,6 +47,7 @@
 import org.opensearch.sql.expression.Expression;
 import org.opensearch.sql.expression.NamedArgumentExpression;
 import org.opensearch.sql.expression.NamedExpression;
+import org.opensearch.sql.expression.ParseExpression;
 import org.opensearch.sql.expression.ReferenceExpression;
 import org.opensearch.sql.expression.aggregation.AggregationState;
 import org.opensearch.sql.expression.aggregation.Aggregator;
@@ -276,6 +277,13 @@ public Expression visitUnresolvedArgument(UnresolvedArgument node, AnalysisConte
   }
 
   private Expression visitIdentifier(String ident, AnalysisContext context) {
+    // ParseExpression will always override ReferenceExpression when ident conflicts
+    for (NamedExpression expr : context.getNamedParseExpressions()) {
+      if (expr.getNameOrAlias().equals(ident) && expr.getDelegated() instanceof ParseExpression) {
+        return expr.getDelegated();
+      }
+    }
+
     TypeEnvironment typeEnv = context.peek();
     ReferenceExpression ref = DSL.ref(ident,
         typeEnv.resolve(new Symbol(Namespace.FIELD_NAME, ident)));

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

@@ -38,6 +38,7 @@
 import org.opensearch.sql.ast.tree.Filter;
 import org.opensearch.sql.ast.tree.Head;
 import org.opensearch.sql.ast.tree.Limit;
+import org.opensearch.sql.ast.tree.Parse;
 import org.opensearch.sql.ast.tree.Project;
 import org.opensearch.sql.ast.tree.RareTopN;
 import org.opensearch.sql.ast.tree.Relation;
@@ -175,6 +176,10 @@ public T visitEval(Eval node, C context) {
     return visitChildren(node, context);
   }
 
+  public T visitParse(Parse node, C context) {
+    return visitChildren(node, context);
+  }
+
   public T visitLet(Let node, C context) {
     return visitChildren(node, context);
   }

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

@@ -44,6 +44,7 @@
 import org.opensearch.sql.ast.tree.Filter;
 import org.opensearch.sql.ast.tree.Head;
 import org.opensearch.sql.ast.tree.Limit;
+import org.opensearch.sql.ast.tree.Parse;
 import org.opensearch.sql.ast.tree.Project;
 import org.opensearch.sql.ast.tree.RareTopN;
 import org.opensearch.sql.ast.tree.RareTopN.CommandType;
@@ -407,4 +408,9 @@ public static RareTopN rareTopN(UnresolvedPlan input, CommandType commandType,
   public static Limit limit(UnresolvedPlan input, Integer limit, Integer offset) {
     return new Limit(limit, offset).attach(input);
   }
+
+  public static Parse parse(UnresolvedPlan input, UnresolvedExpression expression,
+                            Literal pattern) {
+    return new Parse(expression, pattern, input);
+  }
 }

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

@@ -0,0 +1,61 @@
+/*
+ * 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.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.UnresolvedExpression;
+
+/**
+ * AST node represent Parse operation.
+ */
+@Getter
+@Setter
+@ToString
+@EqualsAndHashCode(callSuper = false)
+@RequiredArgsConstructor
+@AllArgsConstructor
+public class Parse extends UnresolvedPlan {
+  /**
+   * Field.
+   */
+  private final UnresolvedExpression expression;
+
+  /**
+   * Pattern.
+   */
+  private final Literal pattern;
+
+  /**
+   * Child Plan.
+   */
+  private UnresolvedPlan child;
+
+  @Override
+  public Parse attach(UnresolvedPlan child) {
+    this.child = child;
+    return this;
+  }
+
+  @Override
+  public List<UnresolvedPlan> getChild() {
+    return ImmutableList.of(this.child);
+  }
+
+  @Override
+  public <T, C> T accept(AbstractNodeVisitor<T, C> nodeVisitor, C context) {
+    return nodeVisitor.visitParse(this, context);
+  }
+}

core/src/main/java/org/opensearch/sql/expression/DSL.java

@@ -96,6 +96,10 @@ public static NamedExpression named(Expression expression) {
     if (expression instanceof NamedExpression) {
       return (NamedExpression) expression;
     }
+    if (expression instanceof ParseExpression) {
+      return named(((ParseExpression) expression).getIdentifier().valueOf(null).stringValue(),
+          expression);
+    }
     return named(expression.toString(), expression);
   }
 
@@ -115,6 +119,11 @@ public NamedArgumentExpression namedArgument(String argName, Expression value) {
     return new NamedArgumentExpression(argName, value);
   }
 
+  public static ParseExpression parsed(Expression expression, Expression pattern,
+                                       Expression identifier) {
+    return new ParseExpression(expression, pattern, identifier);
+  }
+
   public static SpanExpression span(Expression field, Expression value, String unit) {
     return new SpanExpression(field, value, SpanUnit.of(unit));
   }
@@ -254,7 +263,7 @@ public FunctionExpression subtract(Expression... expressions) {
   public FunctionExpression multiply(Expression... expressions) {
     return function(BuiltinFunctionName.MULTIPLY, expressions);
   }
-  
+
   public FunctionExpression adddate(Expression... expressions) {
     return function(BuiltinFunctionName.ADDDATE, expressions);
   }
@@ -366,7 +375,7 @@ public FunctionExpression module(Expression... expressions) {
   public FunctionExpression substr(Expression... expressions) {
     return function(BuiltinFunctionName.SUBSTR, expressions);
   }
-  
+
   public FunctionExpression substring(Expression... expressions) {
     return function(BuiltinFunctionName.SUBSTR, expressions);
   }

core/src/main/java/org/opensearch/sql/expression/ExpressionNodeVisitor.java

@@ -60,6 +60,10 @@ public T visitReference(ReferenceExpression node, C context) {
     return visitNode(node, context);
   }
 
+  public T visitParse(ParseExpression node, C context) {
+    return visitNode(node, context);
+  }
+
   public T visitFunction(FunctionExpression node, C context) {
     return visitChildren(node, context);
   }

core/src/main/java/org/opensearch/sql/expression/ParseExpression.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.expression;
+
+import com.google.common.collect.ImmutableList;
+import java.util.regex.Pattern;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.ToString;
+import org.opensearch.sql.data.model.ExprValue;
+import org.opensearch.sql.data.type.ExprCoreType;
+import org.opensearch.sql.data.type.ExprType;
+import org.opensearch.sql.exception.ExpressionEvaluationException;
+import org.opensearch.sql.exception.SemanticCheckException;
+import org.opensearch.sql.expression.env.Environment;
+import org.opensearch.sql.expression.function.FunctionName;
+import org.opensearch.sql.utils.ParseUtils;
+
+/**
+ * ParseExpression with regex and named capture group.
+ */
+@EqualsAndHashCode
+@ToString
+public class ParseExpression extends FunctionExpression {
+  @Getter
+  private final Expression expression;
+  private final Expression rawPattern;
+  @Getter
+  private final Expression identifier;
+  @Getter
+  @EqualsAndHashCode.Exclude
+  private final Pattern pattern;
+
+  /**
+   * ParseExpression.
+   *
+   * @param expression text field
+   * @param rawPattern regex
+   * @param identifier named capture group to extract
+   */
+  public ParseExpression(Expression expression, Expression rawPattern, Expression identifier) {
+    super(FunctionName.of("parse"), ImmutableList.of(expression, rawPattern, identifier));
+    this.expression = expression;
+    this.rawPattern = rawPattern;
+    this.identifier = identifier;
+    this.pattern = Pattern.compile(rawPattern.valueOf(null).stringValue());
+  }
+
+  @Override
+  public ExprValue valueOf(Environment<Expression, ExprValue> valueEnv) {
+    ExprValue value = valueEnv.resolve(expression);
+    try {
+      return ParseUtils.parseValue(value, pattern, identifier.valueOf(null).stringValue());
+    } catch (ExpressionEvaluationException e) {
+      throw new SemanticCheckException(
+          String.format("failed to parse field \"%s\" with type [%s]", expression, value.type()));
+    }
+  }
+
+  @Override
+  public ExprType type() {
+    return ExprCoreType.STRING;
+  }
+
+  @Override
+  public <T, C> T accept(ExpressionNodeVisitor<T, C> visitor, C context) {
+    return visitor.visitParse(this, context);
+  }
+}

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

@@ -70,7 +70,8 @@ public PhysicalPlan visitDedupe(LogicalDedupe node, C context) {
 
   @Override
   public PhysicalPlan visitProject(LogicalProject node, C context) {
-    return new ProjectOperator(visitChild(node, context), node.getProjectList());
+    return new ProjectOperator(visitChild(node, context), node.getProjectList(),
+        node.getNamedParseExpressions());
   }
 
   @Override

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

@@ -6,6 +6,7 @@
 
 package org.opensearch.sql.planner.logical;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import java.util.Arrays;
 import java.util.List;
@@ -17,6 +18,7 @@
 import org.opensearch.sql.expression.Expression;
 import org.opensearch.sql.expression.LiteralExpression;
 import org.opensearch.sql.expression.NamedExpression;
+import org.opensearch.sql.expression.ParseExpression;
 import org.opensearch.sql.expression.ReferenceExpression;
 import org.opensearch.sql.expression.aggregation.NamedAggregator;
 import org.opensearch.sql.expression.window.WindowDefinition;
@@ -46,7 +48,12 @@ public static LogicalPlan rename(
   }
 
   public static LogicalPlan project(LogicalPlan input, NamedExpression... fields) {
-    return new LogicalProject(input, Arrays.asList(fields));
+    return new LogicalProject(input, Arrays.asList(fields), ImmutableList.of());
+  }
+
+  public static LogicalPlan project(LogicalPlan input, List<NamedExpression> fields,
+                                    List<NamedExpression> namedParseExpressions) {
+    return new LogicalProject(input, fields, namedParseExpressions);
   }
 
   public LogicalPlan window(LogicalPlan input,
@@ -81,14 +88,14 @@ public static LogicalPlan dedupe(
     return new LogicalDedupe(
         input, Arrays.asList(fields), allowedDuplication, keepEmpty, consecutive);
   }
-  
+
   public static LogicalPlan rareTopN(LogicalPlan input, CommandType commandType,
-      List<Expression> groupByList, Expression... fields) {
+                                     List<Expression> groupByList, Expression... fields) {
     return rareTopN(input, commandType, 10, groupByList, fields);
   }
 
   public static LogicalPlan rareTopN(LogicalPlan input, CommandType commandType, int noOfResults,
-      List<Expression> groupByList, Expression... fields) {
+                                     List<Expression> groupByList, Expression... fields) {
     return new LogicalRareTopN(input, commandType, noOfResults, Arrays.asList(fields), groupByList);
   }