Implementation for simple_query_string.

common/src/main/java/org/opensearch/sql/common/antlr/Parser.java

@@ -0,0 +1,7 @@
+package org.opensearch.sql.common.antlr;
+
+import org.antlr.v4.runtime.tree.ParseTree;
+
+public interface Parser {
+  ParseTree parse(String query);
+}

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

@@ -654,6 +654,18 @@ public FunctionExpression match(Expression... args) {
     return compile(BuiltinFunctionName.MATCH, args);
   }
 
+  public FunctionExpression match_phrase(Expression... args) {
+    return compile(BuiltinFunctionName.MATCH_PHRASE, args);
+  }
+
+  public FunctionExpression match_bool_prefix(Expression... args) {
+    return compile(BuiltinFunctionName.MATCH_BOOL_PREFIX, args);
+  }
+
+  private FunctionExpression compile(BuiltinFunctionName bfn, Expression... args) {
+    return (FunctionExpression) repository.compile(bfn.getName(), Arrays.asList(args.clone()));
+  }
+
   public FunctionExpression simple_query_string(Expression... args) {
     return (FunctionExpression) repository
         .compile(BuiltinFunctionName.SIMPLE_QUERY_STRING.getName(), Arrays.asList(args.clone()));

core/src/main/java/org/opensearch/sql/expression/function/BuiltinFunctionName.java

@@ -187,6 +187,9 @@ public enum BuiltinFunctionName {
    * Relevance Function.
    */
   MATCH(FunctionName.of("match")),
+  MATCH_PHRASE(FunctionName.of("match_phrase")),
+  MATCHPHRASE(FunctionName.of("matchphrase")),
+  MATCH_BOOL_PREFIX(FunctionName.of("match_bool_prefix")),
   SIMPLE_QUERY_STRING(FunctionName.of("simple_query_string")),
 
   /**

core/src/main/java/org/opensearch/sql/expression/function/OpenSearchFunctions.java

@@ -8,13 +8,15 @@
 import static org.opensearch.sql.data.type.ExprCoreType.STRING;
 import static org.opensearch.sql.data.type.ExprCoreType.STRUCT;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 import lombok.experimental.UtilityClass;
+import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.opensearch.sql.data.model.ExprValue;
 import org.opensearch.sql.data.type.ExprCoreType;
 import org.opensearch.sql.data.type.ExprType;
@@ -29,27 +31,44 @@ public class OpenSearchFunctions {
   public static final int MATCH_MAX_NUM_PARAMETERS = 12;
   public static final int MATCH_PHRASE_MAX_NUM_PARAMETERS = 3;
   public static final int MIN_NUM_PARAMETERS = 2;
+  public static final int SIMPLE_QUERY_STRING_MAX_NUM_PARAMETERS = 12;
 
   /**
    * Add functions specific to OpenSearch to repository.
    */
   public void register(BuiltinFunctionRepository repository) {
+    repository.register(match_bool_prefix());
     repository.register(match());
     repository.register(simple_query_string());
+    // Register MATCHPHRASE as MATCH_PHRASE as well for backwards
+    // compatibility.
+    repository.register(match_phrase(BuiltinFunctionName.MATCH_PHRASE));
+    repository.register(match_phrase(BuiltinFunctionName.MATCHPHRASE));
+  }
+
+  private static FunctionResolver match_bool_prefix() {
+    FunctionName name = BuiltinFunctionName.MATCH_BOOL_PREFIX.getName();
+    // TODO: Create different resolver more suited for relevance functions.
+    return new FunctionResolver(name,
+        ImmutableMap.<FunctionSignature, FunctionBuilder>builder()
+            .put(new FunctionSignature(name, ImmutableList.of(STRING, STRING)),
+                args -> new OpenSearchFunction(name, args))
+            .build());
   }
 
   private static FunctionResolver match() {
     FunctionName funcName = BuiltinFunctionName.MATCH.getName();
-    // At most field, query, and all optional parameters
-    final int matchMaxNumParameters = 14;
-    return getRelevanceFunctionResolver(funcName, matchMaxNumParameters, STRING);
+    return getRelevanceFunctionResolver(funcName, MATCH_MAX_NUM_PARAMETERS, STRING);
+  }
+
+  private static FunctionResolver match_phrase(BuiltinFunctionName matchPhrase) {
+    FunctionName funcName = matchPhrase.getName();
+    return getRelevanceFunctionResolver(funcName, MATCH_PHRASE_MAX_NUM_PARAMETERS, STRING);
   }
 
   private static FunctionResolver simple_query_string() {
     FunctionName funcName = BuiltinFunctionName.SIMPLE_QUERY_STRING.getName();
-    // At most field, query, and all optional parameters
-    final int simpleQueryStringMaxNumParameters = 12;
-    return getRelevanceFunctionResolver(funcName, simpleQueryStringMaxNumParameters, STRUCT);
+    return getRelevanceFunctionResolver(funcName, SIMPLE_QUERY_STRING_MAX_NUM_PARAMETERS, STRUCT);
   }
 
   private static FunctionResolver getRelevanceFunctionResolver(
@@ -59,11 +78,12 @@ private static FunctionResolver getRelevanceFunctionResolver(
   }
 
   private static Map<FunctionSignature, FunctionBuilder> getRelevanceFunctionSignatureMap(
-      FunctionName funcName, int maxNumParameters, ExprCoreType firstArgType) {
-    final int minNumParameters = 1;
+      FunctionName funcName, int numOptionalParameters, ExprCoreType firstArgType) {
     FunctionBuilder buildFunction = args -> new OpenSearchFunction(funcName, args);
     var signatureMapBuilder = ImmutableMap.<FunctionSignature, FunctionBuilder>builder();
-    for (int numParameters = minNumParameters; numParameters <= maxNumParameters; numParameters++) {
+    for (int numParameters = MIN_NUM_PARAMETERS - 1;
+         numParameters <= MIN_NUM_PARAMETERS + numOptionalParameters;
+         numParameters++) {
       List<ExprType> args = new ArrayList<>(Collections.nCopies(numParameters, STRING));
       args.add(0, firstArgType);
       signatureMapBuilder.put(new FunctionSignature(funcName, args), buildFunction);

core/src/test/java/org/opensearch/sql/analysis/ExpressionAnalyzerTest.java

@@ -342,6 +342,17 @@ public void named_non_parse_expression() {
     assertAnalyzeEqual(DSL.ref("string_field", STRING), qualifiedName("string_field"));
   }
 
+  @Test
+  void match_bool_prefix_expression() {
+    assertAnalyzeEqual(
+        dsl.match_bool_prefix(
+            dsl.namedArgument("field", DSL.literal("fieldA")),
+            dsl.namedArgument("query", DSL.literal("sample query"))),
+        AstDSL.function("match_bool_prefix",
+            AstDSL.unresolvedArg("field", stringLiteral("fieldA")),
+            AstDSL.unresolvedArg("query", stringLiteral("sample query"))));
+  }
+
   @Test
   void visit_span() {
     assertAnalyzeEqual(
@@ -394,8 +405,8 @@ void simple_query_string_expression_with_params() {
   }
 
   @Test
-  // Test is disabled because DSL and AstDSL expressions always has fields in the different order
-  // regardless of how they are specified
+  // Test is disabled because DSL and AstDSL expressions sometimes has fields in the different order
+  // regardless of how they are specified. Test passes and fails in a flaky behavior.
   @Disabled
   void simple_query_string_expression_two_fields() {
     assertAnalyzeEqual(
@@ -406,8 +417,8 @@ void simple_query_string_expression_two_fields() {
             dsl.namedArgument("query", DSL.literal("sample query"))),
         AstDSL.function("simple_query_string",
             AstDSL.unresolvedArg("fields", new RelevanceFieldList(Map.of(
-                stringLiteral("field2"), floatLiteral(.3F),
-                stringLiteral("field1"), floatLiteral(1.F)))),
+                stringLiteral("field1"), floatLiteral(1.F),
+                stringLiteral("field2"), floatLiteral(.3F)))),
             AstDSL.unresolvedArg("query", stringLiteral("sample query"))));
   }
 

core/src/test/java/org/opensearch/sql/expression/function/OpenSearchFunctionsTest.java

@@ -10,6 +10,7 @@
 import static org.opensearch.sql.data.type.ExprCoreType.BOOLEAN;
 
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import org.junit.jupiter.api.Test;
 import org.opensearch.sql.data.model.ExprTupleValue;

docs/user/dql/functions.rst

@@ -2183,8 +2183,6 @@ Example with only ``field`` and ``query`` expressions, and all other parameters
     | Bates      | 789 Madison Street |
     +------------+--------------------+
 
-
-
 Another example to show how to set custom values for the optional parameters::
 
     os> SELECT lastname FROM accounts WHERE match(firstname, 'Hattie', operator='AND', boost=2.0);
@@ -2237,8 +2235,6 @@ Example with only ``fields`` and ``query`` expressions, and all other parameters
     | Nanette     | Bates      | Nogal  | 789 Madison Street |
     +-------------+------------+--------+--------------------+
 
-
-
 Another example to show how to set custom values for the optional parameters::
 
     os> select firstname, lastname, city, address from accounts where simple_query_string(['firstname', city ^ 2], 'Amber Nogal', analyzer=keyword, default_operator='AND');
@@ -2247,3 +2243,63 @@ Another example to show how to set custom values for the optional parameters::
     | firstname   | lastname   | city   | address   |
     |-------------+------------+--------+-----------|
     +-------------+------------+--------+-----------+
+
+MATCH_PHRASE
+------------
+
+Description
+>>>>>>>>>>>
+
+``match_phrase(field_expression, query_expression[, option=<option_value>]*)``
+
+The match_phrase function maps to the match_phrase query used in search engine, to return the documents that match a provided text with a given field. Available parameters include:
+
+- analyzer
+- slop
+- zero_terms_query
+
+For backward compatibility, matchphrase is also supported and mapped to match_phrase query as well.
+
+Example with only ``field`` and ``query`` expressions, and all other parameters are set default values::
+
+    os> SELECT author, title FROM books WHERE match_phrase(author, 'Alexander Milne');
+    fetched rows / total rows = 2/2
+    +----------------------+--------------------------+
+    | author               | title                    |
+    |----------------------+--------------------------|
+    | Alan Alexander Milne | The House at Pooh Corner |
+    | Alan Alexander Milne | Winnie-the-Pooh          |
+    +----------------------+--------------------------+
+
+Another example to show how to set custom values for the optional parameters::
+
+    os> SELECT author, title FROM books WHERE match_phrase(author, 'Alan Milne', slop = 2);
+    fetched rows / total rows = 2/2
+    +----------------------+--------------------------+
+    | author               | title                    |
+    |----------------------+--------------------------|
+    | Alan Alexander Milne | The House at Pooh Corner |
+    | Alan Alexander Milne | Winnie-the-Pooh          |
+    +----------------------+--------------------------+
+
+
+MATCH_BOOL_PREFIX
+-----------------
+
+Description
+>>>>>>>>>>>
+
+``match_bool_prefix(field_expression, query_expression)``
+
+The match_bool_prefix function maps to the match_bool_prefix query in the search engine. match_bool_prefix creates a match query from all but the last term in the query string. The last term is used to create a prefix query.
+
+Example with only ``field`` and ``query`` expressions, and all other parameters are set default values::
+
+    os> SELECT firstname, address FROM accounts WHERE match_bool_prefix(address, 'Bristol Stre');
+    fetched rows / total rows = 2/2
+    +-------------+--------------------+
+    | firstname   | address            |
+    |-------------+--------------------|
+    | Hattie      | 671 Bristol Street |
+    | Nanette     | 789 Madison Street |
+    +-------------+--------------------+

docs/user/ppl/functions/relevance.rst

@@ -99,8 +99,6 @@ Example with only ``fields`` and ``query`` expressions, and all other parameters
     | Nanette     | Bates      | Nogal  | 789 Madison Street |
     +-------------+------------+--------+--------------------+
 
-
-
 Another example to show how to set custom values for the optional parameters::
 
     os> source=accounts | where simple_query_string(['firstname', city ^ 2], 'Amber Nogal', analyzer=keyword, default_operator='AND') | fields firstname, lastname, city, address;
@@ -110,6 +108,44 @@ Another example to show how to set custom values for the optional parameters::
     |-------------+------------+--------+-----------|
     +-------------+------------+--------+-----------+
 
+MATCH_PHRASE
+------------
+
+Description
+>>>>>>>>>>>
+
+``match_phrase(field_expression, query_expression[, option=<option_value>]*)``
+
+The match_phrase function maps to the match_phrase query used in search engine, to return the documents that match a provided text with a given field. Available parameters include:
+
+- analyzer
+- slop
+- zero_terms_query
+
+For backward compatibility, matchphrase is also supported and mapped to match_phrase query as well.
+
+Example with only ``field`` and ``query`` expressions, and all other parameters are set default values::
+
+    os> source=books | where match_phrase(author, 'Alexander Milne') | fields author, title
+    fetched rows / total rows = 2/2
+    +----------------------+--------------------------+
+    | author               | title                    |
+    |----------------------+--------------------------|
+    | Alan Alexander Milne | The House at Pooh Corner |
+    | Alan Alexander Milne | Winnie-the-Pooh          |
+    +----------------------+--------------------------+
+
+Another example to show how to set custom values for the optional parameters::
+
+    os> source=books | where match_phrase(author, 'Alan Milne', slop = 2) | fields author, title
+    fetched rows / total rows = 2/2
+    +----------------------+--------------------------+
+    | author               | title                    |
+    |----------------------+--------------------------|
+    | Alan Alexander Milne | The House at Pooh Corner |
+    | Alan Alexander Milne | Winnie-the-Pooh          |
+    +----------------------+--------------------------+
+
 Limitations
 >>>>>>>>>>>
 

integ-test/src/test/java/org/opensearch/sql/legacy/SQLFunctionsIT.java

@@ -480,7 +480,7 @@ public void castStatementInWhereClauseLessThanConstantTest() {
   public void castStatementInWhereClauseDatetimeCastTest() {
     JSONObject response = executeJdbcRequest("SELECT date_keyword FROM "
         + TestsConstants.TEST_INDEX_DATE
-        + " WHERE (CAST(date_keyword AS DATETIME) = \'2014-08-19T07:09:13.434Z\')");
+        + " WHERE (CAST(date_keyword AS DATETIME) = '2014-08-19T07:09:13.434Z')");
 
     String schema_result = "{\"name\":\"date_keyword\",\"type\":\"keyword\"}";
     assertEquals(response.getJSONArray("schema").get(0).toString(), schema_result);
@@ -704,7 +704,7 @@ public void ifFuncShouldPassJDBC() {
     JSONObject response = executeJdbcRequest(
         "SELECT IF(age > 30, 'True', 'False') AS Ages FROM " + TEST_INDEX_ACCOUNT
             + " WHERE age IS NOT NULL GROUP BY Ages");
-    assertEquals("IF(age > 30, \'True\', \'False\')", response.query("/schema/0/name"));
+    assertEquals("IF(age > 30, 'True', 'False')", response.query("/schema/0/name"));
     assertEquals("Ages", response.query("/schema/0/alias"));
     assertEquals("keyword", response.query("/schema/0/type"));
   }
@@ -742,7 +742,7 @@ public void ifnullShouldPassJDBC() throws IOException {
     JSONObject response = executeJdbcRequest(
         "SELECT IFNULL(lastname, 'unknown') AS name FROM " + TEST_INDEX_ACCOUNT
             + " GROUP BY name");
-    assertEquals("IFNULL(lastname, \'unknown\')", response.query("/schema/0/name"));
+    assertEquals("IFNULL(lastname, 'unknown')", response.query("/schema/0/name"));
     assertEquals("name", response.query("/schema/0/alias"));
     assertEquals("keyword", response.query("/schema/0/type"));
   }

integ-test/src/test/java/org/opensearch/sql/sql/ConditionalIT.java

@@ -45,7 +45,7 @@ public void ifnullShouldPassJDBC() throws IOException {
     JSONObject response = executeJdbcRequest(
         "SELECT IFNULL(lastname, 'unknown') AS name FROM " + TEST_INDEX_ACCOUNT
             + " GROUP BY name");
-    assertEquals("IFNULL(lastname, \'unknown\')", response.query("/schema/0/name"));
+    assertEquals("IFNULL(lastname, 'unknown')", response.query("/schema/0/name"));
     assertEquals("name", response.query("/schema/0/alias"));
     assertEquals("keyword", response.query("/schema/0/type"));
   }
@@ -92,7 +92,7 @@ public void ifnullWithMissingInputTest() {
   public void nullifShouldPassJDBC() throws IOException {
     JSONObject response = executeJdbcRequest(
             "SELECT NULLIF(lastname, 'unknown') AS name FROM " + TEST_INDEX_ACCOUNT);
-    assertEquals("NULLIF(lastname, \'unknown\')", response.query("/schema/0/name"));
+    assertEquals("NULLIF(lastname, 'unknown')", response.query("/schema/0/name"));
     assertEquals("name", response.query("/schema/0/alias"));
     assertEquals("keyword", response.query("/schema/0/type"));
   }
@@ -181,8 +181,8 @@ public void isnullWithMathExpr() throws IOException{
   @Test
   public void ifShouldPassJDBC() throws IOException {
     JSONObject response = executeJdbcRequest(
-            "SELECT IF(2 > 0, \'hello\', \'world\') AS name FROM " + TEST_INDEX_ACCOUNT);
-    assertEquals("IF(2 > 0, \'hello\', \'world\')", response.query("/schema/0/name"));
+        "SELECT IF(2 > 0, 'hello', 'world') AS name FROM " + TEST_INDEX_ACCOUNT);
+    assertEquals("IF(2 > 0, 'hello', 'world')", response.query("/schema/0/name"));
     assertEquals("name", response.query("/schema/0/alias"));
     assertEquals("keyword", response.query("/schema/0/type"));
   }