Introduce encoders() method in Connection for retrieving ValueEncoderRegistry. Enhance PooledConnection with overridden SQL execution methods, connection status management, and lifecycle consistency. Update tests to validate connection release behavior.

Author: smyrgeorge

sqlx4k-sqlite/src/jvmMain/kotlin/io/github/smyrgeorge/sqlx4k/sqlite/SQLite.kt

@@ -176,6 +176,8 @@ class SQLite(
                 }
             }
         }
+
+        override fun encoders(): Statement.ValueEncoderRegistry = encoders
     }
 
     /**

sqlx4k/src/commonMain/kotlin/io/github/smyrgeorge/sqlx4k/Connection.kt

@@ -37,6 +37,15 @@ interface Connection : QueryExecutor, QueryExecutor.Transactional {
      */
     suspend fun close(): Result<Unit>
 
+    /**
+     * Retrieves the `ValueEncoderRegistry` associated with the current connection.
+     * The `ValueEncoderRegistry` provides access to registered value encoders, which
+     * are responsible for converting types into formats suitable for use in SQL statements.
+     *
+     * @return A `ValueEncoderRegistry` instance that manages the encoders for this connection.
+     */
+    fun encoders(): Statement.ValueEncoderRegistry = Statement.ValueEncoderRegistry.EMPTY
+
     /**
      * Represents the operational state of a connection.
      *

sqlx4k/src/commonMain/kotlin/io/github/smyrgeorge/sqlx4k/impl/pool/PooledConnection.kt

@@ -2,8 +2,7 @@
 
 package io.github.smyrgeorge.sqlx4k.impl.pool
 
-import io.github.smyrgeorge.sqlx4k.Connection
-import io.github.smyrgeorge.sqlx4k.SQLError
+import io.github.smyrgeorge.sqlx4k.*
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlin.concurrent.atomics.ExperimentalAtomicApi
@@ -15,13 +14,15 @@ import kotlin.time.TimeSource
 class PooledConnection(
     private val connection: Connection,
     private val pool: ConnectionPoolImpl
-) : Connection by connection {
+) : Connection {
     private val mutex = Mutex()
     private var acquired = true
     private val released get() = !acquired
     private val createdAt: TimeMark = TIME_SOURCE.markNow()
     private var lastUsedAt: TimeMark = createdAt
 
+    override var status: Connection.Status = Connection.Status.Open
+
     fun isReleased(): Boolean = released
 
     fun isExpired(): Boolean {
@@ -39,15 +40,18 @@ class PooledConnection(
 
             acquired = true
             lastUsedAt = TIME_SOURCE.markNow()
+            status = Connection.Status.Open
         }
         return this
     }
 
     override suspend fun close(): Result<Unit> = runCatching {
         mutex.withLock {
+            assertIsOpen()
             if (released) return@runCatching
             acquired = false
             lastUsedAt = TIME_SOURCE.markNow()
+            status = Connection.Status.Closed
         }
 
         if (pool.closed.load()) {
@@ -101,6 +105,36 @@ class PooledConnection(
         }
     }
 
+    override suspend fun execute(sql: String): Result<Long> = runCatching {
+        mutex.withLock {
+            assertIsOpen()
+            return connection.execute(sql)
+        }
+    }
+
+    override suspend fun execute(statement: Statement): Result<Long> =
+        execute(statement.render(connection.encoders()))
+
+    override suspend fun fetchAll(sql: String): Result<ResultSet> = runCatching {
+        return mutex.withLock {
+            assertIsOpen()
+            connection.fetchAll(sql)
+        }
+    }
+
+    override suspend fun fetchAll(statement: Statement): Result<ResultSet> =
+        fetchAll(statement.render(connection.encoders()))
+
+    override suspend fun <T> fetchAll(statement: Statement, rowMapper: RowMapper<T>): Result<List<T>> =
+        fetchAll(statement.render(connection.encoders()), rowMapper)
+
+    override suspend fun begin(): Result<Transaction> = runCatching {
+        mutex.withLock {
+            assertIsOpen()
+            return connection.begin()
+        }
+    }
+
     companion object {
         private val TIME_SOURCE = TimeSource.Monotonic
     }

sqlx4k/src/commonTest/kotlin/io/github/smyrgeorge/sqlx4k/impl/pool/ConnectionPoolErrorHandlingTests.kt

@@ -10,6 +10,7 @@ import io.github.smyrgeorge.sqlx4k.impl.pool.util.FakeConnection
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
 import kotlin.test.Test
+import kotlin.test.assertFails
 import kotlin.test.assertFailsWith
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.milliseconds
@@ -55,13 +56,12 @@ class ConnectionPoolErrorHandlingTests {
     }
 
     @Test
-    fun `Multiple release calls on same connection are idempotent`() = runBlocking {
+    fun `Multiple release calls on same connection should fail`() = runBlocking {
         val pool = newPool(max = 1)
 
         val c = pool.acquire().getOrThrow()
         c.close().getOrThrow()
-        c.close().getOrThrow()  // Second release should be safe
-        c.close().getOrThrow()  // Third release should be safe
+        assertFails { c.close().getOrThrow() }
 
         assertThat(pool.poolIdleSize()).isEqualTo(1)
         assertThat(pool.poolSize()).isEqualTo(1)