Refactor calcite adapter create with utility methods

Signed-off-by: Chen Dai <daichen@amazon.com>

Author: dai-chen

api/src/main/java/org/opensearch/sql/api/function/UnifiedFunction.java

@@ -13,8 +13,9 @@
  * functions, enabling functions to be implemented once and used across multiple execution engines
  * without engine-specific code duplication.
  *
- * <p>Types are represented as SQL type name strings (e.g., "VARCHAR", "INTEGER", "ARRAY&lt;T&gt;",
- * "STRUCT&lt;...&gt;") for engine-agnostic serialization.
+ * <p>Note: types are represented as engine-agnostic SQL type name strings (e.g., {@code "VARCHAR"},
+ * {@code "INTEGER"}, {@code "ARRAY<T>"}, {@code "STRUCT<...>"}) to avoid introducing a dedicated
+ * {@code UnifiedType} abstraction until it’s needed.
  *
  * @see java.io.Serializable
  */
@@ -23,29 +24,29 @@ public interface UnifiedFunction extends Serializable {
   /**
    * Returns the name of the function.
    *
-   * @return the function name.
+   * @return the function name
    */
   String getFunctionName();
 
   /**
    * Returns the unified type names expected for the input arguments.
    *
-   * @return list of SQL type names for input arguments.
+   * @return list of unified type names for input arguments
    */
   List<String> getInputTypes();
 
   /**
    * Returns the unified type name of the function result.
    *
-   * @return unified type name of the function result.
+   * @return unified type name of the function result
    */
   String getReturnType();
 
   /**
    * Evaluates the function with the provided input values.
    *
-   * @param inputs argument values evaluated by the caller.
-   * @return the evaluated result, may be null depending on the function implementation.
+   * @param inputs argument values evaluated by the caller
+   * @return the evaluated result, may be null depending on the function implementation
    */
   Object eval(List<Object> inputs);
 }

api/src/main/java/org/opensearch/sql/api/function/UnifiedFunctionCalciteAdapter.java

@@ -60,47 +60,59 @@ public class UnifiedFunctionCalciteAdapter implements UnifiedFunction {
    */
   private final String compiledCode;
 
+  @Override
+  public Object eval(List<Object> inputs) {
+    RexExecutable rexExecutor = new RexExecutable(compiledCode, functionName);
+    DataContext dataContext = DataContexts.of(Map.of(INPUT_RECORD_KEY, inputs.toArray()));
+    rexExecutor.setDataContext(dataContext);
+
+    Object[] results = rexExecutor.execute();
+    return (results == null || results.length == 0) ? null : results[0];
+  }
+
   /**
    * Creates Calcite RexNode adapter for a unified function.
    *
-   * <p>Note this method pre-compiles the resolved function expression and stores the generated
+   * <p>Note: this method pre-compiles the resolved function expression and stores the generated
    * source code as a string. This avoids serializing {@link RexNode} instances and simplifies
    * distribution across execution engines. If performance or security concerns arise, we can change
    * this internal implementation.
    *
    * @param rexBuilder RexBuilder for creating expressions
-   * @param functionName function name (e.g., "UPPER", "CONCAT", "ABS")
-   * @param inputTypeNames function argument types as SQL type names (e.g., "VARCHAR", "INTEGER")
+   * @param functionName function name
+   * @param inputTypes function argument types
    * @return configured adapter instance
    */
   public static UnifiedFunctionCalciteAdapter create(
-      RexBuilder rexBuilder, String functionName, List<String> inputTypeNames) {
-    RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory();
-    RelDataTypeFactory.Builder rowTypeBuilder = typeFactory.builder();
-    RexNode[] inputRefs = new RexNode[inputTypeNames.size()];
-    for (int i = 0; i < inputTypeNames.size(); i++) {
-      SqlTypeName sqlType = SqlTypeName.valueOf(inputTypeNames.get(i));
-      RelDataType relType = typeFactory.createSqlType(sqlType);
-      rowTypeBuilder.add("_" + i, relType);
-      inputRefs[i] = rexBuilder.makeInputRef(relType, i);
-    }
-
-    RelDataType inputRowType = rowTypeBuilder.build();
+      RexBuilder rexBuilder, String functionName, List<String> inputTypes) {
+    RexNode[] inputRefs = makeInputRefs(rexBuilder, inputTypes);
     RexNode resolved = PPLFuncImpTable.INSTANCE.resolve(rexBuilder, functionName, inputRefs);
+    RelDataType inputRowType = buildInputRowType(rexBuilder, inputTypes);
     RexExecutable executable =
         RexExecutorImpl.getExecutable(rexBuilder, List.of(resolved), inputRowType);
-    String returnTypeName = resolved.getType().getSqlTypeName().getName();
+    String returnType = resolved.getType().getSqlTypeName().getName();
+
     return new UnifiedFunctionCalciteAdapter(
-        functionName, returnTypeName, List.copyOf(inputTypeNames), executable.getSource());
+        functionName, returnType, List.copyOf(inputTypes), executable.getSource());
   }
 
-  @Override
-  public Object eval(List<Object> inputs) {
-    RexExecutable rexExecutor = new RexExecutable(compiledCode, functionName);
-    DataContext dataContext = DataContexts.of(Map.of(INPUT_RECORD_KEY, inputs.toArray()));
-    rexExecutor.setDataContext(dataContext);
+  private static RelDataType buildInputRowType(RexBuilder rexBuilder, List<String> inputTypes) {
+    RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory();
+    RelDataTypeFactory.Builder builder = typeFactory.builder();
+    for (int i = 0; i < inputTypes.size(); i++) {
+      RelDataType relType = typeFactory.createSqlType(SqlTypeName.valueOf(inputTypes.get(i)));
+      builder.add("_" + i, relType);
+    }
+    return builder.build();
+  }
 
-    Object[] results = rexExecutor.execute();
-    return (results == null || results.length == 0) ? null : results[0];
+  private static RexNode[] makeInputRefs(RexBuilder rexBuilder, List<String> inputTypes) {
+    RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory();
+    RexNode[] inputRefs = new RexNode[inputTypes.size()];
+    for (int i = 0; i < inputTypes.size(); i++) {
+      RelDataType relType = typeFactory.createSqlType(SqlTypeName.valueOf(inputTypes.get(i)));
+      inputRefs[i] = rexBuilder.makeInputRef(relType, i);
+    }
+    return inputRefs;
   }
 }

api/src/main/java/org/opensearch/sql/api/function/UnifiedFunctionRepository.java

@@ -36,9 +36,8 @@ public List<UnifiedFunctionDescriptor> loadFunctions() {
             operator -> {
               String functionName = operator.getName();
               UnifiedFunctionBuilder builder =
-                  inputTypeNames ->
-                      UnifiedFunctionCalciteAdapter.create(
-                          rexBuilder, functionName, inputTypeNames);
+                  inputTypes ->
+                      UnifiedFunctionCalciteAdapter.create(rexBuilder, functionName, inputTypes);
               return new UnifiedFunctionDescriptor(functionName, builder);
             })
         .collect(Collectors.toList());
@@ -73,7 +72,7 @@ public interface UnifiedFunctionBuilder extends Serializable {
     /**
      * Builds a {@link UnifiedFunction} instance for the specified input types.
      *
-     * @param inputTypes SQL type names for function arguments (e.g., ["VARCHAR", "INTEGER"])
+     * @param inputTypes Unified type names for function arguments
      * @return a UnifiedFunction instance configured for the specified input types
      */
     UnifiedFunction build(List<String> inputTypes);