Merge pull request #219 from modelix/bugfix/cce-nullIfEmpty

fix(modelql): .nullIfEmpty() caused a CCE in some cases

Author: slisson

modelql-core/src/commonMain/kotlin/org/modelix/modelql/core/NullIfEmpty.kt

@@ -13,25 +13,30 @@
  */
 package org.modelix.modelql.core
 
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEmpty
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.builtins.nullable
 import kotlinx.serialization.modules.SerializersModule
 
 class NullIfEmpty<E>() : MonoTransformingStep<E, E?>() {
 
     override fun getOutputSerializer(serializersModule: SerializersModule): KSerializer<out IStepOutput<E?>> {
-        val serializer: KSerializer<IStepOutput<E>> = getProducer().getOutputSerializer(serializersModule).upcast()
-        val valueSerializer = (serializer as SimpleStepOutputSerializer<E>).valueSerializer
-        val nullableValueSerializer = (valueSerializer as KSerializer<Any>).nullable as KSerializer<E?>
-        return nullableValueSerializer.stepOutputSerializer(this)
+        return MultiplexedOutputSerializer(
+            this,
+            listOf(
+                getProducer().getOutputSerializer(serializersModule).upcast(),
+                nullSerializer<E?>().stepOutputSerializer(this).upcast(),
+            ),
+        )
     }
 
     override fun createFlow(input: StepFlow<E>, context: IFlowInstantiationContext): StepFlow<E?> {
         val downcast: StepFlow<E?> = input
-        return downcast.onEmpty { emit((null as E?).asStepOutput(this@NullIfEmpty)) }
+        return downcast.map { MultiplexedOutput(0, it) }.onEmpty {
+            emit(MultiplexedOutput(1, null.asStepOutput(this@NullIfEmpty)))
+        }
     }
 
     override fun transform(evaluationContext: QueryEvaluationContext, input: E): E? {

modelql-core/src/commonTest/kotlin/org/modelix/modelql/core/ModelQLTest.kt

@@ -279,6 +279,22 @@ class ModelQLTest {
         assertEquals(flowSize, sequenceSize)
     }
 
+    @Test
+    fun test_firstOrNull_nullIfEmpty() = runTestWithTimeout {
+        val result = remoteProductDatabaseQuery { db ->
+            db.products.firstOrNull().nullIfEmpty()
+        }
+        assertEquals(testDatabase.products.firstOrNull(), result)
+    }
+
+    @Test
+    fun test_nullIfEmpty() = runTestWithTimeout {
+        val result = remoteProductDatabaseQuery { db ->
+            db.products.nullIfEmpty().toList()
+        }
+        assertEquals(testDatabase.products, result)
+    }
+
 //    @Test
 //    fun testIndexLookup() {
 //        val result = remoteProductDatabaseQuery { db ->

modelql-core/src/jvmTest/kotlin/org/modelix/modelql/core/PerformanceTests.kt

@@ -47,7 +47,7 @@ class PerformanceTests {
         val query = buildMonoQuery<Int, Int> { it.filter { it.equalTo(0) } }
         val intRange = 1..100000
 
-        compareBenchmark(100, 10.0, {
+        compareBenchmark(100, 20.0, {
             query.asSequence(QueryEvaluationContext.EMPTY, intRange.asSequence()).count()
         }, {
             intRange.asSequence().filter { it == 0 }.count()