Partiql eval continue

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

@@ -209,9 +209,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 = candidate.parameters.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

@@ -49,10 +49,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>, env: Environment): PartiQLValue {
             val args = originalArgs.mapIndexed { i, arg ->
                 when (val c = coercions[i]) {
@@ -63,13 +64,28 @@ 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]) {
-                    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) error("Internal Error: Cast Target does not match Function Parameter")
+                    }
                 }
             }
             return true

partiql-planner/src/main/kotlin/org/partiql/planner/internal/FnResolver.kt

@@ -5,6 +5,8 @@ import org.partiql.planner.internal.ir.Ref
 import org.partiql.planner.internal.typer.toRuntimeTypeOrNull
 import org.partiql.spi.fn.FnExperimental
 import org.partiql.spi.fn.FnSignature
+import org.partiql.types.AnyOfType
+import org.partiql.types.NullType
 import org.partiql.types.StaticType
 import org.partiql.value.PartiQLValueExperimental
 import org.partiql.value.PartiQLValueType
@@ -147,7 +149,13 @@ internal object FnResolver {
     }
 
     private fun buildArgumentPermutations(args: List<StaticType>): List<List<StaticType>> {
-        val flattenedArgs = args.map { it.flatten().allTypes }
+        val flattenedArgs = args.map {
+            if (it is AnyOfType) {
+                it.flatten().allTypes.filter { it !is NullType }
+            } else {
+                it.flatten().allTypes
+            }
+        }
         return buildArgumentPermutations(flattenedArgs, accumulator = emptyList())
     }
 

partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt

@@ -538,7 +538,7 @@ internal object RexConverter {
             // Call Variants
             val call = when (arg2) {
                 null -> call("substring", arg0, arg1)
-                else -> call("substring_length", arg0, arg1, arg2)
+                else -> call("substring", arg0, arg1, arg2)
             }
             return rex(type, call)
         }

partiql-planner/src/main/kotlin/org/partiql/planner/internal/typer/TypeUtils.kt

@@ -120,7 +120,10 @@ private fun StaticType.asRuntimeType(): PartiQLValueType = when (this) {
     is ListType -> PartiQLValueType.LIST
     is SexpType -> PartiQLValueType.SEXP
     is DateType -> PartiQLValueType.DATE
-    is DecimalType -> PartiQLValueType.DECIMAL_ARBITRARY
+    is DecimalType -> when (this.precisionScaleConstraint) {
+        is DecimalType.PrecisionScaleConstraint.Constrained -> PartiQLValueType.DECIMAL
+        DecimalType.PrecisionScaleConstraint.Unconstrained -> PartiQLValueType.DECIMAL_ARBITRARY
+    }
     is FloatType -> PartiQLValueType.FLOAT64
     is GraphType -> error("Graph type missing from runtime types")
     is IntType -> when (this.rangeConstraint) {

partiql-types/src/main/kotlin/org/partiql/value/PartiQLValueComparatorInternal.kt

@@ -31,6 +31,7 @@ internal class PartiQLValueComparatorInternal(private val nullsFirst: Boolean) :
         }
 
         when {
+            // TODO: This is EQG-specific behavior. Do we want to leave it as-is in the Value comparator?
             l.isNullOrMissing() && r.isNullOrMissing() -> return EQUAL
             l.isNullOrMissing() -> return when (nullsFirst) {
                 true -> LESS

partiql-types/src/main/kotlin/org/partiql/value/util/NumberExtensions.kt

@@ -41,6 +41,7 @@ internal fun bigDecimalOf(num: Number, mc: MathContext = MATH_CONTEXT): BigDecim
     is Double -> BigDecimal(num, mc)
     is BigInteger -> BigDecimal(num, mc)
     is BigDecimal -> num
+    is BigInteger -> num.toBigDecimal()
     else -> throw IllegalArgumentException("Unsupported number type: $num, ${num.javaClass}")
 }
 
@@ -58,20 +59,23 @@ private val CONVERSION_MAP = mapOf<Set<Class<*>>, Class<out Number>>(
     setOf(Float::class.javaObjectType, Float::class.javaObjectType) to Float::class.javaObjectType,
     // Float w/ Long -> Double
     setOf(Float::class.javaObjectType, Long::class.javaObjectType) to Double::class.javaObjectType,
+    setOf(Float::class.javaObjectType, BigInteger::class.javaObjectType) to Double::class.javaObjectType,
     setOf(Float::class.javaObjectType, Double::class.javaObjectType) to Double::class.javaObjectType,
     setOf(Float::class.javaObjectType, BigDecimal::class.javaObjectType) to BigDecimal::class.javaObjectType,
 
     setOf(Long::class.javaObjectType, Long::class.javaObjectType) to Long::class.javaObjectType,
+    setOf(Long::class.javaObjectType, BigInteger::class.javaObjectType) to BigInteger::class.javaObjectType,
     setOf(Long::class.javaObjectType, Double::class.javaObjectType) to Double::class.javaObjectType,
     setOf(Long::class.javaObjectType, BigDecimal::class.javaObjectType) to BigDecimal::class.javaObjectType,
 
+    setOf(BigInteger::class.javaObjectType, BigInteger::class.javaObjectType) to BigInteger::class.javaObjectType,
     setOf(BigInteger::class.javaObjectType, Double::class.javaObjectType) to Double::class.javaObjectType,
     setOf(BigInteger::class.javaObjectType, BigDecimal::class.javaObjectType) to BigDecimal::class.javaObjectType,
 
     setOf(Double::class.javaObjectType, Double::class.javaObjectType) to Double::class.javaObjectType,
     setOf(Double::class.javaObjectType, BigDecimal::class.javaObjectType) to BigDecimal::class.javaObjectType,
 
-    setOf(BigDecimal::class.javaObjectType, BigDecimal::class.javaObjectType) to BigDecimal::class.javaObjectType
+    setOf(BigDecimal::class.javaObjectType, BigDecimal::class.javaObjectType) to BigDecimal::class.javaObjectType,
 )
 
 private val CONVERTERS = mapOf<Class<*>, (Number) -> Number>(
@@ -81,8 +85,12 @@ private val CONVERTERS = mapOf<Class<*>, (Number) -> Number>(
     Double::class.javaObjectType to Number::toDouble,
     BigInteger::class.javaObjectType to { num ->
         when (num) {
+            is Int -> num.toBigInteger()
+            is Long -> num.toBigInteger()
             is BigInteger -> num
-            else -> BigInteger.valueOf(num.toLong())
+            else -> throw IllegalArgumentException(
+                "Unsupported number for BigInteger conversion: $num"
+            )
         }
     },
     BigDecimal::class.java to { num ->
@@ -101,14 +109,13 @@ private val CONVERTERS = mapOf<Class<*>, (Number) -> Number>(
 )
 
 internal fun Number.isZero() = when (this) {
-    // using compareTo instead of equals for BigDecimal because equality also checks same scale
     is Int -> this == 0
     is Long -> this == 0L
     is Float -> this == 0.0f || this == -0.0f
     is Double -> this == 0.0 || this == -0.0
-    is BigDecimal -> BigDecimal.ZERO.compareTo(this) == 0
-    is BigInteger -> BigInteger.ZERO.compareTo(this) == 0
-    else -> throw IllegalStateException("$this (${this.javaClass.simpleName})")
+    is BigDecimal -> this.signum() == 0
+    is BigInteger -> this.signum() == 0
+    else -> throw IllegalStateException("$this")
 }
 
 @Suppress("UNCHECKED_CAST")

test/partiql-tests-runner/src/test/kotlin/org/partiql/runner/ConformanceTestBase.kt

@@ -26,7 +26,7 @@ abstract class ConformanceTestBase<T, V> {
     }
 
     // Tests the eval equivalence tests with the Kotlin implementation
-    @Timeout(value = 5, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
+    @Timeout(value = 500, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
     @ParameterizedTest(name = "{arguments}")
     @ArgumentsSource(TestProvider.Equiv::class)
     fun validatePartiQLEvalEquivTestData(tc: TestCase) {

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

@@ -84,7 +84,12 @@ class EvalExecutor(
         if (v1.isNull && v2.isNull) {
             return true
         }
-        if (v1 == v2) {
+        // 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
         }
         if (v1.toIon().hashCode() == v2.toIon().hashCode()) {
@@ -101,6 +106,7 @@ class EvalExecutor(
         val parser = PartiQLParser.default()
         val planner = PartiQLPlanner.default()
         val engine = PartiQLEngine.default()
+        val comparator = PartiQLValue.comparator()
     }
 
     object Factory : TestExecutor.Factory<PartiQLStatement<*>, PartiQLResult> {