Validating field and fields parameters in TypeEnv as part of Expressi…

…onAnalyzer.

Signed-off-by: forestmvey <[email protected]>

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

@@ -75,7 +75,6 @@
 import org.opensearch.sql.expression.aggregation.NamedAggregator;
 import org.opensearch.sql.expression.function.BuiltinFunctionRepository;
 import org.opensearch.sql.expression.function.FunctionName;
-import org.opensearch.sql.expression.function.OpenSearchFunctions;
 import org.opensearch.sql.expression.function.TableFunctionImplementation;
 import org.opensearch.sql.expression.parse.ParseExpression;
 import org.opensearch.sql.planner.logical.LogicalAD;
@@ -221,10 +220,6 @@ public LogicalPlan visitFilter(Filter node, AnalysisContext context) {
     LogicalPlan child = node.getChild().get(0).accept(this, context);
     Expression condition = expressionAnalyzer.analyze(node.getCondition(), context);
 
-    if (condition instanceof OpenSearchFunctions.OpenSearchFunction) {
-      ((OpenSearchFunctions.OpenSearchFunction)condition).validateParameters(context);
-    }
-
     ExpressionReferenceOptimizer optimizer =
         new ExpressionReferenceOptimizer(expressionAnalyzer.getRepository(), child);
     Expression optimized = optimizer.optimize(condition, context);

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

@@ -11,7 +11,6 @@
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.ToString;
-import org.opensearch.sql.analysis.AnalysisContext;
 import org.opensearch.sql.expression.function.FunctionImplementation;
 import org.opensearch.sql.expression.function.FunctionName;
 
@@ -33,11 +32,4 @@ public <T, C> T accept(ExpressionNodeVisitor<T, C> visitor, C context) {
     return visitor.visitFunction(this, context);
   }
 
-  /**
-   * Verify if function queries fields available in type environment.
-   * @param context : Context of fields querying.
-   */
-  public void validateParameters(AnalysisContext context) {
-    return;
-  }
 }

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

@@ -5,17 +5,9 @@
 
 package org.opensearch.sql.expression.function;
 
-import static org.opensearch.sql.data.type.ExprCoreType.STRING;
-import static org.opensearch.sql.data.type.ExprCoreType.STRUCT;
-
 import java.util.List;
 import java.util.stream.Collectors;
 import lombok.experimental.UtilityClass;
-import org.opensearch.sql.analysis.AnalysisContext;
-import org.opensearch.sql.analysis.TypeEnvironment;
-import org.opensearch.sql.analysis.symbol.Namespace;
-import org.opensearch.sql.analysis.symbol.Symbol;
-import org.opensearch.sql.common.utils.StringUtils;
 import org.opensearch.sql.data.model.ExprValue;
 import org.opensearch.sql.data.type.ExprCoreType;
 import org.opensearch.sql.data.type.ExprType;
@@ -26,37 +18,6 @@
 
 @UtilityClass
 public class OpenSearchFunctions {
-  private final List<String> singleFieldFunctionNames = List.of(
-      BuiltinFunctionName.MATCH.name(),
-      BuiltinFunctionName.MATCH_BOOL_PREFIX.name(),
-      BuiltinFunctionName.MATCHPHRASE.name(),
-      BuiltinFunctionName.MATCH_PHRASE_PREFIX.name()
-  );
-
-  private final List<String> multiFieldFunctionNames = List.of(
-      BuiltinFunctionName.MULTI_MATCH.name(),
-      BuiltinFunctionName.SIMPLE_QUERY_STRING.name(),
-      BuiltinFunctionName.QUERY_STRING.name()
-  );
-
-  /**
-   * Check if supplied function name is valid SingleFieldRelevanceFunction.
-   * @param funcName : Name of function
-   * @return : True if function is single-field function
-   */
-  public static boolean isSingleFieldFunction(String funcName) {
-    return singleFieldFunctionNames.contains(funcName.toUpperCase());
-  }
-
-  /**
-   * Check if supplied function name is valid MultiFieldRelevanceFunction.
-   * @param funcName : Name of function
-   * @return : True if function is multi-field function
-   */
-  public static boolean isMultiFieldFunction(String funcName) {
-    return multiFieldFunctionNames.contains(funcName.toUpperCase());
-  }
-
   /**
    * Add functions specific to OpenSearch to repository.
    */
@@ -83,46 +44,46 @@ public void register(BuiltinFunctionRepository repository) {
 
   private static FunctionResolver match_bool_prefix() {
     FunctionName name = BuiltinFunctionName.MATCH_BOOL_PREFIX.getName();
-    return new RelevanceFunctionResolver(name, STRING);
+    return new RelevanceFunctionResolver(name);
   }
 
   private static FunctionResolver match(BuiltinFunctionName match) {
     FunctionName funcName = match.getName();
-    return new RelevanceFunctionResolver(funcName, STRING);
+    return new RelevanceFunctionResolver(funcName);
   }
 
   private static FunctionResolver match_phrase_prefix() {
     FunctionName funcName = BuiltinFunctionName.MATCH_PHRASE_PREFIX.getName();
-    return new RelevanceFunctionResolver(funcName, STRING);
+    return new RelevanceFunctionResolver(funcName);
   }
 
   private static FunctionResolver match_phrase(BuiltinFunctionName matchPhrase) {
     FunctionName funcName = matchPhrase.getName();
-    return new RelevanceFunctionResolver(funcName, STRING);
+    return new RelevanceFunctionResolver(funcName);
   }
 
   private static FunctionResolver multi_match(BuiltinFunctionName multiMatchName) {
-    return new RelevanceFunctionResolver(multiMatchName.getName(), STRUCT);
+    return new RelevanceFunctionResolver(multiMatchName.getName());
   }
 
   private static FunctionResolver simple_query_string() {
     FunctionName funcName = BuiltinFunctionName.SIMPLE_QUERY_STRING.getName();
-    return new RelevanceFunctionResolver(funcName, STRUCT);
+    return new RelevanceFunctionResolver(funcName);
   }
 
   private static FunctionResolver query() {
     FunctionName funcName = BuiltinFunctionName.QUERY.getName();
-    return new RelevanceFunctionResolver(funcName, STRING);
+    return new RelevanceFunctionResolver(funcName);
   }
 
   private static FunctionResolver query_string() {
     FunctionName funcName = BuiltinFunctionName.QUERY_STRING.getName();
-    return new RelevanceFunctionResolver(funcName, STRUCT);
+    return new RelevanceFunctionResolver(funcName);
   }
 
   private static FunctionResolver wildcard_query(BuiltinFunctionName wildcardQuery) {
     FunctionName funcName = wildcardQuery.getName();
-    return new RelevanceFunctionResolver(funcName, STRING);
+    return new RelevanceFunctionResolver(funcName);
   }
 
   public static class OpenSearchFunction extends FunctionExpression {
@@ -160,35 +121,5 @@ public String toString() {
           .collect(Collectors.toList());
       return String.format("%s(%s)", functionName, String.join(", ", args));
     }
-
-    /**
-     * Verify if function queries fields available in type environment.
-     * @param context : Context of fields querying.
-     */
-    @Override
-    public void validateParameters(AnalysisContext context) {
-      String funcName = this.getFunctionName().toString();
-
-      TypeEnvironment typeEnv = context.peek();
-      if (isSingleFieldFunction(funcName)) {
-        this.getArguments().stream().map(NamedArgumentExpression.class::cast).filter(arg ->
-            ((arg.getArgName().equals("field")
-                && !arg.getValue().toString().contains("*"))
-            )).findFirst().ifPresent(arg ->
-            typeEnv.resolve(new Symbol(Namespace.FIELD_NAME,
-                StringUtils.unquoteText(arg.getValue().toString()))
-            )
-        );
-      } else if (isMultiFieldFunction(funcName)) {
-        this.getArguments().stream().map(NamedArgumentExpression.class::cast).filter(arg ->
-            arg.getArgName().equals("fields")
-        ).findFirst().ifPresent(fields ->
-            fields.getValue().valueOf(null).tupleValue()
-                .entrySet().stream().filter(k -> !(k.getKey().contains("*"))
-                ).forEach(key -> typeEnv.resolve(new Symbol(Namespace.FIELD_NAME, key.getKey())))
-        );
-      }
-    }
-
   }
 }

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

@@ -20,24 +20,13 @@ public class RelevanceFunctionResolver
   @Getter
   private final FunctionName functionName;
 
-  @Getter
-  private final ExprType declaredFirstParamType;
-
   @Override
   public Pair<FunctionSignature, FunctionBuilder> resolve(FunctionSignature unresolvedSignature) {
     if (!unresolvedSignature.getFunctionName().equals(functionName)) {
       throw new SemanticCheckException(String.format("Expected '%s' but got '%s'",
           functionName.getFunctionName(), unresolvedSignature.getFunctionName().getFunctionName()));
     }
     List<ExprType> paramTypes = unresolvedSignature.getParamTypeList();
-    ExprType providedFirstParamType = paramTypes.get(0);
-
-    // Check if the first parameter is of the specified type.
-    if (!declaredFirstParamType.equals(providedFirstParamType)) {
-      throw new SemanticCheckException(
-          getWrongParameterErrorMessage(0, providedFirstParamType, declaredFirstParamType));
-    }
-
     // Check if all but the first parameter are of type STRING.
     for (int i = 1; i < paramTypes.size(); i++) {
       ExprType paramType = paramTypes.get(i);