fixed update

Author: inemtsev

frameworks/Kotlin/ktor/ktor-r2dbc/src/main/kotlin/org/jetbrains/ktor/benchmarks/Hello.kt

@@ -127,22 +127,27 @@ fun Application.main() {
             val random = Random.Default
 
             val worlds = selectWorlds(queries, random)
+            val worldsUpdated = ArrayList<World>(queries)
 
-            val worldsUpdated = buildList {
-                worlds.collect { world ->
-                    world.randomNumber = random.nextInt(DB_ROWS) + 1
-                    add(world)
-                }
+            worlds.collect { world ->
+                world.randomNumber = random.nextInt(DB_ROWS) + 1
+                worldsUpdated.add(world)
             }
 
             Mono.usingWhen(dbConnFactory.create(), { connection ->
                 val statement = connection.createStatement(UPDATE_QUERY)
                 worldsUpdated.forEach { world ->
-                    statement.bind(0, world.randomNumber)
-                    statement.bind(1, world.id)
-                    statement.add()
+                    if (world.id != null && world.randomNumber != null) {
+                        statement.bind(0, world.randomNumber)
+                        statement.bind(1, world.id)
+                        statement.add()
+                    }
+                }
+                if (worldsUpdated.isNotEmpty()) {
+                    Mono.from(statement.execute())
+                } else {
+                    Mono.empty()
                 }
-                Mono.from(statement.execute())
             }, Connection::close).awaitFirstOrNull()
 
             call.respondText(json.encodeToString(worldsUpdated), ContentType.Application.Json)
@@ -153,13 +158,20 @@ fun Application.main() {
 private fun getWorld(
     dbConnFactory: ConnectionFactory, random: Random
 ): Mono<World> = Mono.usingWhen(dbConnFactory.create(), { connection ->
-    Mono.from(connection.createStatement(WORLD_QUERY).bind(0, random.nextInt(DB_ROWS) + 1).execute()).flatMap { r ->
-        Mono.from(r.map { row, _ ->
-            World(
-                row.get(0, Int::class.java)!!, row.get(1, Int::class.java)!!
-            )
-        })
-    }
+    Mono.from(connection.createStatement(WORLD_QUERY)
+        .bind(0, random.nextInt(DB_ROWS) + 1)
+        .execute())
+        .flatMap { r ->
+            Mono.from(r.map { row, _ ->
+                val id = row.get(0, Int::class.java)
+                val randomNumber = row.get(1, Int::class.java)
+                if (id != null && randomNumber != null) {
+                    World(id, randomNumber)
+                } else {
+                    throw IllegalStateException("Database returned null values for required fields")
+                }
+            })
+        }
 }, Connection::close)
 
 private fun configurePostgresR2DBC(config: ApplicationConfig): ConnectionFactory {

frameworks/Kotlin/ktor/ktor/src/main/kotlin/org/jetbrains/ktor/benchmarks/Hello.kt

@@ -20,6 +20,19 @@ import org.jetbrains.ktor.benchmarks.Constants.WORLD_QUERY
 import java.sql.Connection
 import java.util.concurrent.ThreadLocalRandom
 import kotlin.random.Random
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.modules.SerializersModule
+import kotlinx.serialization.modules.contextual
+import kotlinx.serialization.modules.polymorphic
+import kotlinx.serialization.modules.subclass
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.descriptors.buildClassSerialDescriptor
+import kotlinx.serialization.descriptors.element
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.encoding.encodeStructure
+import kotlinx.serialization.encoding.decodeStructure
 
 @Serializable
 data class Message(val message: String)
@@ -30,6 +43,65 @@ data class World(val id: Int, var randomNumber: Int)
 @Serializable
 data class Fortune(val id: Int, var message: String)
 
+@Serializable
+data class DynamicValue(
+    @Contextual
+    val value: Any
+)
+
+class AnySerializer : KSerializer<Any> {
+    override val descriptor: SerialDescriptor = buildClassSerialDescriptor("Any") {
+        element<String>("type")
+        element<String>("value")
+    }
+
+    override fun serialize(encoder: Encoder, value: Any) {
+        encoder.encodeStructure(descriptor) {
+            when (value) {
+                is String -> {
+                    encodeStringElement(descriptor, 0, "string")
+                    encodeStringElement(descriptor, 1, value)
+                }
+                is Number -> {
+                    encodeStringElement(descriptor, 0, "number")
+                    encodeStringElement(descriptor, 1, value.toString())
+                }
+                is Boolean -> {
+                    encodeStringElement(descriptor, 0, "boolean")
+                    encodeStringElement(descriptor, 1, value.toString())
+                }
+                is List<*> -> {
+                    encodeStringElement(descriptor, 0, "list")
+                    encodeStringElement(descriptor, 1, json.encodeToString(value))
+                }
+                is Map<*, *> -> {
+                    encodeStringElement(descriptor, 0, "map")
+                    encodeStringElement(descriptor, 1, json.encodeToString(value))
+                }
+                else -> {
+                    encodeStringElement(descriptor, 0, "string")
+                    encodeStringElement(descriptor, 1, value.toString())
+                }
+            }
+        }
+    }
+
+    override fun deserialize(decoder: Decoder): Any {
+        return decoder.decodeStructure(descriptor) {
+            val type = decodeStringElement(descriptor, 0)
+            val value = decodeStringElement(descriptor, 1)
+            when (type) {
+                "string" -> value
+                "number" -> value.toDoubleOrNull() ?: value
+                "boolean" -> value.toBoolean()
+                "list" -> json.decodeFromString<List<Any>>(value)
+                "map" -> json.decodeFromString<Map<String, Any>>(value)
+                else -> value
+            }
+        }
+    }
+}
+
 // Optimized JSON instance with better performance settings
 private val json = Json {
     prettyPrint = false
@@ -38,6 +110,17 @@ private val json = Json {
     coerceInputValues = true
 }
 
+// Create a custom JSON instance with the AnySerializer
+private val jsonWithAny = Json {
+    serializersModule = SerializersModule {
+        contextual(AnySerializer())
+    }
+    prettyPrint = false
+    isLenient = true
+    ignoreUnknownKeys = true
+    coerceInputValues = true
+}
+
 fun Application.main() {
     val dbRows = 10000
     val poolSize = Runtime.getRuntime().availableProcessors() * 2
@@ -160,6 +243,11 @@ fun Application.main() {
 
             call.respondText(json.encodeToString(result), ContentType.Application.Json)
         }
+
+        post("/dynamic-map") {
+            val dynamicMap = call.receive<Map<String, DynamicValue>>()
+            call.respondText(jsonWithAny.encodeToString(dynamicMap), ContentType.Application.Json)
+        }
     }
 }