address comments

Author: yliuuuu

partiql-eval/src/main/kotlin/org/partiql/eval/internal/Compiler.kt

@@ -161,9 +161,8 @@ internal class Compiler(
         val args = node.args.map { visitRex(it, ctx).modeHandled() }.toTypedArray()
         val candidates = node.candidates.map { candidate ->
             val fn = symbols.getFn(candidate.fn)
-            val types = fn.signature.parameters.map { it.type }.toTypedArray()
             val coercions = candidate.coercions.toTypedArray()
-            ExprCallDynamic.Candidate(fn, types, coercions)
+            ExprCallDynamic.Candidate(fn, coercions)
         }
         return ExprCallDynamic(candidates, args)
     }

partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rex/ExprCallDynamic.kt

@@ -44,10 +44,11 @@ internal class ExprCallDynamic(
      */
     internal class Candidate(
         val fn: Fn,
-        val types: Array<PartiQLValueType>,
         val coercions: Array<Ref.Cast?>
     ) {
 
+        private val signatureParameters = fn.signature.parameters.map { it.type }.toTypedArray()
+
         fun eval(originalArgs: Array<PartiQLValue>): PartiQLValue {
             val args = originalArgs.mapIndexed { i, arg ->
                 when (val c = coercions[i]) {
@@ -58,17 +59,27 @@ internal class ExprCallDynamic(
             return fn.invoke(args)
         }
 
-        internal fun matches(args: Array<PartiQLValue>): Boolean {
-            for (i in args.indices) {
-                if (types[i] == PartiQLValueType.ANY) {
-                    return true
-                }
-                if (args[i].type != types[i]) {
-                    val c = coercions[i]
-                    when {
-                        c == null -> return false
-                        c.input != args[i].type -> return false
-                        c.target != types[i] -> return false
+        internal fun matches(inputs: Array<PartiQLValue>): Boolean {
+            for (i in inputs.indices) {
+                val inputType = inputs[i].type
+                val parameterType = signatureParameters[i]
+                val c = coercions[i]
+                when (c) {
+                    // coercion might be null if one of the following is true
+                    // Function parameter is ANY,
+                    // Input type is null
+                    // input type is the same as function parameter
+                    null -> {
+                        if (!(inputType == parameterType || inputType == PartiQLValueType.NULL || parameterType == PartiQLValueType.ANY)) {
+                            return false
+                        }
+                    }
+                    else -> {
+                        // checking the input type is expected by the coercion
+                        if (inputType != c.input) return false
+                        // checking the result is expected by the function signature
+                        // this should branch should never be reached, but leave it here for clarity
+                        if (c.target != parameterType) return false
                     }
                 }
             }

test/partiql-tests-runner/src/test/kotlin/org/partiql/runner/executor/EvalExecutor.kt

@@ -84,6 +84,11 @@ class EvalExecutor(
         if (v1.isNull && v2.isNull) {
             return true
         }
+        // TODO: this comparator is designed for order by
+        //  One of the false result it might produce is that
+        //  it treats MISSING and NULL equally.
+        //  we should move to hash or equals in value class once
+        //  we finished implementing those.
         if (comparator.compare(v1, v2) == 0) {
             return true
         }