fix tests

amorynan · Dec 14, 2023 · 331968e · 331968e
1 parent 054be24
commit 331968e
Show file tree

Hide file tree

Showing 3 changed files with 58 additions and 10 deletions.
diff --git a/fe/fe-core/src/main/java/org/apache/doris/analysis/FunctionCallExpr.java b/fe/fe-core/src/main/java/org/apache/doris/analysis/FunctionCallExpr.java
@@ -1878,6 +1878,8 @@ && collectChildReturnTypes()[0].isDecimalV3()) {
                         || (children.get(0).getType().isDecimalV2()
                         && ((ArrayType) args[ix]).getItemType().isDecimalV2()))) {
                     continue;
+                } else if (fnName.getFunction().equalsIgnoreCase("array_zip")) {
+                    continue;
                 } else if ((fnName.getFunction().equalsIgnoreCase("array")
                         || fnName.getFunction().equalsIgnoreCase("array_distinct")
                         || fnName.getFunction().equalsIgnoreCase("array_remove")

diff --git a/fe/fe-core/src/main/java/org/apache/doris/catalog/FunctionSet.java b/fe/fe-core/src/main/java/org/apache/doris/catalog/FunctionSet.java
@@ -392,8 +392,20 @@ public Function specializeTemplateFunction(Function templateFunction, Function r
             for (int i = 0; i < args.length; i++) {
                 if (args[i].hasTemplateType()) {
                     hasTemplateType = true;
-                    args[i] = args[i].specializeTemplateType(requestFunction.getArgs()[i], specializedTypeMap, false,
-                            enableDecimal256);
+                    // if args[i] is template type, and requestFunction.getArgs()[i] NULL_TYPE, we need call function
+                    // deduce to get the specific type
+                    Type deduceType = requestFunction.getArgs()[i];
+                    if (requestFunction.getArgs()[i].isNull()
+                            || (requestFunction.getArgs()[i] instanceof ArrayType
+                            && ((ArrayType) requestFunction.getArgs()[i]).getItemType().isNull()
+                            && FunctionTypeDeducers.DEDUCERS.containsKey(specializedFunction.functionName()))) {
+                        deduceType = FunctionTypeDeducers.deduce(specializedFunction.functionName(), i, requestFunction.getArgs());
+                        args[i] = args[i].specializeTemplateType(deduceType == null ? requestFunction.getArgs()[i]
+                            : deduceType, specializedTypeMap, false, enableDecimal256);
+                    } else {
+                        args[i] = args[i].specializeTemplateType(requestFunction.getArgs()[i],
+                                specializedTypeMap, false, enableDecimal256);
+                    }
                 }
             }
             if (specializedFunction.getReturnType().hasTemplateType()) {
@@ -426,7 +438,7 @@ public Function resolveInferenceFunction(Function inferenceFunction, Function re
                 newTypes[i] = inputType;
             }
         }
-        Type newRetType = FunctionTypeDeducers.deduce(inferenceFunction.functionName(), newTypes);
+        Type newRetType = FunctionTypeDeducers.deduce(inferenceFunction.functionName(), 0, newTypes);
         if (newRetType != null && inferenceFunction instanceof ScalarFunction) {
             ScalarFunction f = (ScalarFunction) inferenceFunction;
             return new ScalarFunction(f.getFunctionName(), Lists.newArrayList(newTypes), newRetType, f.hasVarArgs(),
@@ -448,7 +460,20 @@ public static boolean isCastMatchAllowed(Function desc, Function candicate) {
         final Type[] candicateArgTypes = candicate.getArgs();
         if (!(descArgTypes[0] instanceof ScalarType)
                 || !(candicateArgTypes[0] instanceof ScalarType)) {
-            if (candicateArgTypes[0] instanceof ArrayType || candicateArgTypes[0] instanceof MapType) {
+            if (candicateArgTypes[0] instanceof ArrayType) {
+                // match is exactly type. but for null type , with in array|map elem can not return true, because for
+                // be will make null_type to uint8
+                // so here meet null_type just make true as allowed, descArgTypes[0]).getItemType().isNull() is for
+                // empty literal like: []|{}
+                if (descArgTypes[0] instanceof ArrayType && ((ArrayType) descArgTypes[0]).getItemType().isNull()) {
+                    return true;
+                }
+                return descArgTypes[0].matchesType(candicateArgTypes[0]);
+            } else if (candicateArgTypes[0] instanceof MapType) {
+                if (descArgTypes[0] instanceof MapType && ((MapType) descArgTypes[0]).getKeyType().isNull()
+                        && ((MapType) descArgTypes[0]).getValueType().isNull()) {
+                    return true;
+                }
                 return descArgTypes[0].matchesType(candicateArgTypes[0]);
             }
             return false;

diff --git a/fe/fe-core/src/main/java/org/apache/doris/catalog/FunctionTypeDeducers.java b/fe/fe-core/src/main/java/org/apache/doris/catalog/FunctionTypeDeducers.java
@@ -23,26 +23,47 @@
 import java.util.List;
 
 public class FunctionTypeDeducers {
-
     public interface TypeDeducer {
-        public Type deduce(Type[] args);
+        public Type deduce(int argIdx, Type[] args);
     }
 
     public static final ImmutableMap<String, TypeDeducer> DEDUCERS = ImmutableMap.<String, TypeDeducer>builder()
             .put("named_struct", new NamedStructDeducer())
             .put("struct_element", new StructElementDeducer())
+            .put("array_contains", new ArrayElemFuncDeducer())
+            .put("element_at", new ArrayElemFuncDeducer())
             .build();
 
-    public static Type deduce(String fnName, Type[] args) {
+    public static Type deduce(String fnName, int argIdx, Type[] args) {
         if (DEDUCERS.containsKey(fnName)) {
-            return DEDUCERS.get(fnName).deduce(args);
+            return DEDUCERS.get(fnName).deduce(argIdx, args);
         }
         return null;
     }
 
+    public static class ArrayElemFuncDeducer implements TypeDeducer {
+        @Override
+        public Type deduce(int argIdx, Type[] args) {
+            if (args.length >= 2) {
+                if (argIdx == 0) {
+                    // first args should only to be array or null
+                    return args[0] instanceof ArrayType || args[0].isNull() ? new ArrayType(args[1]) : args[0];
+                } else if (args[0].isNull()) {
+                    // first arg is null, later element is not contains
+                    return args[argIdx];
+                } else if (Type.isImplicitlyCastable(args[argIdx], ((ArrayType) args[0]).getItemType(), false, true)) {
+                    return args[argIdx];
+                } else {
+                    return null;
+                }
+            }
+            return null;
+        }
+    }
+
     public static class NamedStructDeducer implements TypeDeducer {
         @Override
-        public Type deduce(Type[] args) {
+        public Type deduce(int argIdx, Type[] args) {
             List<Type> evenArgs = Lists.newArrayList();
             for (int i = 0; i < args.length; i++) {
                 if ((i & 1) == 1) {
@@ -55,7 +76,7 @@ public Type deduce(Type[] args) {
 
     public static class StructElementDeducer implements TypeDeducer {
         @Override
-        public Type deduce(Type[] args) {
+        public Type deduce(int argIdx, Type[] args) {
             if (args[0] instanceof StructType) {
                 return Type.ANY_ELEMENT_TYPE;
             }