Merge branch 'dev-dependent-on-snapshots'

README.md

@@ -6,7 +6,7 @@
 
 ## Note
 
-This project currently serves our own use and there are temporarily no guides or docs. See [DatabaseClient.kt](lib/src/main/kotlin/com/huanshankeji/exposedvertxsqlclient/DatabaseClient.kt) for the major APIs.
+This project currently serves our own use and there are temporarily no guides or docs. See [DatabaseClient.kt](lib/src/main/kotlin/com/huanshankeji/exposedvertxsqlclient/DatabaseClient.kt) and [DatabaseClientSql.kt](lib/src/main/kotlin/com/huanshankeji/exposedvertxsqlclient/sql/DatabaseClientSql.kt) for the major APIs.
 
 Only PostgreSQL with [Reactive PostgreSQL Client](https://vertx.io/docs/vertx-pg-client/java/) is currently supported.
 

buildSrc/build.gradle.kts

@@ -15,7 +15,7 @@ repositories {
 }
 
 dependencies {
-    implementation(kotlin("gradle-plugin", "1.8.21"))
-    implementation("com.huanshankeji:common-gradle-dependencies:0.6.0-20230609")
-    implementation("com.huanshankeji.team:gradle-plugins:0.4.1")
+    implementation(kotlin("gradle-plugin", "1.9.23"))
+    implementation("com.huanshankeji:common-gradle-dependencies:0.7.1-20240314")
+    implementation("com.huanshankeji.team:gradle-plugins:0.5.1")
 }

buildSrc/src/main/kotlin/VersionsAndDependencies.kt

@@ -1,6 +1,13 @@
 import com.huanshankeji.CommonDependencies
+import com.huanshankeji.CommonGradleClasspathDependencies
 import com.huanshankeji.CommonVersions
 
-val projectVersion = "0.2.1-SNAPSHOT"
-val commonVersions = CommonVersions(kotlin = "1.8.21")
+val projectVersion = "0.3.0-SNAPSHOT"
+
+val commonVersions = CommonVersions()
 val commonDependencies = CommonDependencies(commonVersions)
+val commonGradleClasspathDependencies = CommonGradleClasspathDependencies(commonVersions)
+
+object DependencyVersions {
+    val exposedAdtMapping = "0.1.0"
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-all.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew.bat

@@ -43,11 +43,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -57,11 +57,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 

lib/build.gradle.kts

@@ -1,12 +1,14 @@
 plugins {
     conventions
+    id("com.huanshankeji.benchmark.kotlinx-benchmark-jvm-conventions")
 }
 
 dependencies {
     api(commonDependencies.exposed.core()) // TODO: use `implementation` when possible
     // TODO: remove the Exposed JDBC dependency and the PostgresSQL dependency when there is no need to to generate SQLs with an Exposed transaction
     runtimeOnly(commonDependencies.exposed.module("jdbc"))
     api(commonDependencies.kotlinCommon.exposed())
+    implementation("com.huanshankeji:exposed-adt-mapping:${DependencyVersions.exposedAdtMapping}")
 
     with(commonDependencies.vertx) {
         implementation(platformStackDepchain())
@@ -22,8 +24,20 @@ dependencies {
     implementation(commonDependencies.kotlinCommon.net())
 }
 
+
 // for PostgreSQL
 dependencies {
     runtimeOnly(commonDependencies.postgreSql())
     implementation(commonDependencies.vertx.moduleWithoutVersion("pg-client"))
 }
+
+afterEvaluate {
+// for the benchmarks
+    dependencies {
+        with(commonDependencies.testContainers) {
+            "benchmarksImplementation"(platformBom())
+            "benchmarksImplementation"(postgreSql)
+        }
+        "benchmarksImplementation"(commonDependencies.slf4j.simple())
+    }
+}

lib/src/benchmarks/kotlin/com/huanshankeji/exposed/benchmark/AbstractBenchmark.kt

@@ -0,0 +1,11 @@
+package com.huanshankeji.exposed.benchmark
+
+import kotlinx.benchmark.Measurement
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
+import kotlinx.benchmark.Warmup
+
+@State(Scope.Benchmark)
+@Warmup(time = 1, iterations = 2)
+@Measurement(time = 1, iterations = 2)
+abstract class AbstractBenchmark

lib/src/benchmarks/kotlin/com/huanshankeji/exposed/benchmark/EmptyBenchmark.kt

@@ -0,0 +1,13 @@
+package com.huanshankeji.exposed.benchmark
+
+import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
+
+@State(Scope.Benchmark)
+class EmptyBenchmark : AbstractBenchmark() {
+    // for comparison
+    @Benchmark
+    fun empty() {
+    }
+}

lib/src/benchmarks/kotlin/com/huanshankeji/exposed/benchmark/PreparedSqlGenerationBenchmark.kt

@@ -0,0 +1,99 @@
+package com.huanshankeji.exposed.benchmark
+
+import com.huanshankeji.exposed.benchmark.table.VarcharTable
+import com.huanshankeji.exposed.deleteAllStatement
+import com.huanshankeji.exposed.deleteWhereStatement
+import com.huanshankeji.exposed.insertStatement
+import com.huanshankeji.exposed.updateStatement
+import kotlinx.benchmark.*
+import kotlinx.coroutines.*
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.statements.Statement
+import org.jetbrains.exposed.sql.transactions.transaction
+
+@State(Scope.Benchmark)
+class PreparedSqlGenerationBenchmark : WithContainerizedDatabaseBenchmark() {
+    enum class StatementEnum(val statement: Statement<*>) {
+        SelectAll(VarcharTable.selectAll()),
+        SelectWhere(VarcharTable.select(VarcharTable.id eq 0L)),
+        Insert(VarcharTable.insertStatement { it[varcharColumn] = "string" }),
+        Update(VarcharTable.updateStatement({ VarcharTable.id eq 0L }) {
+            it[varcharColumn] = "string"
+        }),
+        DeleteAll(VarcharTable.deleteAllStatement()),
+        DeleteStatement(VarcharTable.deleteWhereStatement { VarcharTable.id eq 0L })
+    }
+
+    @Param("SelectAll", "SelectWhere", "Insert", "Update", "DeleteAll", "DeleteStatement")
+    lateinit var statementEnum: StatementEnum
+    val statement get() = statementEnum.statement
+
+    /*
+    var transaction: Transaction? = null
+    val releaseTransactionMutex = Mutex(true)
+
+    @OptIn(DelicateCoroutinesApi::class)
+    val context = newSingleThreadContext("keep transaction alive")
+
+    override fun setUp() {
+        // for debugging purposes
+        fun println(x:Int) = println("break point $x")
+        super.setUp()
+        println(1)
+        runBlocking {
+            println(2)
+            val setTransactionMutex = Mutex(true)
+            println(3)
+            CoroutineScope(context).launch {
+                // doesn't work because the transaction is stored into the current thread's `ThreadLocal` for `arguments()` to use
+                newSuspendedTransaction (db = database) {
+                    println(4)
+                    transaction = this
+                    println(5)
+                    setTransactionMutex.unlock()
+                    println(6)
+                    releaseTransactionMutex.lock()
+                    println(7)
+                }
+            }
+            println(8)
+            setTransactionMutex.lock()
+            println(9)
+        }
+        println(10)
+    }
+
+
+    override fun tearDown() {
+        transaction = null
+        releaseTransactionMutex.unlock()
+        println("isActive: " + context.isActive)
+        context.cancel()
+
+        super.tearDown()
+    }
+    */
+
+    companion object {
+        const val `1M` = 1000_000
+    }
+
+    @Benchmark
+    fun prepareSQL1M() {
+        transaction(database) {
+            repeat(`1M`) {
+                statement.prepareSQL(this)
+            }
+        }
+    }
+
+    @Benchmark
+    fun arguments1M() {
+        transaction(database) {
+            repeat(`1M`) {
+                statement.arguments()
+            }
+        }
+    }
+}

lib/src/benchmarks/kotlin/com/huanshankeji/exposed/benchmark/StatementBenchmark.kt

@@ -0,0 +1,41 @@
+package com.huanshankeji.exposed.benchmark
+
+import com.huanshankeji.exposed.benchmark.table.EmptyTable
+import com.huanshankeji.exposed.benchmark.table.VarcharTable
+import com.huanshankeji.exposed.deleteAllStatement
+import com.huanshankeji.exposed.deleteWhereStatement
+import com.huanshankeji.exposed.insertStatement
+import com.huanshankeji.exposed.updateStatement
+import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Param
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
+import org.jetbrains.exposed.sql.Op
+import org.jetbrains.exposed.sql.Table
+import org.jetbrains.exposed.sql.selectAll
+
+@State(Scope.Benchmark)
+class StatementBenchmark : AbstractBenchmark() {
+    enum class TableEnum(val table: Table) {
+        EmptyTableEnum(EmptyTable), VarcharTableEnum(VarcharTable)
+    }
+
+    @Param("EmptyTableEnum", "VarcharTableEnum")
+    lateinit var tableEnum: TableEnum
+    val table get() = tableEnum.table
+
+    @Benchmark
+    fun createSelectStatement() = table.selectAll()
+
+    @Benchmark
+    fun createInsertStatement() = table.insertStatement {}
+
+    @Benchmark
+    fun createUpdateStatement() = table.updateStatement(null) {}
+
+    @Benchmark
+    fun deleteAllStatement() = table.deleteAllStatement()
+
+    @Benchmark
+    fun deleteWhereStatement() = table.deleteWhereStatement { Op.TRUE }
+}

lib/src/benchmarks/kotlin/com/huanshankeji/exposed/benchmark/TransactionBenchmark.kt

@@ -0,0 +1,69 @@
+package com.huanshankeji.exposed.benchmark
+
+import com.huanshankeji.kotlinx.coroutine.awaitAny
+import kotlinx.benchmark.Benchmark
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.State
+import kotlinx.coroutines.*
+import org.jetbrains.exposed.sql.transactions.experimental.newSuspendedTransaction
+import org.jetbrains.exposed.sql.transactions.experimental.suspendedTransactionAsync
+import org.jetbrains.exposed.sql.transactions.transaction
+import kotlin.concurrent.thread
+
+@State(Scope.Benchmark)
+class TransactionBenchmark : WithContainerizedDatabaseBenchmark() {
+    @Benchmark
+    fun transaction() {
+        transaction(database) {}
+    }
+
+    companion object {
+        const val `10K` = 10_000
+    }
+
+    @Benchmark
+    fun _10KTransactions() {
+        repeat(`10K`) { transaction(database) {} }
+    }
+
+    private suspend fun awaitAsync10KTransactions() =
+        coroutineScope {
+            List(`10K`) { async { transaction(database) {} } }.awaitAll()
+        }
+
+    @Benchmark
+    fun singleThreadConcurrent10KTransactions() = runBlocking {
+        awaitAsync10KTransactions()
+    }
+
+
+    @Benchmark
+    fun multiThreadConcurrent10KTransactions() = runBlocking {
+        withContext(Dispatchers.Default) {
+            awaitAsync10KTransactions()
+        }
+    }
+
+
+    @Benchmark
+    fun _10KSuspendedTransactions() = runBlocking {
+        repeat(`10K`) { newSuspendedTransaction(db = database) {} }
+    }
+
+    @Benchmark
+    fun _10KSuspendedTransactionAsyncs() = runBlocking {
+        List(`10K`) { suspendedTransactionAsync(db = database) {} }.awaitAny()
+    }
+
+    @Benchmark
+    fun multiThreadMultiConnectionEach10KLocalTransactions() {
+        List(Runtime.getRuntime().availableProcessors()) {
+            thread {
+                val database = databaseConnect()
+                repeat(`10K`) { transaction(database) {} }
+            }
+        }.forEach {
+            it.join()
+        }
+    }
+}

lib/src/benchmarks/kotlin/com/huanshankeji/exposed/benchmark/WithContainerizedDatabaseBenchmark.kt

@@ -0,0 +1,33 @@
+package com.huanshankeji.exposed.benchmark
+
+import com.huanshankeji.exposedvertxsqlclient.ConnectionConfig
+import com.huanshankeji.exposedvertxsqlclient.exposedDatabaseConnectPostgreSql
+import kotlinx.benchmark.Scope
+import kotlinx.benchmark.Setup
+import kotlinx.benchmark.State
+import kotlinx.benchmark.TearDown
+import org.jetbrains.exposed.sql.Database
+import org.testcontainers.containers.PostgreSQLContainer
+import org.testcontainers.utility.DockerImageName
+
+@State(Scope.Benchmark)
+class WithContainerizedDatabaseBenchmark : AbstractBenchmark() {
+    val postgreSQLContainer = PostgreSQLContainer(DockerImageName.parse("postgres:latest"))
+    lateinit var database: Database
+
+    fun databaseConnect() =
+        exposedDatabaseConnectPostgreSql(with(postgreSQLContainer) {
+            ConnectionConfig.Socket(host, firstMappedPort, username, password, databaseName)
+        })
+
+    @Setup
+    fun setUp() {
+        postgreSQLContainer.start()
+        database = databaseConnect()
+    }
+
+    @TearDown
+    fun tearDown() {
+        postgreSQLContainer.stop()
+    }
+}