Added following string functions: regex, substr, substring, ltrim, rtrim, trim, upper, lower, concat, concat_ws, length, strcmp

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/expression/DSL.java

@@ -273,6 +273,54 @@ public FunctionExpression module(Expression... expressions) {
     return function(BuiltinFunctionName.MODULES, expressions);
   }
 
+  public FunctionExpression substr(Expression... expressions) {
+    return function(BuiltinFunctionName.SUBSTR, expressions);
+  }
+
+  public FunctionExpression substring(Expression... expressions) {
+    return function(BuiltinFunctionName.SUBSTR, expressions);
+  }
+
+  public FunctionExpression ltrim(Expression... expressions) {
+    return function(BuiltinFunctionName.LTRIM, expressions);
+  }
+
+  public FunctionExpression rtrim(Expression... expressions) {
+    return function(BuiltinFunctionName.RTRIM, expressions);
+  }
+
+  public FunctionExpression trim(Expression... expressions) {
+    return function(BuiltinFunctionName.TRIM, expressions);
+  }
+
+  public FunctionExpression upper(Expression... expressions) {
+    return function(BuiltinFunctionName.UPPER, expressions);
+  }
+
+  public FunctionExpression lower(Expression... expressions) {
+    return function(BuiltinFunctionName.LOWER, expressions);
+  }
+
+  public FunctionExpression regexp(Expression... expressions) {
+    return function(BuiltinFunctionName.REGEXP, expressions);
+  }
+
+  public FunctionExpression concat(Expression... expressions) {
+    return function(BuiltinFunctionName.CONCAT, expressions);
+  }
+
+  public FunctionExpression concat_ws(Expression... expressions) {
+    return function(BuiltinFunctionName.CONCAT_WS, expressions);
+  }
+
+  public FunctionExpression length(Expression... expressions) {
+    return function(BuiltinFunctionName.LENGTH, expressions);
+  }
+
+  public FunctionExpression strcmp(Expression... expressions) {
+    return function(BuiltinFunctionName.STRCMP, expressions);
+  }
+
   public FunctionExpression and(Expression... expressions) {
     return function(BuiltinFunctionName.AND, expressions);
   }

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/expression/config/ExpressionConfig.java

@@ -24,6 +24,7 @@
 import com.amazon.opendistroforelasticsearch.sql.expression.operator.arthmetic.MathematicalFunction;
 import com.amazon.opendistroforelasticsearch.sql.expression.operator.predicate.BinaryPredicateOperator;
 import com.amazon.opendistroforelasticsearch.sql.expression.operator.predicate.UnaryPredicateOperator;
+import com.amazon.opendistroforelasticsearch.sql.expression.text.TextFunction;
 import java.util.HashMap;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -47,6 +48,7 @@ public BuiltinFunctionRepository functionRepository() {
     AggregatorFunction.register(builtinFunctionRepository);
     DateTimeFunction.register(builtinFunctionRepository);
     IntervalClause.register(builtinFunctionRepository);
+    TextFunction.register(builtinFunctionRepository);
     return builtinFunctionRepository;
   }
 

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/expression/function/BuiltinFunctionName.java

@@ -94,6 +94,22 @@ public enum BuiltinFunctionName {
   SUM(FunctionName.of("sum")),
   COUNT(FunctionName.of("count")),
 
+  /**
+   * Text Functions.
+   */
+  SUBSTR(FunctionName.of("substr")),
+  SUBSTRING(FunctionName.of("substring")),
+  RTRIM(FunctionName.of("rtrim")),
+  LTRIM(FunctionName.of("ltrim")),
+  TRIM(FunctionName.of("trim")),
+  UPPER(FunctionName.of("upper")),
+  LOWER(FunctionName.of("lower")),
+  REGEXP(FunctionName.of("regexp")),
+  CONCAT(FunctionName.of("concat")),
+  CONCAT_WS(FunctionName.of("concat_ws")),
+  LENGTH(FunctionName.of("length")),
+  STRCMP(FunctionName.of("strcmp")),
+
   /**
    * NULL Test.
    */

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/expression/operator/predicate/BinaryPredicateOperator.java

@@ -20,6 +20,7 @@
 import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.LITERAL_NULL;
 import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.LITERAL_TRUE;
 import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.BOOLEAN;
+import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.INTEGER;
 import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.STRING;
 
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprBooleanValue;
@@ -61,6 +62,7 @@ public static void register(BuiltinFunctionRepository repository) {
     repository.register(gte());
     repository.register(like());
     repository.register(notLike());
+    repository.register(regexp());
   }
 
   /**
@@ -245,6 +247,12 @@ private static FunctionResolver like() {
             STRING));
   }
 
+  private static FunctionResolver regexp() {
+    return FunctionDSL.define(BuiltinFunctionName.REGEXP.getName(), FunctionDSL
+        .impl(FunctionDSL.nullMissingHandling(OperatorUtils::matchesRegexp),
+            INTEGER, STRING, STRING));
+  }
+
   private static FunctionResolver notLike() {
     return FunctionDSL.define(BuiltinFunctionName.NOT_LIKE.getName(), FunctionDSL
         .impl(FunctionDSL.nullMissingHandling(

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/expression/text/TextFunction.java

@@ -0,0 +1,231 @@
+/*
+ *
+ *    Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License").
+ *    You may not use this file except in compliance with the License.
+ *    A copy of the License is located at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    or in the "license" file accompanying this file. This file is distributed
+ *    on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ *    express or implied. See the License for the specific language governing
+ *    permissions and limitations under the License.
+ *
+ */
+
+package com.amazon.opendistroforelasticsearch.sql.expression.text;
+
+import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.INTEGER;
+import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.STRING;
+import static com.amazon.opendistroforelasticsearch.sql.expression.function.FunctionDSL.define;
+import static com.amazon.opendistroforelasticsearch.sql.expression.function.FunctionDSL.impl;
+import static com.amazon.opendistroforelasticsearch.sql.expression.function.FunctionDSL.nullMissingHandling;
+
+import com.amazon.opendistroforelasticsearch.sql.data.model.ExprIntegerValue;
+import com.amazon.opendistroforelasticsearch.sql.data.model.ExprStringValue;
+import com.amazon.opendistroforelasticsearch.sql.data.model.ExprValue;
+import com.amazon.opendistroforelasticsearch.sql.expression.function.BuiltinFunctionName;
+import com.amazon.opendistroforelasticsearch.sql.expression.function.BuiltinFunctionRepository;
+import com.amazon.opendistroforelasticsearch.sql.expression.function.FunctionResolver;
+
+import lombok.experimental.UtilityClass;
+
+
+/**
+ * The definition of text functions.
+ * 1) have the clear interface for function define.
+ * 2) the implementation should rely on ExprValue.
+ */
+@UtilityClass
+public class TextFunction {
+  private static String EMPTY_STRING = "";
+
+  /**
+   * Register String Functions.
+   *
+   * @param repository {@link BuiltinFunctionRepository}.
+   */
+  public void register(BuiltinFunctionRepository repository) {
+    repository.register(substr());
+    repository.register(substring());
+    repository.register(ltrim());
+    repository.register(rtrim());
+    repository.register(trim());
+    repository.register(lower());
+    repository.register(upper());
+    repository.register(concat());
+    repository.register(concat_ws());
+    repository.register(length());
+    repository.register(strcmp());
+  }
+
+  /**
+   * Gets substring starting at given point, for optional given length.
+   * Form of this function using keywords instead of comma delimited variables is not supported.
+   * Supports following signatures:
+   * (STRING, INTEGER)/(STRING, INTEGER, INTEGER) -> STRING
+   */
+  private FunctionResolver substring() {
+    return define(BuiltinFunctionName.SUBSTRING.getName(),
+            impl(nullMissingHandling(TextFunction::exprSubstrStart),
+                    STRING, STRING, INTEGER),
+            impl(nullMissingHandling(TextFunction::exprSubstrStartLength),
+                    STRING, STRING, INTEGER, INTEGER));
+  }
+
+  private FunctionResolver substr() {
+    return define(BuiltinFunctionName.SUBSTR.getName(),
+      impl(nullMissingHandling(TextFunction::exprSubstrStart),
+        STRING, STRING, INTEGER),
+      impl(nullMissingHandling(TextFunction::exprSubstrStartLength),
+        STRING, STRING, INTEGER, INTEGER));
+  }
+
+  /**
+   * Removes leading whitespace from string.
+   * Supports following signatures:
+   * STRING -> STRING
+   */
+  private FunctionResolver ltrim() {
+    return define(BuiltinFunctionName.LTRIM.getName(),
+            impl(nullMissingHandling((v) -> new ExprStringValue(v.stringValue().stripLeading())),
+                    STRING, STRING));
+  }
+
+  /**
+   * Removes trailing whitespace from string.
+   * Supports following signatures:
+   * STRING -> STRING
+   */
+  private FunctionResolver rtrim() {
+    return define(BuiltinFunctionName.RTRIM.getName(),
+        impl(nullMissingHandling((v) -> new ExprStringValue(v.stringValue().stripTrailing())),
+                STRING, STRING));
+  }
+
+  /**
+   * Removes leading and trailing whitespace from string.
+   * Has option to specify a String to trim instead of whitespace but this is not yet supported.
+   * Supporting String specification requires finding keywords inside TRIM command.
+   * Supports following signatures:
+   * STRING -> STRING
+   */
+  private FunctionResolver trim() {
+    return define(BuiltinFunctionName.TRIM.getName(),
+        impl(nullMissingHandling((v) -> new ExprStringValue(v.stringValue().trim())),
+            STRING, STRING));
+  }
+
+  /**
+   * Converts String to lowercase.
+   * Supports following signatures:
+   * STRING -> STRING
+   */
+  private FunctionResolver lower() {
+    return define(BuiltinFunctionName.LOWER.getName(),
+        impl(nullMissingHandling((v) -> new ExprStringValue((v.stringValue().toLowerCase()))),
+            STRING, STRING)
+    );
+  }
+
+  /**
+   * Converts String to uppercase.
+   * Supports following signatures:
+   * STRING -> STRING
+   */
+  private FunctionResolver upper() {
+    return define(BuiltinFunctionName.UPPER.getName(),
+        impl(nullMissingHandling((v) -> new ExprStringValue((v.stringValue().toUpperCase()))),
+            STRING, STRING)
+    );
+  }
+
+  /**
+   * TODO: https://github.com/opendistro-for-elasticsearch/sql/issues/710
+   *  Extend to accept variable argument amounts.
+   * Concatenates a list of Strings.
+   * Supports following signatures:
+   * (STRING, STRING) -> STRING
+   */
+  private FunctionResolver concat() {
+    return define(BuiltinFunctionName.CONCAT.getName(),
+        impl(nullMissingHandling((str1, str2) ->
+            new ExprStringValue(str1.stringValue() + str2.stringValue())), STRING, STRING, STRING));
+  }
+
+  /**
+   * TODO: https://github.com/opendistro-for-elasticsearch/sql/issues/710
+   *  Extend to accept variable argument amounts.
+   * Concatenates a list of Strings with a separator string.
+   * Supports following signatures:
+   * (STRING, STRING, STRING) -> STRING
+   */
+  private FunctionResolver concat_ws() {
+    return define(BuiltinFunctionName.CONCAT_WS.getName(),
+        impl(nullMissingHandling((sep, str1, str2) ->
+            new ExprStringValue(str1.stringValue() + sep.stringValue() + str2.stringValue())),
+                STRING, STRING, STRING, STRING));
+  }
+
+  /**
+   * Calculates length of String in bytes.
+   * Supports following signatures:
+   * STRING -> INTEGER
+   */
+  private FunctionResolver length() {
+    return define(BuiltinFunctionName.LENGTH.getName(),
+        impl(nullMissingHandling((str) ->
+            new ExprIntegerValue(str.stringValue().getBytes().length)), INTEGER, STRING));
+  }
+
+  /**
+   * Does String comparison of two Strings and returns Integer value.
+   * Supports following signatures:
+   * (STRING, STRING) -> INTEGER
+   */
+  private FunctionResolver strcmp() {
+    return define(BuiltinFunctionName.STRCMP.getName(),
+        impl(nullMissingHandling((str1, str2) ->
+            new ExprIntegerValue(Integer.compare(
+                str1.stringValue().compareTo(str2.stringValue()), 0))),
+            INTEGER, STRING, STRING));
+  }
+
+  private static ExprValue exprSubstrStart(ExprValue exprValue, ExprValue start) {
+    int startIdx = start.integerValue();
+    if (startIdx == 0) {
+      return new ExprStringValue(EMPTY_STRING);
+    }
+    String str = exprValue.stringValue();
+    return exprSubStr(str, startIdx, 0);
+  }
+
+  private static ExprValue exprSubstrStartLength(
+          ExprValue exprValue, ExprValue start, ExprValue length) {
+    int startIdx = start.integerValue();
+    int len = length.integerValue();
+    if ((startIdx == 0) || (len == 0)) {
+      return new ExprStringValue(EMPTY_STRING);
+    }
+    String str = exprValue.stringValue();
+    return exprSubStr(str, startIdx, len);
+  }
+
+  private static ExprValue exprSubStr(String str, int start, int len) {
+    // Correct negative start
+    start = (start > 0) ? (start - 1) : (str.length() + start);
+
+    // Length 0 is only given by exprSubstrStart, exprSubstrStartLength handles this explicitly.
+    if ((start + len > str.length()) || (len == 0)) {
+      // Start is after string, return empty.
+      if (start > str.length()) {
+        return new ExprStringValue(EMPTY_STRING);
+      }
+      return new ExprStringValue(str.substring(start));
+    }
+    return new ExprStringValue(str.substring(start, start + len));
+  }
+}
+

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/utils/OperatorUtils.java

@@ -16,6 +16,7 @@
 package com.amazon.opendistroforelasticsearch.sql.utils;
 
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprBooleanValue;
+import com.amazon.opendistroforelasticsearch.sql.data.model.ExprIntegerValue;
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprValue;
 import java.util.regex.Pattern;
 import lombok.experimental.UtilityClass;
@@ -35,6 +36,16 @@ public static ExprBooleanValue matches(ExprValue text, ExprValue pattern) {
             .matches());
   }
 
+  /**
+   * Checks if text matches regular expression pattern.
+   * @param pattern string pattern to match.
+   * @return if text matches pattern returns true; else return false.
+   */
+  public static ExprIntegerValue matchesRegexp(ExprValue text, ExprValue pattern) {
+    return new ExprIntegerValue(Pattern.compile(pattern.stringValue()).matcher(text.stringValue())
+                    .matches() ? 1 : 0);
+  }
+
   private static final char DEFAULT_ESCAPE = '\\';
 
   private static String patternToRegex(String patternString) {