add utils to change typeToVariable in functions

Author: pdabre12

presto-main/src/main/java/com/facebook/presto/metadata/FunctionAndTypeManager.java

@@ -234,6 +234,12 @@ public SqlFunctionSupplier getSpecializedFunctionKey(Signature signature)
                 return FunctionAndTypeManager.this.getSpecializedFunctionKey(signature);
             }
 
+            @Override
+            public List<Type> getTypes()
+            {
+                return FunctionAndTypeManager.this.getTypes();
+            }
+
             @Override
             public Collection<SqlFunction> listBuiltInFunctions()
             {
@@ -524,6 +530,7 @@ public void addUserDefinedType(UserDefinedType userDefinedType)
         functionNamespaceManager.get().addUserDefinedType(userDefinedType);
     }
 
+    @Override
     public List<Type> getTypes()
     {
         return builtInTypeAndFunctionNamespaceManager.getTypes();

presto-native-sidecar-plugin/src/main/java/com/facebook/presto/sidecar/functionNamespace/NativeFunctionNamespaceManager.java

@@ -16,6 +16,7 @@
 import com.facebook.airlift.log.Logger;
 import com.facebook.presto.common.CatalogSchemaName;
 import com.facebook.presto.common.QualifiedObjectName;
+import com.facebook.presto.common.type.NamedTypeSignature;
 import com.facebook.presto.common.type.Type;
 import com.facebook.presto.common.type.TypeManager;
 import com.facebook.presto.common.type.TypeSignature;
@@ -91,6 +92,7 @@ public class NativeFunctionNamespaceManager
     private final Supplier<Map<SqlFunctionId, SqlInvokedFunction>> memoizedFunctionsSupplier;
     private final FunctionMetadataManager functionMetadataManager;
     private final LoadingCache<Signature, SqlFunctionSupplier> specializedFunctionKeyCache;
+    private final List<Type> types;
 
     @Inject
     public NativeFunctionNamespaceManager(
@@ -111,6 +113,7 @@ public NativeFunctionNamespaceManager(
                 .maximumSize(1000)
                 .expireAfterWrite(1, HOURS)
                 .build(CacheLoader.from(this::doGetSpecializedFunctionKey));
+        this.types = functionMetadataManager.getTypes();
     }
 
     private SqlFunctionSupplier doGetSpecializedFunctionKey(Signature signature)
@@ -221,20 +224,8 @@ protected SqlInvokedFunction createSqlInvokedFunction(String functionName, JsonB
         List<TypeVariableConstraint> typeVariableConstraintsList = jsonBasedUdfFunctionMetaData.getTypeVariableConstraints().isPresent() ?
                 jsonBasedUdfFunctionMetaData.getTypeVariableConstraints().get() : Collections.emptyList();
 
-        if (functionName.equals("approx_distinct")) {
-            List<TypeSignature> newParameterTypeList = new ArrayList<>();
-            for (int j = 0; j < parameterNameList.size(); j++) {
-                if (parameterTypeList.get(j).getTypeSignatureBase().getStandardTypeBase().startsWith("decimal") || parameterTypeList.get(j).getTypeSignatureBase().getStandardTypeBase().startsWith("DECIMAL")) {
-                    List<TypeSignature> paramtersList = parameterTypeList.get(j).getTypeParametersAsTypeSignatures();
-                    newParameterTypeList.add(new TypeSignature(
-                            "decimal", TypeSignatureParameter.of(paramtersList.get(0).getBase()), TypeSignatureParameter.of(paramtersList.get(1).getBase())));
-                }
-                else {
-                    newParameterTypeList.add(parameterTypeList.get(j));
-                }
-            }
-            parameterTypeList = newParameterTypeList;
-        }
+        TypeSignature outputType = helperTypeSignature(jsonBasedUdfFunctionMetaData.getOutputType(), types);
+        parameterTypeList = helperTypeSignatureList(parameterTypeList, types);
 
         ImmutableList.Builder<Parameter> parameterBuilder = ImmutableList.builder();
         for (int i = 0; i < parameterNameList.size(); i++) {
@@ -256,7 +247,7 @@ protected SqlInvokedFunction createSqlInvokedFunction(String functionName, JsonB
                 qualifiedFunctionName,
                 parameterBuilder.build(),
                 typeVariableConstraintsBuilder.build(),
-                jsonBasedUdfFunctionMetaData.getOutputType(),
+                outputType,
                 jsonBasedUdfFunctionMetaData.getDocString(),
                 jsonBasedUdfFunctionMetaData.getRoutineCharacteristics(),
                 "",
@@ -360,6 +351,94 @@ public final FunctionHandle getFunctionHandle(Optional<? extends FunctionNamespa
         return functionHandle;
     }
 
+    public static TypeSignature helperTypeSignature(TypeSignature typeSignature, List<Type> types)
+    {
+        List<TypeSignature> typeSignatureList = helperTypeSignatureList(ImmutableList.of(typeSignature), types);
+        checkArgument(!typeSignatureList.isEmpty(), "Type signature list is empty for : " + typeSignature);
+        return typeSignatureList.get(0);
+    }
+
+    public static List<TypeSignature> helperTypeSignatureList(List<TypeSignature> typeSignatures, List<Type> types)
+    {
+        List<TypeSignature> newTypeSignaturesList = new ArrayList<>();
+        for (TypeSignature typeSignature : typeSignatures) {
+            if (!typeSignature.getParameters().isEmpty()) {
+                TypeSignature newTypeSignature =
+                        new TypeSignature(
+                                typeSignature.getBase(),
+                                getAccurateTypeSignatureParameterKindLists(
+                                        typeSignature.getParameters(), types));
+                newTypeSignaturesList.add(newTypeSignature);
+            }
+            else {
+                newTypeSignaturesList.add(typeSignature);
+            }
+        }
+        return newTypeSignaturesList;
+    }
+
+    private static List<TypeSignatureParameter> getAccurateTypeSignatureParameterKindLists(List<TypeSignatureParameter> typeSignatureParameterList, List<Type> types)
+    {
+        List<TypeSignatureParameter> newParameterTypeList = new ArrayList<>();
+        for (TypeSignatureParameter parameter : typeSignatureParameterList) {
+            if (parameter.isLongLiteral()) {
+                newParameterTypeList.add(parameter);
+                continue;
+            }
+
+            boolean isNamedTypeSignature = parameter.isNamedTypeSignature();
+            TypeSignature parameterTypeSignature;
+            // If it's a named type signatures only in the case of row signature types.
+            if (isNamedTypeSignature) {
+                parameterTypeSignature = parameter.getNamedTypeSignature().getTypeSignature();
+            }
+            else {
+                parameterTypeSignature = parameter.getTypeSignature();
+            }
+
+            if (parameterTypeSignature.getParameters().isEmpty()) {
+                boolean changeTypeToVariable = helperFunctions(parameterTypeSignature, types);
+                if (changeTypeToVariable) {
+                    newParameterTypeList.add(
+                            TypeSignatureParameter.of(parameterTypeSignature.getBase()));
+                }
+                else {
+                    if (isNamedTypeSignature) {
+                        newParameterTypeList.add(TypeSignatureParameter.of(parameter.getNamedTypeSignature()));
+                    }
+                    else {
+                        newParameterTypeList.add(TypeSignatureParameter.of(parameterTypeSignature));
+                    }
+                }
+            }
+            else {
+                TypeSignature typeSignature =
+                        new TypeSignature(
+                                parameterTypeSignature.getBase(),
+                                getAccurateTypeSignatureParameterKindLists(
+                                        parameterTypeSignature.getParameters(), types));
+                if (isNamedTypeSignature) {
+                    newParameterTypeList.add(
+                            TypeSignatureParameter.of(
+                                    new NamedTypeSignature(
+                                            Optional.empty(),
+                                            typeSignature)));
+                }
+                else {
+                    newParameterTypeList.add(TypeSignatureParameter.of(typeSignature));
+                }
+            }
+        }
+        return newParameterTypeList;
+    }
+
+    private static boolean helperFunctions(TypeSignature parameterType, List<Type> types)
+    {
+        return types.stream().noneMatch(key ->
+                key.getTypeSignature().getTypeSignatureBase().getStandardTypeBase()
+                        .equals(parameterType.getStandardTypeSignature().getTypeSignatureBase().getStandardTypeBase()));
+    }
+
     private SqlFunction getSqlFunctionFromSignature(Signature signature)
     {
         SqlFunctionSupplier functionKey;