Adding alternate multi_match syntax.

forestmvey · forestmvey · commit 94a700ac6d7e · 2022-11-16T08:18:49.000-08:00
Signed-off-by: forestmvey &lt;forestv@bitquilltech.com&gt;
diff --git a/core/src/main/java/org/opensearch/sql/expression/function/BuiltinFunctionName.java b/core/src/main/java/org/opensearch/sql/expression/function/BuiltinFunctionName.java
@@ -220,7 +220,9 @@ public enum BuiltinFunctionName {
   QUERY(FunctionName.of("query")),
   MATCH_QUERY(FunctionName.of("match_query")),
   MATCHQUERY(FunctionName.of("matchquery")),
-  MULTI_MATCH(FunctionName.of("multi_match"));
+  MULTI_MATCH(FunctionName.of("multi_match")),
+  MULTIMATCH(FunctionName.of("multimatch")),
+  MULTIMATCHQUERY(FunctionName.of("multimatchquery"));
 
   private final FunctionName name;
 
diff --git a/core/src/main/java/org/opensearch/sql/expression/function/OpenSearchFunctions.java b/core/src/main/java/org/opensearch/sql/expression/function/OpenSearchFunctions.java
@@ -28,7 +28,9 @@ public class OpenSearchFunctions {
   public void register(BuiltinFunctionRepository repository) {
     repository.register(match_bool_prefix());
     repository.register(match());
-    repository.register(multi_match());
+    repository.register(multi_match(BuiltinFunctionName.MULTI_MATCH));
+    repository.register(multi_match(BuiltinFunctionName.MULTIMATCH));
+    repository.register(multi_match(BuiltinFunctionName.MULTIMATCHQUERY));
     repository.register(simple_query_string());
     repository.register(query());
     repository.register(query_string());
@@ -59,8 +61,8 @@ private static FunctionResolver match_phrase(BuiltinFunctionName matchPhrase) {
     return new RelevanceFunctionResolver(funcName, STRING);
   }
 
-  private static FunctionResolver multi_match() {
-    FunctionName funcName = BuiltinFunctionName.MULTI_MATCH.getName();
+  private static FunctionResolver multi_match(BuiltinFunctionName matchPhrase) {
+    FunctionName funcName = matchPhrase.getName();
     return new RelevanceFunctionResolver(funcName, STRUCT);
   }
 
diff --git a/integ-test/src/test/java/org/opensearch/sql/sql/MultiMatchIT.java b/integ-test/src/test/java/org/opensearch/sql/sql/MultiMatchIT.java
@@ -6,6 +6,8 @@
 package org.opensearch.sql.sql;
 
 import static org.opensearch.sql.legacy.TestsConstants.TEST_INDEX_BEER;
+import static org.opensearch.sql.util.MatcherUtils.rows;
+import static org.opensearch.sql.util.MatcherUtils.verifyDataRows;
 
 import java.io.IOException;
 import org.json.JSONObject;
@@ -27,15 +29,15 @@ public void init() throws IOException {
   */
 
   @Test
-  public void test_mandatory_params() throws IOException {
+  public void test_mandatory_params() {
     String query = "SELECT Id FROM " + TEST_INDEX_BEER
         + " WHERE multi_match([\\\"Tags\\\" ^ 1.5, Title, `Body` 4.2], 'taste')";
     var result = new JSONObject(executeQuery(query, "jdbc"));
     assertEquals(16, result.getInt("total"));
   }
 
   @Test
-  public void test_all_params() throws IOException {
+  public void test_all_params() {
     String query = "SELECT Id FROM " + TEST_INDEX_BEER
         + " WHERE multi_match(['Body', Tags], 'taste beer', operator='and', analyzer=english,"
         + "auto_generate_synonyms_phrase_query=true, boost = 0.77, cutoff_frequency=0.33,"
@@ -47,7 +49,7 @@ public void test_all_params() throws IOException {
   }
 
   @Test
-  public void verify_wildcard_test() throws IOException {
+  public void verify_wildcard_test() {
     String query1 = "SELECT Id FROM " + TEST_INDEX_BEER
         + " WHERE multi_match(['Tags'], 'taste')";
     var result1 = new JSONObject(executeQuery(query1, "jdbc"));
@@ -61,4 +63,65 @@ public void verify_wildcard_test() throws IOException {
     var result = new JSONObject(executeQuery(query, "jdbc"));
     assertEquals(10, result.getInt("total"));
   }
+
+  @Test
+  public void test_multimatch_alternate_parameter_syntax() {
+    String query = "SELECT Tags FROM " + TEST_INDEX_BEER
+        + " WHERE multimatch('query'='taste', 'fields'='Tags')";
+    var result = new JSONObject(executeQuery(query, "jdbc"));
+    assertEquals(8, result.getInt("total"));
+  }
+
+  @Test
+  public void test_multimatchquery_alternate_parameter_syntax() {
+    String query = "SELECT Tags FROM " + TEST_INDEX_BEER
+        + " WHERE multimatchquery(query='cicerone', fields='Tags')";
+    var result = new JSONObject(executeQuery(query, "jdbc"));
+    assertEquals(2, result.getInt("total"));
+    verifyDataRows(result, rows("serving cicerone restaurants"),
+        rows("taste cicerone"));
+  }
+
+  @Test
+  public void test_quoted_multi_match_alternate_parameter_syntax() {
+    String query = "SELECT Tags FROM " + TEST_INDEX_BEER
+        + " WHERE multi_match('query'='cicerone', 'fields'='Tags')";
+    var result = new JSONObject(executeQuery(query, "jdbc"));
+    assertEquals(2, result.getInt("total"));
+    verifyDataRows(result, rows("serving cicerone restaurants"),
+        rows("taste cicerone"));
+  }
+
+  @Test
+  public void test_multi_match_alternate_parameter_syntax() {
+    String query = "SELECT Tags FROM " + TEST_INDEX_BEER
+        + " WHERE multi_match(query='cicerone', fields='Tags')";
+    var result = new JSONObject(executeQuery(query, "jdbc"));
+    assertEquals(2, result.getInt("total"));
+    verifyDataRows(result, rows("serving cicerone restaurants"),
+        rows("taste cicerone"));
+  }
+
+  @Test
+  public void test_wildcard_multi_match_alternate_parameter_syntax() {
+    String query = "SELECT Body FROM " + TEST_INDEX_BEER
+        + " WHERE multi_match(query='IPA', fields='B*') LIMIT 1";
+    var result = new JSONObject(executeQuery(query, "jdbc"));
+    verifyDataRows(result, rows("<p>I know what makes an IPA an IPA, but what are the unique" +
+        " characteristics of it's common variants? To be specific, the ones I'm interested in are Double IPA" +
+        " and Black IPA, but general differences between any other styles would be welcome too. </p>\n"));
+  }
+
+  @Test
+  public void test_all_params_multimatchquery_alternate_parameter_syntax() {
+    String query = "SELECT Id FROM " + TEST_INDEX_BEER
+        + " WHERE multimatchquery(query='cicerone', fields='Tags', 'operator'='or', analyzer=english,"
+        + "auto_generate_synonyms_phrase_query=true, boost = 0.77, cutoff_frequency=0.33,"
+        + "fuzziness = 'AUTO:1,5', fuzzy_transpositions = false, lenient = true, max_expansions = 25,"
+        + "minimum_should_match = '2<-25% 9<-3', prefix_length = 7, tie_breaker = 0.3,"
+        + "type = most_fields, slop = 2, zero_terms_query = 'ALL');";
+
+    var result = new JSONObject(executeQuery(query, "jdbc"));
+    assertEquals(2, result.getInt("total"));
+  }
 }
diff --git a/opensearch/src/main/java/org/opensearch/sql/opensearch/storage/script/filter/FilterQueryBuilder.java b/opensearch/src/main/java/org/opensearch/sql/opensearch/storage/script/filter/FilterQueryBuilder.java
@@ -65,6 +65,8 @@ public class FilterQueryBuilder extends ExpressionNodeVisitor<QueryBuilder, Obje
           .put(BuiltinFunctionName.MATCH_QUERY.getName(), new MatchQuery())
           .put(BuiltinFunctionName.MATCHQUERY.getName(), new MatchQuery())
           .put(BuiltinFunctionName.MULTI_MATCH.getName(), new MultiMatchQuery())
+          .put(BuiltinFunctionName.MULTIMATCH.getName(), new MultiMatchQuery())
+          .put(BuiltinFunctionName.MULTIMATCHQUERY.getName(), new MultiMatchQuery())
           .put(BuiltinFunctionName.SIMPLE_QUERY_STRING.getName(), new SimpleQueryStringQuery())
           .put(BuiltinFunctionName.QUERY_STRING.getName(), new QueryStringQuery())
           .put(BuiltinFunctionName.MATCH_BOOL_PREFIX.getName(), new MatchBoolPrefixQuery())
diff --git a/opensearch/src/test/java/org/opensearch/sql/opensearch/storage/script/filter/lucene/MultiMatchTest.java b/opensearch/src/test/java/org/opensearch/sql/opensearch/storage/script/filter/lucene/MultiMatchTest.java
@@ -39,7 +39,11 @@ class MultiMatchTest {
   private static final DSL dsl = new ExpressionConfig()
       .dsl(new ExpressionConfig().functionRepository());
   private final MultiMatchQuery multiMatchQuery = new MultiMatchQuery();
-  private final FunctionName multiMatch = FunctionName.of("multi_match");
+  private final FunctionName multiMatchName = FunctionName.of("multimatch");
+  private final FunctionName multiMatchWithUnderscoreName = FunctionName.of("multi_match");
+  private final FunctionName multiMatchQueryName = FunctionName.of("multi_match");
+  private final FunctionName[] functionNames =
+      {multiMatchName, multiMatchWithUnderscoreName, multiMatchQueryName};
   private static final LiteralExpression fields_value = DSL.literal(
       new ExprTupleValue(new LinkedHashMap<>(ImmutableMap.of(
           "title", ExprValueUtils.floatValue(1.F),
@@ -133,22 +137,28 @@ static Stream<List<Expression>> generateValidData() {
   @ParameterizedTest
   @MethodSource("generateValidData")
   public void test_valid_parameters(List<Expression> validArgs) {
-    Assertions.assertNotNull(multiMatchQuery.build(
-        new MultiMatchExpression(validArgs)));
+    for (FunctionName funcName: functionNames) {
+      Assertions.assertNotNull(multiMatchQuery.build(
+          new MultiMatchExpression(validArgs, funcName)));
+    }
   }
 
   @Test
   public void test_SyntaxCheckException_when_no_arguments() {
     List<Expression> arguments = List.of();
-    assertThrows(SyntaxCheckException.class,
-        () -> multiMatchQuery.build(new MultiMatchExpression(arguments)));
+    for (FunctionName funcName: functionNames) {
+      assertThrows(SyntaxCheckException.class,
+          () -> multiMatchQuery.build(new MultiMatchExpression(arguments, funcName)));
+    }
   }
 
   @Test
   public void test_SyntaxCheckException_when_one_argument() {
     List<Expression> arguments = List.of(namedArgument("fields", fields_value));
-    assertThrows(SyntaxCheckException.class,
-        () -> multiMatchQuery.build(new MultiMatchExpression(arguments)));
+    for (FunctionName funcName: functionNames) {
+      assertThrows(SyntaxCheckException.class,
+          () -> multiMatchQuery.build(new MultiMatchExpression(arguments, funcName)));
+    }
   }
 
   @Test
@@ -157,17 +167,19 @@ public void test_SemanticCheckException_when_invalid_parameter() {
         namedArgument("fields", fields_value),
         namedArgument("query", query_value),
         dsl.namedArgument("unsupported", "unsupported_value"));
-    Assertions.assertThrows(SemanticCheckException.class,
-        () -> multiMatchQuery.build(new MultiMatchExpression(arguments)));
+    for (FunctionName funcName: functionNames) {
+      Assertions.assertThrows(SemanticCheckException.class,
+          () -> multiMatchQuery.build(new MultiMatchExpression(arguments, funcName)));
+    }
   }
 
   private NamedArgumentExpression namedArgument(String name, LiteralExpression value) {
     return dsl.namedArgument(name, value);
   }
 
   private class MultiMatchExpression extends FunctionExpression {
-    public MultiMatchExpression(List<Expression> arguments) {
-      super(MultiMatchTest.this.multiMatch, arguments);
+    public MultiMatchExpression(List<Expression> arguments, FunctionName funcName) {
+      super(funcName, arguments);
     }
 
     @Override
diff --git a/sql/src/main/antlr/OpenSearchSQLLexer.g4 b/sql/src/main/antlr/OpenSearchSQLLexer.g4
@@ -305,6 +305,7 @@ MINUTE_OF_HOUR:                     'MINUTE_OF_HOUR';
 MONTH_OF_YEAR:                      'MONTH_OF_YEAR';
 MULTIMATCH:                         'MULTIMATCH';
 MULTI_MATCH:                        'MULTI_MATCH';
+MULTIMATCHQUERY:                    'MULTIMATCHQUERY';
 NESTED:                             'NESTED';
 PERCENTILES:                        'PERCENTILES';
 REGEXP_QUERY:                       'REGEXP_QUERY';
diff --git a/sql/src/main/antlr/OpenSearchSQLParser.g4 b/sql/src/main/antlr/OpenSearchSQLParser.g4
@@ -347,6 +347,9 @@ multiFieldRelevanceFunction
     : multiFieldRelevanceFunctionName LR_BRACKET
         LT_SQR_PRTHS field=relevanceFieldAndWeight (COMMA field=relevanceFieldAndWeight)* RT_SQR_PRTHS
         COMMA query=relevanceQuery (COMMA relevanceArg)* RR_BRACKET
+    | multiFieldRelevanceFunctionName LR_BRACKET
+              alternateMultiMatchQueryField  COMMA alternateMultiMatchQueryField
+              (COMMA alternateMultiMatchOptionalArg)* RR_BRACKET
     ;
 
 convertedDataType
@@ -431,6 +434,8 @@ singleFieldRelevanceFunctionName
 
 multiFieldRelevanceFunctionName
     : MULTI_MATCH
+    | MULTIMATCH
+    | MULTIMATCHQUERY
     | SIMPLE_QUERY_STRING
     | QUERY_STRING
     ;
@@ -498,3 +503,22 @@ highlightArgValue
     : stringLiteral
     ;
 
+alternateMultiMatchArgName
+    : FIELDS
+    | QUERY
+    | stringLiteral
+    ;
+
+alternateMultiMatchArgVal
+    : qualifiedName
+    | stringLiteral
+    ;
+
+alternateMultiMatchOptionalArg
+    : relevanceArg
+    | argName=stringLiteral EQUAL_SYMBOL argVal=relevanceArgValue
+    ;
+
+alternateMultiMatchQueryField
+    : argName=alternateMultiMatchArgName EQUAL_SYMBOL argVal=alternateMultiMatchArgVal
+    ;
diff --git a/sql/src/main/java/org/opensearch/sql/sql/parser/AstExpressionBuilder.java b/sql/src/main/java/org/opensearch/sql/sql/parser/AstExpressionBuilder.java
@@ -80,6 +80,8 @@
 import org.opensearch.sql.ast.expression.WindowFunction;
 import org.opensearch.sql.ast.tree.Sort.SortOption;
 import org.opensearch.sql.common.utils.StringUtils;
+import org.opensearch.sql.exception.SemanticCheckException;
+import org.opensearch.sql.expression.function.BuiltinFunctionName;
 import org.opensearch.sql.sql.antlr.parser.OpenSearchSQLParser;
 import org.opensearch.sql.sql.antlr.parser.OpenSearchSQLParser.AndExpressionContext;
 import org.opensearch.sql.sql.antlr.parser.OpenSearchSQLParser.ColumnNameContext;
@@ -399,9 +401,24 @@ public UnresolvedExpression visitSingleFieldRelevanceFunction(
   @Override
   public UnresolvedExpression visitMultiFieldRelevanceFunction(
       MultiFieldRelevanceFunctionContext ctx) {
-    return new Function(
-        ctx.multiFieldRelevanceFunctionName().getText().toLowerCase(),
-        multiFieldRelevanceArguments(ctx));
+    // To support alternate syntax for MULTI_MATCH like
+    // 'MULTI_MATCH('query'='query_val', 'fields'='*fields_val')'
+    if ((StringUtils.unquoteText(ctx.multiFieldRelevanceFunctionName().getText().toUpperCase())
+            .equals(BuiltinFunctionName.MULTI_MATCH.toString())
+        || StringUtils.unquoteText(ctx.multiFieldRelevanceFunctionName().getText().toUpperCase())
+            .equals(BuiltinFunctionName.MULTIMATCH.toString())
+        || StringUtils.unquoteText(ctx.multiFieldRelevanceFunctionName().getText().toUpperCase())
+            .equals(BuiltinFunctionName.MULTIMATCHQUERY.toString()))
+        && ! ctx.getRuleContexts(OpenSearchSQLParser.AlternateMultiMatchQueryFieldContext.class)
+        .isEmpty()) {
+      return new Function(
+          ctx.multiFieldRelevanceFunctionName().getText().toLowerCase(),
+          alternateMultiMatchArguments(ctx));
+    } else {
+      return new Function(
+          ctx.multiFieldRelevanceFunctionName().getText().toLowerCase(),
+          multiFieldRelevanceArguments(ctx));
+    }
   }
 
   private Function visitFunction(String functionName, FunctionArgsContext args) {
@@ -487,4 +504,54 @@ private List<UnresolvedExpression> multiFieldRelevanceArguments(
     fillRelevanceArgs(ctx.relevanceArg(), builder);
     return builder.build();
   }
+
+  /**
+   * Adds support for multi_match alternate syntax like
+   * MULTI_MATCH('query'='Dale', 'fields'='*name').
+   * @param ctx : Context for multi field relevance function.
+   * @return : Returns list of all arguments for relevance function.
+   */
+  private List<UnresolvedExpression> alternateMultiMatchArguments(
+      OpenSearchSQLParser.MultiFieldRelevanceFunctionContext ctx) {
+    // all the arguments are defaulted to string values
+    // to skip environment resolving and function signature resolving
+    ImmutableList.Builder<UnresolvedExpression> builder = ImmutableList.builder();
+    String fields = "";
+    String query = "";
+    for (var arg : ctx.getRuleContexts(
+        OpenSearchSQLParser.AlternateMultiMatchQueryFieldContext.class)) {
+      switch (StringUtils.unquoteText(arg.argName.getText())) {
+        case "query":
+          query = StringUtils.unquoteText(arg.argVal.getText());
+          break;
+
+        case "fields":
+          fields = StringUtils.unquoteText(arg.argVal.getText());
+          break;
+
+        default:
+          throw new SemanticCheckException(
+              String.format("can't resolve argument %s for %s",
+                  StringUtils.unquoteText(arg.argName.getText()),
+                  StringUtils.unquoteText(ctx.multiFieldRelevanceFunctionName().getText()))
+          );
+      }
+    }
+
+    builder.add(new UnresolvedArgument("fields",
+        new RelevanceFieldList(ImmutableMap.of(fields, 1F))));
+    builder.add(new UnresolvedArgument("query",
+        new Literal(query, DataType.STRING)));
+
+    // To support old syntax we must support argument keys as quoted strings.
+    ctx.getRuleContexts(OpenSearchSQLParser.AlternateMultiMatchOptionalArgContext.class)
+        .forEach(v -> builder.add(v.relevanceArg() != null
+            ? new UnresolvedArgument(v.relevanceArg().relevanceArgName().getText().toLowerCase(),
+                new Literal(StringUtils.unquoteText(v.relevanceArg().relevanceArgValue().getText()),
+                    DataType.STRING))
+            : new UnresolvedArgument(StringUtils.unquoteText(v.argName.getText()).toLowerCase(),
+                new Literal(StringUtils.unquoteText(v.argVal.getText()), DataType.STRING))));
+
+    return builder.build();
+  }
 }
diff --git a/sql/src/test/java/org/opensearch/sql/sql/antlr/SQLSyntaxParserTest.java b/sql/src/test/java/org/opensearch/sql/sql/antlr/SQLSyntaxParserTest.java
@@ -193,6 +193,12 @@ public void can_parse_now_like_functions(String name, Boolean hasFsp, Boolean ha
 
   @Test
   public void can_parse_multi_match_relevance_function() {
+    assertNotNull(parser.parse(
+        "SELECT id FROM test WHERE multi_match(\"fields\"=\"field\", \"query\"=\"query\")"));
+    assertNotNull(parser.parse(
+        "SELECT id FROM test WHERE multi_match(\'fields\'=\'field\', \'query\'=\'query\')"));
+    assertNotNull(parser.parse(
+        "SELECT id FROM test WHERE multi_match(fields=\'field\', query=\'query\')"));
     assertNotNull(parser.parse(
         "SELECT id FROM test WHERE multi_match(['address'], 'query')"));
     assertNotNull(parser.parse(
diff --git a/sql/src/test/java/org/opensearch/sql/sql/parser/AstExpressionBuilderTest.java b/sql/src/test/java/org/opensearch/sql/sql/parser/AstExpressionBuilderTest.java
