EVA-PIMP use generic dml query for deletes and no returning inserts (#…

…110)

* EVA-PIMP use generic dml query for deletes and no returning inserts

* cosmetics

* fix patching executor

buildSrc/src/main/kotlin/CI.kt

@@ -3,7 +3,7 @@ import java.lang.Boolean.parseBoolean
 object Ci {
 
     private const val SNAPSHOT_BASE = "0.5.0"
-    private const val RELEASE_VERSION = "0.3.7"
+    private const val RELEASE_VERSION = "0.4.1"
     private val githubSha = System.getenv("GITHUB_SHA") ?: "latest"
 
     val publishRelease = System.getProperty("release", "true").let(::parseBoolean)

eva-persistence-jdbc/src/main/kotlin/com/razz/eva/persistence/jdbc/executor/JdbcQueryExecutor.kt

@@ -3,8 +3,8 @@ package com.razz.eva.persistence.jdbc.executor
 import com.razz.eva.persistence.ConnectionMode.REQUIRE_EXISTING
 import com.razz.eva.persistence.executor.QueryExecutor
 import com.razz.eva.persistence.jdbc.JdbcTransactionManager
+import org.jooq.DMLQuery
 import org.jooq.DSLContext
-import org.jooq.DeleteQuery
 import org.jooq.Param
 import org.jooq.Query
 import org.jooq.Record
@@ -42,30 +42,33 @@ class JdbcQueryExecutor(
         }
     }
 
-    override suspend fun <R : Record> executeDelete(
+    override suspend fun <R : Record> executeQuery(
         dslContext: DSLContext,
-        jooqQuery: DeleteQuery<R>,
-        table: Table<R>,
+        jooqQuery: DMLQuery<R>,
     ): Int {
         return transactionManager.inTransaction(REQUIRE_EXISTING) { connection ->
             DSL.using(connection, dslContext.settings()).run {
-                preparedQuery(jooqQuery).execute()
+                execute(
+                    render(jooqQuery),
+                    *extractParams(jooqQuery)
+                        .values
+                        .filterNot(Param<*>::isInline)
+                        .toTypedArray()
+                )
             }
         }
     }
 
     private fun <R : Record> DSLContext.preparedQuery(
         jooqQuery: Query,
         table: Table<R>,
-    ): List<R> = preparedQuery(jooqQuery).coerce(table).fetch()
-
-    private fun DSLContext.preparedQuery(jooqQuery: Query) = resultQuery(
+    ): List<R> = resultQuery(
         render(jooqQuery),
         *extractParams(jooqQuery)
             .values
             .filterNot(Param<*>::isInline)
             .toTypedArray()
-    )
+    ).coerce(table).fetch()
 
     override fun getConstraintName(e: DataAccessException): String? {
         return e.getCause(PSQLException::class.java)?.serverErrorMessage?.constraint

eva-persistence-jdbc/src/test/kotlin/com/razz/eva/persistence/jdbc/executor/JdbcQueryExecutorSpec.kt

@@ -90,10 +90,9 @@ class JdbcQueryExecutorSpec : BehaviorSpec({
             When("Principal calls execute delete without context") {
 
                 val storeRun = suspend {
-                    jdbcExecutor.executeDelete(
+                    jdbcExecutor.executeQuery(
                         dslContext,
                         delete,
-                        DSL.table("cool_table"),
                     )
                 }
 
@@ -166,10 +165,9 @@ class JdbcQueryExecutorSpec : BehaviorSpec({
             When("Principal calls execute delete with context") {
 
                 withContext(Dispatchers.IO + JdbcConnectionElement(connection)) {
-                    jdbcExecutor.executeDelete(
+                    jdbcExecutor.executeQuery(
                         dslContext,
                         delete,
-                        DSL.table("cool_table"),
                     )
                 }
 

eva-persistence-vertx/src/main/kotlin/com/razz/eva/persistence/vertx/executor/VertxQueryExecutor.kt

@@ -11,8 +11,8 @@ import io.vertx.sqlclient.RowSet
 import io.vertx.sqlclient.SqlResult
 import io.vertx.sqlclient.impl.ArrayTuple
 import org.jooq.Converter
+import org.jooq.DMLQuery
 import org.jooq.DSLContext
-import org.jooq.DeleteQuery
 import org.jooq.JSON
 import org.jooq.JSONB
 import org.jooq.Query
@@ -55,10 +55,9 @@ class VertxQueryExecutor(
         }
     }
 
-    override suspend fun <R : Record> executeDelete(
+    override suspend fun <R : Record> executeQuery(
         dslContext: DSLContext,
-        jooqQuery: DeleteQuery<R>,
-        table: Table<R>,
+        jooqQuery: DMLQuery<R>,
     ): Int {
         return transactionManager.inTransaction(REQUIRE_EXISTING) { connection ->
             connection.preparedQuery(dslContext.renderNamedParams(jooqQuery))

eva-persistence-vertx/src/test/kotlin/com/razz/eva/persistence/vertx/executor/VertxQueryExecutorSpec.kt

@@ -128,10 +128,9 @@ class VertxQueryExecutorSpec : BehaviorSpec({
             When("Principal calls execute store without context") {
 
                 val storeRun = suspend {
-                    vertxExecutor.executeDelete(
+                    vertxExecutor.executeQuery(
                         dslContext,
                         delete,
-                        DSL.table("cool_table"),
                     )
                 }
 
@@ -204,10 +203,9 @@ class VertxQueryExecutorSpec : BehaviorSpec({
             When("Principal calls execute delete with context") {
 
                 withContext(Dispatchers.IO + VertxConnectionElement(connection)) {
-                    vertxExecutor.executeDelete(
+                    vertxExecutor.executeQuery(
                         dslContext,
                         delete,
-                        DSL.table("cool_table"),
                     )
                 }
 

eva-persistence/src/main/kotlin/com/razz/eva/persistence/executor/QueryExecutor.kt

@@ -1,7 +1,7 @@
 package com.razz.eva.persistence.executor
 
+import org.jooq.DMLQuery
 import org.jooq.DSLContext
-import org.jooq.DeleteQuery
 import org.jooq.Record
 import org.jooq.Select
 import org.jooq.StoreQuery
@@ -22,10 +22,9 @@ interface QueryExecutor {
         table: Table<ROUT>,
     ): List<ROUT>
 
-    suspend fun <R : Record> executeDelete(
+    suspend fun <R : Record> executeQuery(
         dslContext: DSLContext,
-        jooqQuery: DeleteQuery<R>,
-        table: Table<R>,
+        jooqQuery: DMLQuery<R>,
     ): Int
 
     fun getConstraintName(e: DataAccessException): String?

eva-repository/src/main/kotlin/com/razz/eva/repository/JooqEventRepository.kt

@@ -22,7 +22,6 @@ import kotlinx.serialization.encodeToString
 import org.jooq.DSLContext
 import org.jooq.InsertQuery
 import org.jooq.Record
-import org.jooq.Table
 import org.jooq.exception.DataAccessException
 import kotlin.coroutines.coroutineContext
 
@@ -86,7 +85,6 @@ class JooqEventRepository(
                 dslContext.insertQuery(UOW_EVENTS).apply {
                     setRecord(toUERecord(uowEvent))
                 },
-                UOW_EVENTS
             )
         } catch (e: Exception) {
             val constraintName = when {
@@ -128,16 +126,14 @@ class JooqEventRepository(
                         addRecord(mer)
                     }
                 },
-                MODEL_EVENTS
             )
         }
     }
 
-    private suspend fun <R : Record> insert(query: InsertQuery<R>, table: Table<R>) {
-        queryExecutor.executeStore(
+    private suspend fun <R : Record> insert(query: InsertQuery<R>) {
+        queryExecutor.executeQuery(
             dslContext = dslContext,
             jooqQuery = query,
-            table = table
         )
     }
 }

eva-repository/src/test/kotlin/com/razz/eva/repository/JooqEventRepositorySpec.kt

@@ -15,7 +15,7 @@ import com.razz.eva.events.db.tables.UowEvents.UOW_EVENTS
 import com.razz.eva.events.db.tables.records.ModelEventsRecord
 import com.razz.eva.events.db.tables.records.UowEventsRecord
 import com.razz.eva.persistence.executor.FakeMemorizingQueryExecutor
-import com.razz.eva.persistence.executor.FakeMemorizingQueryExecutor.ExecutionStep.StoreExecuted
+import com.razz.eva.persistence.executor.FakeMemorizingQueryExecutor.ExecutionStep.QueryExecuted
 import com.razz.eva.serialization.json.JsonFormat.json
 import com.razz.eva.uow.UowParams
 import com.razz.eva.tracing.Tracing.notReportingTracer
@@ -110,7 +110,7 @@ class JooqEventRepositorySpec : BehaviorSpec({
 
                 Then("Query executor should receive one uow event and two model events") {
                     queryExecutor.executionHistory shouldBe listOf(
-                        StoreExecuted(
+                        QueryExecuted(
                             dslContext,
                             dslContext.insertQuery(UOW_EVENTS)
                                 .also {
@@ -136,9 +136,8 @@ class JooqEventRepositorySpec : BehaviorSpec({
                                         }
                                     )
                                 },
-                            UOW_EVENTS
                         ),
-                        StoreExecuted(
+                        QueryExecuted(
                             dslContext,
                             dslContext.insertQuery(MODEL_EVENTS)
                                 .also {
@@ -189,7 +188,6 @@ class JooqEventRepositorySpec : BehaviorSpec({
                                         }
                                     )
                                 },
-                            MODEL_EVENTS
                         )
                     )
                 }
@@ -238,7 +236,7 @@ class JooqEventRepositorySpec : BehaviorSpec({
 
                 Then("Query executor should receive one uow event") {
                     queryExecutor.executionHistory shouldBe listOf(
-                        StoreExecuted(
+                        QueryExecuted(
                             dslContext,
                             dslContext.insertQuery(UOW_EVENTS)
                                 .also {
@@ -264,7 +262,6 @@ class JooqEventRepositorySpec : BehaviorSpec({
                                         }
                                     )
                                 },
-                            UOW_EVENTS
                         )
                     )
                 }
@@ -295,7 +292,7 @@ class JooqEventRepositorySpec : BehaviorSpec({
 
                 Then("Query executor should receive one uow event") {
                     queryExecutor.executionHistory shouldBe listOf(
-                        StoreExecuted(
+                        QueryExecuted(
                             dslContext,
                             dslContext.insertQuery(UOW_EVENTS)
                                 .also {
@@ -321,7 +318,6 @@ class JooqEventRepositorySpec : BehaviorSpec({
                                         }
                                     )
                                 },
-                            UOW_EVENTS
                         )
                     )
                 }

eva-repository/src/testFixtures/kotlin/com/razz/eva/persistence/executor/FakeMemorizingQueryExecutor.kt

@@ -1,10 +1,10 @@
 package com.razz.eva.persistence.executor
 
-import com.razz.eva.persistence.executor.FakeMemorizingQueryExecutor.ExecutionStep.DeleteExecuted
+import com.razz.eva.persistence.executor.FakeMemorizingQueryExecutor.ExecutionStep.QueryExecuted
 import com.razz.eva.persistence.executor.FakeMemorizingQueryExecutor.ExecutionStep.SelectExecuted
 import com.razz.eva.persistence.executor.FakeMemorizingQueryExecutor.ExecutionStep.StoreExecuted
+import org.jooq.DMLQuery
 import org.jooq.DSLContext
-import org.jooq.DeleteQuery
 import org.jooq.Record
 import org.jooq.SQLDialect.POSTGRES
 import org.jooq.Select
@@ -57,12 +57,11 @@ class FakeMemorizingQueryExecutor(
             .into(table)
     }
 
-    override suspend fun <R : Record> executeDelete(
+    override suspend fun <R : Record> executeQuery(
         dslContext: DSLContext,
-        jooqQuery: DeleteQuery<R>,
-        table: Table<R>,
+        jooqQuery: DMLQuery<R>,
     ): Int {
-        executions += DeleteExecuted(dslContext, jooqQuery)
+        executions += QueryExecuted(dslContext, jooqQuery)
         return DSL.using(MockConnection(MockProvider(queries)), POSTGRES, dslContext.settings())
             .execute(jooqQuery.getSQL(INLINED))
     }
@@ -81,9 +80,9 @@ class FakeMemorizingQueryExecutor(
             val table: Table<out Record>,
         ) : ExecutionStep()
 
-        data class DeleteExecuted(
+        data class QueryExecuted(
             val dslContext: DSLContext,
-            val jooqQuery: DeleteQuery<out Record>,
+            val jooqQuery: DMLQuery<out Record>,
         ) : ExecutionStep()
     }
 

eva-uow/src/test/kotlin/com/razz/eva/uow/func/PersistenceSpec.kt

@@ -143,12 +143,11 @@ class PersistenceSpec : PersistenceBaseSpec({
 
         When("Principal performs delete on query executor") {
             module.transactionManager.inTransaction(REQUIRE_NEW) { _ ->
-                module.queryExecutor.executeDelete(
+                module.queryExecutor.executeQuery(
                     module.dslContext,
                     module.dslContext.deleteQuery(Tables.EMPLOYEES).apply {
                         addConditions(Tables.EMPLOYEES.ID.eq(boss.id().id))
                     },
-                    Tables.EMPLOYEES,
                 )
             }
 

eva-uow/src/test/kotlin/com/razz/eva/uow/func/TestModule.kt

@@ -25,17 +25,16 @@ import com.razz.eva.uow.Persisting
 import com.razz.eva.uow.UnitOfWorkExecutor
 import com.razz.eva.uow.withFactory
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry
+import org.jooq.DMLQuery
 import org.jooq.DSLContext
 import org.jooq.Field
+import org.jooq.InsertQuery
 import org.jooq.Record
-import org.jooq.StoreQuery
-import org.jooq.Table
 import org.jooq.impl.DSL
 import org.jooq.impl.SQLDataType
 import java.sql.Timestamp
 import java.time.Clock
 import java.time.Duration
-import java.time.Instant.now
 import java.util.*
 
 class TestModule(config: DatabaseConfig) : TransactionalModule(config) {
@@ -88,24 +87,20 @@ class TestModule(config: DatabaseConfig) : TransactionalModule(config) {
     )
 
     private val patchingQueryExecutor = object : QueryExecutor by queryExecutor {
-        override suspend fun <RIN : Record, ROUT : Record> executeStore(
-            dslContext: DSLContext,
-            jooqQuery: StoreQuery<RIN>,
-            table: Table<ROUT>,
-        ): List<ROUT> {
-            if (table.name == "uow_events") {
+        override suspend fun <R : Record> executeQuery(dslContext: DSLContext, jooqQuery: DMLQuery<R>): Int {
+            if (jooqQuery is InsertQuery<*> && jooqQuery.sql.contains("uow_events")) {
                 val occurredAtParam = jooqQuery.getParam("6") as Field<Timestamp>
                 jooqQuery.addValue(
                     DSL.field("inserted_at", SQLDataType.TIMESTAMP),
                     occurredAtParam,
                 )
             }
-            return queryExecutor.executeStore(dslContext, jooqQuery, table)
+            return queryExecutor.executeQuery(dslContext, jooqQuery)
         }
     }
 
     val uowxInFuture = UnitOfWorkExecutor(
-        factories = factories(fixedUTC(now() + Duration.ofDays(6))),
+        factories = factories(fixedUTC(now + Duration.ofDays(6))),
         persisting = Persisting(
             transactionManager = transactionManager,
             modelRepos = repos,