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,229 @@
+/*
+ *
+ * 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.FunctionName;
+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 substringSubstr(FunctionName functionName) {
+ return define(functionName,
+ impl(nullMissingHandling(TextFunction::exprSubstrStart),
+ STRING, STRING, INTEGER),
+ impl(nullMissingHandling(TextFunction::exprSubstrStartLength),
+ STRING, STRING, INTEGER, INTEGER));
+ }
+
+ private FunctionResolver substring() {
+ return substringSubstr(BuiltinFunctionName.SUBSTRING.getName());
+ }
+
+ private FunctionResolver substr() {
+ return substringSubstr(BuiltinFunctionName.SUBSTR.getName());
+ }
+
+ /**
+ * 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, str.length());
+ }
+
+ 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);
+
+ if (start > str.length()) {
+ return new ExprStringValue(EMPTY_STRING);
+ } else if ((start + len) > str.length()) {
+ 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) {