docs/usage/multi-level.md

@@ -62,7 +62,7 @@ import fr.postgresjson.connexion.Requester
 val requester: Requester = TODO()
 val result: Parent = requester
     .getFunction("find_parent_by_id")
-    .selectOne("id" to "379e0687-9e4a-4781-b0e9-d94a62e4261f")
+    .execute("id" to "379e0687-9e4a-4781-b0e9-d94a62e4261f")
 ```
 
 The requester create dynamically this request

docs/usage/paginated.md

@@ -1,19 +0,0 @@
-Paginated request
-=================
-
-```kotlin
-import fr.postgresjson.connexion.Paginated
-import fr.postgresjson.connexion.Requester
-import java.util.UUID
-
-class Article(val id: UUID, val name: String)
-
-val request: Requester = TODO()
-val article: Paginated<Article> = requester
-    .getFunction("find_articles")
-    .select(
-        page = 1, 
-        limit = 10, 
-        "id" to "4a04820e-f880-4d80-b1c9-aeacccb24977"
-    )
-```

docs/usage/raw-request.md

@@ -26,10 +26,10 @@ data class Inventor(
     val id: UUID = UUID.randomUUID(),
     val name: String,
     val roles: List<String> = listOf(),
-): Serializable
+)
 
 // Select one entity
-val result: Inventor? = connection.selectOne(
+val result: Inventor = connection.execute(
     """
     SELECT json_build_object(
         'id', '9e65de49-712e-47ce-8bf2-dfffae53a82e', 
@@ -40,7 +40,7 @@ val result: Inventor? = connection.selectOne(
 )
 
 // Select multiple entities
-val result = connection.select<List<Inventor>>(
+val result = connection.execute<List<Inventor>>(
     """
     SELECT json_build_array(
         json_build_object(
@@ -60,7 +60,7 @@ val result = connection.select<List<Inventor>>(
 )
 
 // Select multiple with real query
-val result: List<Inventor> = connection.select(
+val result: List<Inventor> = connection.execute(
     """
         select json_agg(i)
         from inventor i
@@ -71,7 +71,7 @@ val result: List<Inventor> = connection.select(
 
 
 // Select multiple with only some rows
-val result: List<Inventor> = connection.select(
+val result: List<Inventor> = connection.execute(
     """
         select json_agg(i)
         from (

docs/usage/stored-procedure.md

@@ -22,7 +22,6 @@ val requester = Requester(
 ```kotlin
 import java.util.UUID
 import org.joda.time.DateTime
-import fr.postgresjson.entity.Serializable
 
 enum class Roles { ROLE_USER, ROLE_ADMIN }
 
@@ -31,15 +30,16 @@ class User(
     override var username: String,
     var blockedAt: DateTime? = null,
     var roles: List<Roles> = emptyList()
-): Serializable
+)
 
+@SqlSerializable
 class UserForCreate(
     id: UUID = UUID.randomUUID(),
     username: String,
     val password: String,
     blockedAt: DateTime? = null,
     roles: List<Roles> = emptyList()
-): Serializable
+)
 ```
 3. and, define Repositories
 [See SQL function](../migrations/migrations.md)
@@ -53,19 +53,14 @@ class UserRepository(override var requester: Requester): RepositoryI {
     fun findById(id: UUID): User {
         return requester
             .getFunction("find_user_by_id") // Use the name of the function
-            .selectOne(
+            .execute("id" to id) // You can pass parameters by their names. The underscore prefix on parameters is not required to be mapped. 
-                "id" to id // You can pass parameters by their names. The underscore prefix on parameters is not required to be mapped. 
+            // Throw exception if user not found
-            ) ?: throw UserNotFound(id) // Throw exception if user not found
     }
 
     fun insert(user: UserForCreate): User {
         return requester
             .getFunction("insert_user")
-            .selectOne("resource" to user)
+            .execute("resource" to user)
-    }
-
-    class UserNotFound(override val message: String?, override val cause: Throwable?): Throwable(message, cause) {
-        constructor(id: UUID): this("No User with ID $id", null)
     }
 }
 ```

docs/usage/usage.md

@@ -3,5 +3,4 @@
 1. [Init connection](./init-connection.md)
 2. [Raw request](./raw-request.md)
 3. [Stored Procedure](./stored-procedure.md)
-4. [Paginated request](./paginated.md)
+4. [Multi level request](./multi-level.md)
-5. [Multi level request](./multi-level.md)

src/main/kotlin/fr/postgresjson/connexion/Connection.kt

@@ -3,21 +3,19 @@ package fr.postgresjson.connexion
 import com.fasterxml.jackson.core.type.TypeReference
 import com.github.jasync.sql.db.QueryResult
 import com.github.jasync.sql.db.ResultSet
-import com.github.jasync.sql.db.general.ArrayRowData
 import com.github.jasync.sql.db.pool.ConnectionPool
 import com.github.jasync.sql.db.postgresql.PostgreSQLConnection
 import com.github.jasync.sql.db.postgresql.PostgreSQLConnectionBuilder
 import com.github.jasync.sql.db.util.length
-import fr.postgresjson.entity.EntityI
-import fr.postgresjson.entity.Serializable
 import fr.postgresjson.serializer.Serializer
 import fr.postgresjson.utils.LoggerDelegate
+import kotlin.jvm.Throws
 import org.slf4j.Logger
 import kotlin.random.Random
+import kotlin.reflect.full.hasAnnotation
 
-typealias SelectOneCallback<T> = QueryResult.(T?) -> Unit
+// TODO move execute function outside
-typealias SelectCallback<T> = QueryResult.(List<T>) -> Unit
+// TODO create function executeNullable
-typealias SelectPaginatedCallback<T> = QueryResult.(Paginated<T>) -> Unit
 
 class Connection(
     private val database: String,
@@ -25,18 +23,18 @@ class Connection(
     private val password: String,
     private val host: String = "localhost",
     private val port: Int = 5432
-) : Executable {
+) : ExecutableRaw {
-    private var connection: ConnectionPool<PostgreSQLConnection>? = null
+    private var connectionPool: ConnectionPool<PostgreSQLConnection>? = null
     private val serializer = Serializer()
     private val logger: Logger? by LoggerDelegate()
 
     internal fun connect(): ConnectionPool<PostgreSQLConnection> {
-        return connection.let { connectionPool ->
+        return connectionPool.let { connectionPool ->
             if (connectionPool == null || !connectionPool.isConnected()) {
                 PostgreSQLConnectionBuilder.createConnectionPool(
                     "jdbc:postgresql://$host:$port/$database?user=$username&password=$password"
                 ).also {
-                    connection = it
+                    this.connectionPool = it
                 }
             } else {
                 connectionPool
@@ -45,7 +43,7 @@ class Connection(
     }
 
     fun disconnect() {
-        connection?.disconnect()
+        connectionPool?.disconnect()
     }
 
     fun <A> inTransaction(block: Connection.() -> A?): A? = connect().run {
@@ -59,16 +57,19 @@ class Connection(
     }
 
     /**
-     * Select One [EntityI] with [List] of parameters
+     * Select with unnamed parameters
      */
-    override fun <R : EntityI> selectOne(
+    @Throws(DataNotFoundException::class)
+    override fun <R : Any> execute(
         sql: String,
         typeReference: TypeReference<R>,
         values: List<Any?>,
-        block: (QueryResult, R?) -> Unit
+        block: SelectCallback<R>
     ): R? {
-        val result = exec(sql, compileArgs(values))
+        val result: QueryResult = exec(sql, compileArgs(values))
-        val json = result.rows.firstOrNull()?.getString(0)
+        if (result.rows.size == 0) throw DataNotFoundException(sql)
+
+        val json: String? = result.rows.firstOrNull()?.getString(0)
         return if (json === null) {
             null
         } else {
@@ -79,119 +80,16 @@ class Connection(
     }
 
     /**
-     * Select One [EntityI] with named parameters
+     * Select with named parameters
      */
-    override fun <R : EntityI> selectOne(
+    override fun <R : Any> execute(
         sql: String,
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
-        block: (QueryResult, R?) -> Unit
+        block: SelectCallback<R>
     ): R? {
         return replaceArgs(sql, values) {
-            selectOne(this.sql, typeReference, parameters, block)
+            execute(this.sql, typeReference, parameters, block)
-        }
-    }
-
-    /* Select Multiples */
-
-    /**
-     * Select multiple [EntityI] with [List] of parameters
-     */
-    override fun <R : EntityI> select(
-        sql: String,
-        typeReference: TypeReference<List<R>>,
-        values: List<Any?>,
-        block: QueryResult.(List<R>) -> Unit
-    ): List<R> {
-        val result = exec(sql, values)
-        val json = result.rows[0].getString(0)
-        return if (json === null) {
-            emptyList()
-        } else {
-            serializer.deserializeList(json, typeReference)
-        }.also {
-            block(result, it)
-        }
-    }
-
-    /**
-     * Select multiple [EntityI] with [Map] of parameters
-     */
-    override fun <R : EntityI> select(
-        sql: String,
-        typeReference: TypeReference<List<R>>,
-        values: Map<String, Any?>,
-        block: QueryResult.(List<R>) -> Unit
-    ): List<R> {
-        return replaceArgs(sql, values) {
-            select(this.sql, typeReference, this.parameters, block)
-        }
-    }
-
-    /**
-     * Select multiple or one [EntityI] with [Map] of parameters
-     */
-    override fun <R : Any?> selectAny(
-        sql: String,
-        typeReference: TypeReference<R>,
-        values: Map<String, Any?>,
-        block: QueryResult.(R) -> Unit
-    ): R {
-        val result = exec(sql, values)
-        val json = result.rows[0].getString(0)
-        return if (json === null) {
-            null as R
-        } else {
-            serializer.deserialize(json, typeReference)
-        }.also {
-            block(result, it)
-        }
-    }
-
-    /* Select Paginated */
-
-    /**
-     * Select Multiple [EntityI] with pagination
-     */
-    override fun <R : EntityI> select(
-        sql: String,
-        page: Int,
-        limit: Int,
-        typeReference: TypeReference<List<R>>,
-        values: Map<String, Any?>,
-        block: QueryResult.(Paginated<R>) -> Unit
-    ): Paginated<R> {
-        val offset = (page - 1) * limit
-        val newValues = values
-            .plus("offset" to offset)
-            .plus("limit" to limit)
-
-        val line = replaceArgs(sql, newValues) {
-            exec(this.sql, this.parameters)
-        }
-
-        return line.run {
-            val firstLine = rows.firstOrNull() ?: queryError("The query has no return", sql, newValues)
-            if (!rows.columnNames().contains("total")) queryError("""The query not return the "total" column""", sql, newValues, rows)
-            val total = try {
-                firstLine.getInt("total") ?: queryError("The query return \"total\" must not be null", sql, newValues, rows)
-            } catch (e: ClassCastException) {
-                queryError("""Column "total" must be an integer""", sql, newValues, rows)
-            }
-            val json = firstLine.getString(0)
-            val entities = if (json == null) {
-                emptyList()
-            } else {
-                serializer.deserializeList(json, typeReference)
-            }
-            Paginated(
-                entities,
-                offset,
-                limit,
-                total
-            )
-        }.also {
-            block(line, it)
         }
     }
 
@@ -231,10 +129,12 @@ class Connection(
 
     private fun compileArgs(values: List<Any?>): List<Any?> {
         return values.map {
-            if (it is Serializable || (it is List<*> && it.firstOrNull() is Serializable)) {
+            when {
-                serializer.serialize(it)
+                it == null -> it
-            } else {
+                it is List<*> && it.isEmpty() -> it
-                it
+                it is List<*> && it.first()!!::class.hasAnnotation<SqlSerializable>() -> serializer.serialize(it)
+                it::class.hasAnnotation<SqlSerializable>() -> serializer.serialize(it)
+                else -> it
             }
         }
     }

src/main/kotlin/fr/postgresjson/connexion/DataNotFoundException.kt

@@ -0,0 +1,6 @@
+package fr.postgresjson.connexion
+
+class DataNotFoundException(val queryExecuted: String): Exception() {
+    override val message: String
+        get() = "No data return for the query"
+}

src/main/kotlin/fr/postgresjson/connexion/EmbedExecutable.kt

@@ -2,116 +2,43 @@ package fr.postgresjson.connexion
 
 import com.fasterxml.jackson.core.type.TypeReference
 import com.github.jasync.sql.db.QueryResult
-import fr.postgresjson.entity.EntityI
+import kotlin.jvm.Throws
 
-sealed interface EmbedExecutable {
+sealed interface EmbedExecutable : Executable {
     val connection: Connection
     override fun toString(): String
     val name: String
 
-    /* Select One */
-
     /**
-     * Update [EntityI] with one entity as argument
+     * Select with unnamed parameters
      */
-    fun <R : EntityI> update(
+    @Throws(DataNotFoundException::class)
-        typeReference: TypeReference<R>,
+    fun <R : Any> execute(
-        value: R,
-        block: SelectOneCallback<R> = {}
-    ): R? =
-        selectOne(typeReference, listOf(value), block)
-
-    /**
-     * Select One [EntityI] with [List] of parameters
-     */
-    fun <R : EntityI> selectOne(
         typeReference: TypeReference<R>,
         values: List<Any?>,
-        block: SelectOneCallback<R> = {}
+        block: SelectCallback<R> = {}
     ): R?
 
     /**
-     * Select One [EntityI] with [Map] of parameters
+     * Select with named parameters
      */
-    fun <R : EntityI> selectOne(
+    @Throws(DataNotFoundException::class)
+    fun <R : Any> execute(
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
-        block: SelectOneCallback<R> = {}
+        block: SelectCallback<R> = {}
     ): R?
 
     /**
-     * Select One [EntityI] with multiple [Pair] of parameters
+     * Select with named parameters
      */
-    fun <R : EntityI> selectOne(
+    @Throws(DataNotFoundException::class)
+    fun <R : Any> execute(
         typeReference: TypeReference<R>,
         vararg values: Pair<String, Any?>,
-        block: SelectOneCallback<R> = {}
+        block: SelectCallback<R> = {}
     ): R? =
-        selectOne(typeReference, values.toMap(), block)
+        execute(typeReference, values.toMap(), block)
-
-    /* Select Multiples */
-
-    /**
-     * Select Multiple [EntityI] with [List] of parameters
-     */
-    fun <R : EntityI> select(
-        typeReference: TypeReference<List<R>>,
-        values: List<Any?>,
-        block: SelectCallback<R> = {}
-    ): List<R>
-
-    /**
-     * Select Multiple [EntityI] with [Map] of parameters
-     */
-    fun <R : EntityI> select(
-        typeReference: TypeReference<List<R>>,
-        values: Map<String, Any?>,
-        block: SelectCallback<R> = {}
-    ): List<R>
-
-    /**
-     * Select Multiple [EntityI] with multiple [Pair] of parameters
-     */
-    fun <R : EntityI> select(
-        typeReference: TypeReference<List<R>>,
-        vararg values: Pair<String, Any?>,
-        block: SelectCallback<R> = {}
-    ): List<R> =
-        select(typeReference, values.toMap(), block)
-
-    /**
-     * Select Multiple or One [EntityI] with multiple [Pair] of parameters
-     */
-    fun <R : Any?> selectAny(
-        typeReference: TypeReference<R>,
-        values: Map<String, Any?>,
-        block: QueryResult.(R) -> Unit = {}
-    ): R
-
-    /* Select Paginated */
-
-    /**
-     * Select Paginated [EntityI] with [Map] of parameters
-     */
-    fun <R : EntityI> select(
-        page: Int,
-        limit: Int,
-        typeReference: TypeReference<List<R>>,
-        values: Map<String, Any?>,
-        block: SelectPaginatedCallback<R> = {}
-    ): Paginated<R>
-
-    /**
-     * Select Paginated [EntityI] with multiple [Pair] of parameters
-     */
-    fun <R : EntityI> select(
-        page: Int,
-        limit: Int,
-        typeReference: TypeReference<List<R>>,
-        vararg values: Pair<String, Any?>,
-        block: SelectPaginatedCallback<R> = {}
-    ): Paginated<R> =
-        select(page, limit, typeReference, values.toMap(), block)
 
     fun exec(values: List<Any?>): QueryResult
     fun exec(values: Map<String, Any?>): QueryResult

src/main/kotlin/fr/postgresjson/connexion/EmbedExecutableReified.kt

@@ -1,68 +1,25 @@
 package fr.postgresjson.connexion
 
 import com.fasterxml.jackson.core.type.TypeReference
-import fr.postgresjson.entity.EntityI
+import kotlin.jvm.Throws
 
-/* Select One */
+@Throws(DataNotFoundException::class)
-
+inline fun <reified R : Any> EmbedExecutable.execute(
-inline fun <reified R : EntityI> EmbedExecutable.update(
-    value: R,
-    noinline block: SelectOneCallback<R> = {}
-): R? =
-    update(object : TypeReference<R>() {}, value, block)
-
-inline fun <reified R : EntityI> EmbedExecutable.selectOne(
-    values: List<Any?>,
-    noinline block: SelectOneCallback<R> = {}
-): R? =
-    selectOne(object : TypeReference<R>() {}, values, block)
-
-inline fun <reified R : EntityI> EmbedExecutable.selectOne(
-    values: Map<String, Any?>,
-    noinline block: SelectOneCallback<R> = {}
-): R? =
-    selectOne(object : TypeReference<R>() {}, values, block)
-
-inline fun <reified R : EntityI> EmbedExecutable.selectOne(
-    vararg values: Pair<String, Any?>,
-    noinline block: SelectOneCallback<R> = {}
-): R? =
-    selectOne(object : TypeReference<R>() {}, values = values, block)
-
-/* Select Multiples */
-
-inline fun <reified R : EntityI> EmbedExecutable.select(
     values: List<Any?>,
     noinline block: SelectCallback<R> = {}
-): List<R> =
+): R? =
-    select(object : TypeReference<List<R>>() {}, values, block)
+    execute(object : TypeReference<R>() {}, values, block)
 
-inline fun <reified R : EntityI> EmbedExecutable.select(
+@Throws(DataNotFoundException::class)
+inline fun <reified R : Any> EmbedExecutable.execute(
     values: Map<String, Any?>,
     noinline block: SelectCallback<R> = {}
-): List<R> =
+): R? =
-    select(object : TypeReference<List<R>>() {}, values, block)
+    execute(object : TypeReference<R>() {}, values, block)
 
-inline fun <reified R : EntityI> EmbedExecutable.select(
+@Throws(DataNotFoundException::class)
+inline fun <reified R : Any> EmbedExecutable.execute(
     vararg values: Pair<String, Any?>,
     noinline block: SelectCallback<R> = {}
-): List<R> =
+): R? =
-    select(object : TypeReference<List<R>>() {}, values = values, block)
+    execute(object : TypeReference<R>() {}, values = values, block)
-
-/* Select Paginated */
-
-inline fun <reified R : EntityI> EmbedExecutable.select(
-    page: Int,
-    limit: Int,
-    values: Map<String, Any?> = emptyMap(),
-    noinline block: SelectPaginatedCallback<R> = {}
-): Paginated<R> =
-    select(page, limit, object : TypeReference<List<R>>() {}, values, block)
-
-inline fun <reified R : EntityI> EmbedExecutable.select(
-    page: Int,
-    limit: Int,
-    vararg values: Pair<String, Any?>,
-    noinline block: SelectPaginatedCallback<R> = {}
-): Paginated<R> =
-    select(page, limit, object : TypeReference<List<R>>() {}, values = values, block)

src/main/kotlin/fr/postgresjson/connexion/Executable.kt

@@ -1,146 +1,3 @@
 package fr.postgresjson.connexion
 
-import com.fasterxml.jackson.core.type.TypeReference
+sealed interface Executable
-import com.github.jasync.sql.db.QueryResult
-import fr.postgresjson.entity.EntityI
-
-interface Executable {
-
-    /* Update */
-
-    /**
-     * Update [EntityI] with one entity as argument
-     */
-    fun <R : EntityI> update(
-        sql: String,
-        typeReference: TypeReference<R>,
-        value: R,
-        block: SelectOneCallback<R> = {}
-    ): R? =
-        selectOne(sql, typeReference, listOf(value), block)
-
-    /* Select One */
-
-    /**
-     * Select One [EntityI] with [List] of parameters
-     */
-    fun <R : EntityI> selectOne(
-        sql: String,
-        typeReference: TypeReference<R>,
-        values: List<Any?>,
-        block: SelectOneCallback<R> = {}
-    ): R?
-
-    /**
-     * Select One [EntityI] with [Map] of parameters
-     */
-    fun <R : EntityI> selectOne(
-        sql: String,
-        typeReference: TypeReference<R>,
-        values: Map<String, Any?>,
-        block: SelectOneCallback<R> = {}
-    ): R?
-
-    /**
-     * Select One [EntityI] with multiple [Pair] of parameters
-     */
-    fun <R : EntityI> selectOne(
-        sql: String,
-        typeReference: TypeReference<R>,
-        vararg values: Pair<String, Any?>,
-        block: SelectOneCallback<R> = {}
-    ): R? =
-        selectOne(sql, typeReference, values.toMap(), block)
-
-    /* Select Multiples */
-
-    /**
-     * Select Multiple [EntityI] with [List] of parameters
-     */
-    fun <R : EntityI> select(
-        sql: String,
-        typeReference: TypeReference<List<R>>,
-        values: List<Any?> = emptyList(),
-        block: SelectCallback<R> = {}
-    ): List<R>
-
-    /**
-     * Select Multiple [EntityI] with [Map] of parameters
-     */
-    fun <R : EntityI> select(
-        sql: String,
-        typeReference: TypeReference<List<R>>,
-        values: Map<String, Any?>,
-        block: SelectCallback<R> = {}
-    ): List<R>
-
-    /**
-     * Select Multiple or One [EntityI] with [Map] of parameters
-     */
-    fun <R : Any?> selectAny(
-        sql: String,
-        typeReference: TypeReference<R>,
-        values: Map<String, Any?>,
-        block: QueryResult.(R) -> Unit = {}
-    ): R
-
-    /**
-     * Select Multiple [EntityI] with multiple [Pair] of parameters
-     */
-    fun <R : EntityI> select(
-        sql: String,
-        typeReference: TypeReference<List<R>>,
-        vararg values: Pair<String, Any?>,
-        block: SelectCallback<R> = {}
-    ): List<R> =
-        select(sql, typeReference, values.toMap(), block)
-
-    /* Select Paginated */
-
-    /**
-     * Select Paginated [EntityI] with [Map] of parameters
-     */
-    fun <R : EntityI> select(
-        sql: String,
-        page: Int,
-        limit: Int,
-        typeReference: TypeReference<List<R>>,
-        values: Map<String, Any?>,
-        block: SelectPaginatedCallback<R> = {}
-    ): Paginated<R>
-
-    /**
-     * Select Paginated [EntityI] with multiple [Pair] of parameters
-     */
-    fun <R : EntityI> select(
-        sql: String,
-        page: Int,
-        limit: Int,
-        typeReference: TypeReference<List<R>>,
-        vararg values: Pair<String, Any?>,
-        block: SelectPaginatedCallback<R> = {}
-    ): Paginated<R> =
-        select(sql, page, limit, typeReference, values.toMap(), block)
-
-    fun <R : EntityI> exec(sql: String, value: R): QueryResult = exec(sql, listOf(value))
-    fun exec(sql: String, values: List<Any?>): QueryResult
-    fun exec(sql: String, values: Map<String, Any?>): QueryResult
-    fun exec(sql: String, vararg values: Pair<String, Any?>): QueryResult = exec(sql, values.toMap())
-
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun <R : EntityI> sendQuery(sql: String, value: R): QueryResult = sendQuery(sql, listOf(value))
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun sendQuery(sql: String, values: List<Any?>): QueryResult
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun sendQuery(sql: String, values: Map<String, Any?>): QueryResult
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun sendQuery(sql: String, vararg values: Pair<String, Any?>): QueryResult = sendQuery(sql, values.toMap())
-}

src/main/kotlin/fr/postgresjson/connexion/ExecutableRaw.kt

@@ -0,0 +1,76 @@
+package fr.postgresjson.connexion
+
+import com.fasterxml.jackson.core.type.TypeReference
+import com.github.jasync.sql.db.QueryResult
+import kotlin.jvm.Throws
+
+typealias SelectCallback<R> = QueryResult.(R?) -> Unit
+
+sealed interface ExecutableRaw : Executable {
+    /**
+     * Select with one entity as argument
+     */
+    @Throws(DataNotFoundException::class)
+    fun <R : Any> execute(
+        sql: String,
+        typeReference: TypeReference<R>,
+        value: R,
+        block: SelectCallback<R> = {}
+    ): R? =
+        execute(sql, typeReference, listOf(value), block)
+
+    /**
+     * Select with [List] of parameters
+     */
+    @Throws(DataNotFoundException::class)
+    fun <R : Any> execute(
+        sql: String,
+        typeReference: TypeReference<R>,
+        values: List<Any?> = emptyList(),
+        block: SelectCallback<R> = {}
+    ): R?
+
+    /**
+     * Select with [Map] of parameters
+     */
+    @Throws(DataNotFoundException::class)
+    fun <R : Any> execute(
+        sql: String,
+        typeReference: TypeReference<R>,
+        values: Map<String, Any?>,
+        block: SelectCallback<R> = {}
+    ): R?
+
+    /**
+     * Select with multiple [Pair] of parameters
+     */
+    @Throws(DataNotFoundException::class)
+    fun <R : Any> execute(
+        sql: String,
+        typeReference: TypeReference<R>,
+        vararg values: Pair<String, Any?>,
+        block: SelectCallback<R> = {}
+    ): R? = execute(sql, typeReference, values.toMap(), block)
+
+    fun <R : Any?> exec(sql: String, value: R): QueryResult = exec(sql, listOf(value))
+    fun exec(sql: String, values: List<Any?>): QueryResult
+    fun exec(sql: String, values: Map<String, Any?>): QueryResult
+    fun exec(sql: String, vararg values: Pair<String, Any?>): QueryResult = exec(sql, values.toMap())
+
+    /**
+     * Warning: this method not use prepared statement
+     */
+    fun <R : Any?> sendQuery(sql: String, value: R): QueryResult = sendQuery(sql, listOf(value))
+    /**
+     * Warning: this method not use prepared statement
+     */
+    fun sendQuery(sql: String, values: List<Any?>): QueryResult
+    /**
+     * Warning: this method not use prepared statement
+     */
+    fun sendQuery(sql: String, values: Map<String, Any?>): QueryResult
+    /**
+     * Warning: this method not use prepared statement
+     */
+    fun sendQuery(sql: String, vararg values: Pair<String, Any?>): QueryResult = sendQuery(sql, values.toMap())
+}

src/main/kotlin/fr/postgresjson/connexion/ExecutableReified.kt

@@ -1,106 +1,37 @@
 package fr.postgresjson.connexion
 
 import com.fasterxml.jackson.core.type.TypeReference
-import fr.postgresjson.entity.EntityI
+import kotlin.jvm.Throws
-
-/* Update */
 
 /**
- * Update [EntityI] with one entity as argument
+ * Select with unnamed parameters
  */
-inline fun <reified R : EntityI> Executable.update(
+@Throws(DataNotFoundException::class)
-    sql: String,
+inline fun <reified R : Any> ExecutableRaw.execute(
-    value: R,
-    noinline block: SelectOneCallback<R> = {}
-): R? =
-    update(sql, object : TypeReference<R>() {}, value, block)
-
-/* Select One */
-
-/**
- * Select One [EntityI] with [List] of parameters
- */
-inline fun <reified R : EntityI> Executable.selectOne(
-    sql: String,
-    values: List<Any?> = emptyList(),
-    noinline block: SelectOneCallback<R> = {}
-): R? =
-    selectOne(sql, object : TypeReference<R>() {}, values, block)
-
-/**
- * Select One [EntityI] with [Map] of parameters
- */
-inline fun <reified R : EntityI> Executable.selectOne(
-    sql: String,
-    values: Map<String, Any?>,
-    noinline block: SelectOneCallback<R> = {}
-): R? =
-    selectOne(sql, object : TypeReference<R>() {}, values, block)
-
-/**
- * Select One [EntityI] with multiple [Pair] of parameters
- */
-inline fun <reified R : EntityI> Executable.selectOne(
-    sql: String,
-    vararg values: Pair<String, Any?>,
-    noinline block: SelectOneCallback<R> = {}
-): R? =
-    selectOne(sql, object : TypeReference<R>() {}, values = values, block)
-
-/* Select Multiples */
-
-/**
- * Select Multiple [EntityI] with [List] of parameters
- */
-inline fun <reified R : EntityI> Executable.select(
     sql: String,
     values: List<Any?> = emptyList(),
     noinline block: SelectCallback<R> = {}
-): List<R> =
+): R? =
-    select(sql, object : TypeReference<List<R>>() {}, values, block)
+    execute(sql, object : TypeReference<R>() {}, values, block)
 
 /**
- * Select Multiple [EntityI] with [Map] of parameters
+ * Select with named parameters
  */
-inline fun <reified R : EntityI> Executable.select(
+@Throws(DataNotFoundException::class)
+inline fun <reified R : Any> ExecutableRaw.execute(
     sql: String,
     values: Map<String, Any?>,
     noinline block: SelectCallback<R> = {}
-): List<R> =
+): R? =
-    select(sql, object : TypeReference<List<R>>() {}, values, block)
+    execute(sql, object : TypeReference<R>() {}, values, block)
 
 /**
- * Select Multiple [EntityI] with multiple [Pair] of parameters
+ * Select with named parameters
  */
-inline fun <reified R : EntityI> Executable.select(
+@Throws(DataNotFoundException::class)
+inline fun <reified R : Any> ExecutableRaw.execute(
     sql: String,
     vararg values: Pair<String, Any?>,
     noinline block: SelectCallback<R> = {}
-): List<R> =
+): R? =
-    select(sql, object : TypeReference<List<R>>() {}, values = values, block)
+    execute(sql, object : TypeReference<R>() {}, values = values, block)
-
-/* Select Paginated */
-
-/**
- * Select Paginated [EntityI] with [Map] of parameters
- */
-inline fun <reified R : EntityI> Executable.select(
-    sql: String,
-    page: Int,
-    limit: Int,
-    values: Map<String, Any?> = emptyMap(),
-    noinline block: SelectPaginatedCallback<R> = {}
-): Paginated<R> =
-    select(sql, page, limit, object : TypeReference<List<R>>() {}, values, block)
-
-/**
- * Select Paginated [EntityI] with multiple [Pair] of parameters
- */
-inline fun <reified R : EntityI> Executable.select(
-    sql: String,
-    page: Int,
-    limit: Int,
-    vararg values: Pair<String, Any?>,
-    noinline block: SelectPaginatedCallback<R> = {}
-): Paginated<R> =
-    select(sql, page, limit, object : TypeReference<List<R>>() {}, values = values, block)

src/main/kotlin/fr/postgresjson/connexion/Function.kt

@@ -3,7 +3,6 @@ package fr.postgresjson.connexion
 import com.fasterxml.jackson.core.type.TypeReference
 import com.github.jasync.sql.db.QueryResult
 import fr.postgresjson.definition.Function
-import fr.postgresjson.entity.EntityI
 
 class Function(val definition: Function, override val connection: Connection) : EmbedExecutable {
     override fun toString(): String {
@@ -12,86 +11,42 @@ class Function(val definition: Function, override val connection: Connection) :
 
     override val name: String = definition.name
 
-    /* Select One */
-
     /**
-     * Select One [EntityI] with [List] of parameters
+     * Select with [List] of parameters
      */
-    override fun <R : EntityI> selectOne(
+    override fun <R : Any> execute(
         typeReference: TypeReference<R>,
         values: List<Any?>,
-        block: (QueryResult, R?) -> Unit
+        block: SelectCallback<R>
     ): R? =
-        connection.selectOne(compileSql(values), typeReference, values, block)
+        connection.execute(compileSql(values), typeReference, values, block)
 
     /**
-     * Select One [EntityI] with named parameters
+     * Select with named parameters
      */
-    override fun <R : EntityI> selectOne(
+    override fun <R : Any> execute(
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
-        block: (QueryResult, R?) -> Unit
+        block: SelectCallback<R>
     ): R? =
-        connection.selectOne(compileSql(values), typeReference, values, block)
+        connection.execute(compileSql(values), typeReference, values, block)
-
-    /* Select Multiples */
 
     /**
-     * Select multiple [EntityI] with [List] of parameters
+     * Execute function without treatments
      */
-    override fun <R : EntityI> select(
-        typeReference: TypeReference<List<R>>,
-        values: List<Any?>,
-        block: (QueryResult, List<R>) -> Unit
-    ): List<R> =
-        connection.select(compileSql(values), typeReference, values, block)
-
-    /**
-     * Select multiple [EntityI] with named parameters
-     */
-    override fun <R : EntityI> select(
-        typeReference: TypeReference<List<R>>,
-        values: Map<String, Any?>,
-        block: (QueryResult, List<R>) -> Unit
-    ): List<R> =
-        connection.select(compileSql(values), typeReference, values, block)
-
-    override fun <R : Any?> selectAny(
-        typeReference: TypeReference<R>,
-        values: Map<String, Any?>,
-        block: QueryResult.(R) -> Unit
-    ): R =
-        connection.selectAny(compileSql(values.toMap()), typeReference, values.toMap(), block)
-
-    /* Select Paginated */
-
-    /**
-     * Select Multiple [EntityI] with pagination
-     */
-    override fun <R : EntityI> select(
-        page: Int,
-        limit: Int,
-        typeReference: TypeReference<List<R>>,
-        values: Map<String, Any?>,
-        block: (QueryResult, Paginated<R>) -> Unit
-    ): Paginated<R> {
-        val offset = (page - 1) * limit
-        val newValues = values
-            .plus("offset" to offset)
-            .plus("limit" to limit)
-
-        return connection.select(compileSql(newValues), page, limit, typeReference, values, block)
-    }
-
-    /* Execute function without treatments */
-
     override fun exec(values: List<Any?>): QueryResult = connection.exec(compileSql(values), values)
 
+    /**
+     * Execute function without treatments
+     */
     override fun exec(values: Map<String, Any?>): QueryResult = connection.exec(compileSql(values), values)
 
-    private fun <R : EntityI> compileArgs(value: R): String = compileArgs(listOf(value))
+    private fun <A : Any?> compileParameters(value: A): String = compileParameters(listOf(value))
 
-    private fun compileArgs(values: List<Any?>): String {
+    /**
+     * Add cast to all parameters
+     */
+    private fun compileParameters(values: List<Any?>): String {
         val placeholders = values
             .filterIndexed { index, value ->
                 definition.parameters[index].default === null || value != null
@@ -103,7 +58,10 @@ class Function(val definition: Function, override val connection: Connection) :
         return placeholders.joinToString(separator = ", ")
     }
 
-    private fun compileArgs(values: Map<String, Any?>): String {
+    /**
+     * Cast and add named parameters
+     */
+    private fun compileParameters(values: Map<String, Any?>): String {
         val parameters = definition.getParametersIndexedByName()
         val placeholders = values
             .filter { entry ->
@@ -118,7 +76,16 @@ class Function(val definition: Function, override val connection: Connection) :
         return placeholders.joinToString(separator = ", ")
     }
 
-    private fun <R : EntityI> compileSql(value: R): String = "SELECT * FROM ${definition.name} (${compileArgs(value)})"
+    /**
-    private fun compileSql(values: List<Any?>): String = "SELECT * FROM ${definition.name} (${compileArgs(values)})"
+     * Create SQL to call the function
-    private fun compileSql(values: Map<String, Any?>): String = "SELECT * FROM ${definition.name} (${compileArgs(values)})"
+     */
+    private fun <A : Any?> compileSql(value: A): String = "SELECT * FROM ${definition.name} (${compileParameters(value)})"
+    /**
+     * Create SQL to call the function
+     */
+    private fun compileSql(values: List<Any?>): String = "SELECT * FROM ${definition.name} (${compileParameters(values)})"
+    /**
+     * Create SQL to call the function
+     */
+    private fun compileSql(values: Map<String, Any?>): String = "SELECT * FROM ${definition.name} (${compileParameters(values)})"
 }

src/main/kotlin/fr/postgresjson/connexion/Paginated.kt

@@ -1,25 +0,0 @@
-package fr.postgresjson.connexion
-
-import fr.postgresjson.entity.EntityI
-import kotlin.math.ceil
-
-data class Paginated<T : EntityI>(
-    val result: List<T>,
-    val offset: Int,
-    val limit: Int,
-    val total: Int
-) {
-    val currentPage: Int = (offset / limit) + 1
-    val count: Int = result.size
-    val totalPages: Int = (total.toDouble() / limit.toDouble()).ceil()
-
-    init {
-        if (offset < 0) error("offset must be greater or equal than 0")
-        if (limit < 1) error("limit must be greater or equal than 1")
-        if (total < 0) error("total must be greater or equal than 0")
-    }
-
-    fun isLastPage(): Boolean = currentPage >= totalPages
-
-    private fun Double.ceil(): Int = ceil(this).toInt()
-}

src/main/kotlin/fr/postgresjson/connexion/Query.kt

@@ -2,81 +2,40 @@ package fr.postgresjson.connexion
 
 import com.fasterxml.jackson.core.type.TypeReference
 import com.github.jasync.sql.db.QueryResult
-import fr.postgresjson.entity.EntityI
 
 class Query(override val name: String, private val sql: String, override val connection: Connection) : EmbedExecutable {
     override fun toString(): String {
         return sql
     }
 
-    /* Select One */
-
     /**
-     * Select One [EntityI] with [List] of parameters
+     * Select with unnamed of parameters
      */
-    override fun <R : EntityI> selectOne(
+    override fun <R : Any> execute(
         typeReference: TypeReference<R>,
         values: List<Any?>,
-        block: SelectOneCallback<R>
+        block: SelectCallback<R>
     ): R? =
-        connection.selectOne(sql, typeReference, values, block)
+        connection.execute(sql, typeReference, values, block)
 
     /**
-     * Select One [EntityI] with named parameters
+     * Select with named parameters
      */
-    override fun <R : EntityI> selectOne(
+    override fun <R : Any> execute(
         typeReference: TypeReference<R>,
         values: Map<String, Any?>,
-        block: SelectOneCallback<R>
+        block: SelectCallback<R>
     ): R? =
-        connection.selectOne(sql, typeReference, values, block)
+        connection.execute(sql, typeReference, values, block)
-
-    /* Select Multiples */
 
     /**
-     * Select multiple [EntityI] with [List] of parameters
+     * Execute function without treatments
      */
-    override fun <R : EntityI> select(
-        typeReference: TypeReference<List<R>>,
-        values: List<Any?>,
-        block: SelectCallback<R>
-    ): List<R> =
-        connection.select(sql, typeReference, values, block)
-
-    /**
-     * Select multiple [EntityI] with [Map] of parameters
-     */
-    override fun <R : EntityI> select(
-        typeReference: TypeReference<List<R>>,
-        values: Map<String, Any?>,
-        block: SelectCallback<R>
-    ): List<R> =
-        connection.select(sql, typeReference, values, block)
-
-    /* Select Paginated */
-
-    /**
-     * Select Multiple [EntityI] with pagination
-     */
-    override fun <R : EntityI> select(
-        page: Int,
-        limit: Int,
-        typeReference: TypeReference<List<R>>,
-        values: Map<String, Any?>,
-        block: (QueryResult, Paginated<R>) -> Unit
-    ): Paginated<R> =
-        connection.select(sql, page, limit, typeReference, values, block)
-
-    override fun <R> selectAny(
-        typeReference: TypeReference<R>,
-        values: Map<String, Any?>,
-        block: QueryResult.(R) -> Unit
-    ): R = connection.selectAny(sql, typeReference, values.toMap(), block)
-
-    /* Execute function without treatments */
-
     override fun exec(values: List<Any?>): QueryResult = connection.exec(sql, values)
 
+    /**
+     * Execute function without treatments
+     */
     override fun exec(values: Map<String, Any?>): QueryResult = connection.exec(sql, values)
 
     /**
@@ -88,6 +47,7 @@ class Query(override val name: String, private val sql: String, override val con
      * Warning: this method not use prepared statement
      */
     fun sendQuery(values: Map<String, Any?>): QueryResult = connection.sendQuery(sql, values)
+
     /**
      * Warning: this method not use prepared statement
      */

src/main/kotlin/fr/postgresjson/connexion/QueryConverter.kt

@@ -4,12 +4,24 @@ import fr.postgresjson.utils.searchSqlFiles
 import java.net.URI
 import fr.postgresjson.definition.Query as QueryDefinition
 
+/**
+ * Convert [QueryDefinition], to runnable [Query]
+ */
 fun QueryDefinition.toRunnable(connection: Connection): Query = Query(name, script, connection)
 
+/**
+ * Convert Sequence of [QueryDefinition], to runnable Sequence of [Query]
+ */
 fun Sequence<QueryDefinition>.toRunnable(connection: Connection): Sequence<Query> = map { it.toRunnable(connection) }
 
+/**
+ * Convert Sequence of [Query], to [Map] of [Query] with name as key
+ */
 fun Sequence<Query>.toMutableMap(): MutableMap<String, Query> = map { it.name to it }.toMap().toMutableMap()
 
+/**
+ * Create a [Map] of [Query] from a [URI] pointing to the queries folder
+ */
 internal fun URI.toQuery(connection: Connection): MutableMap<String, Query> = searchSqlFiles()
     .filterIsInstance(QueryDefinition::class.java)
     .toRunnable(connection)

src/main/kotlin/fr/postgresjson/connexion/SqlSerializable.kt

@@ -0,0 +1,4 @@
+package fr.postgresjson.connexion
+
+@Target(AnnotationTarget.CLASS)
+annotation class SqlSerializable

src/main/kotlin/fr/postgresjson/entity/EntitiesInterfaces.kt

@@ -1,126 +0,0 @@
-package fr.postgresjson.entity
-
-import org.joda.time.DateTime
-import java.util.UUID
-
-interface EntityRefI<T> : EntityI {
-    val id: T
-}
-
-interface UuidEntityI : EntityRefI<UUID> {
-    override val id: UUID
-}
-
-abstract class Entity<T>(override val id: T) : EntityRefI<T>
-open class UuidEntity(id: UUID? = null) : UuidEntityI, Entity<UUID>(id ?: UUID.randomUUID())
-
-/* Version */
-interface EntityVersioning<ID, NUMBER> {
-    val versionNumber: NUMBER
-    val versionId: ID
-}
-
-class UuidEntityVersioning(
-    override val versionNumber: Int,
-    versionId: UUID? = null
-) : EntityVersioning<UUID, Int> {
-    override val versionId: UUID = versionId ?: UUID.randomUUID()
-}
-
-/* Dates */
-interface EntityCreatedAt {
-    val createdAt: DateTime
-}
-interface EntityUpdatedAt {
-    val updatedAt: DateTime
-}
-
-interface EntityDeletedAt {
-    val deletedAt: DateTime?
-    fun isDeleted(): Boolean {
-        return deletedAt?.let {
-            it < DateTime.now()
-        } ?: false
-    }
-}
-
-class EntityCreatedAtImp(
-    override val createdAt: DateTime = DateTime.now()
-) : EntityCreatedAt
-
-class EntityUpdatedAtImp(
-    override val updatedAt: DateTime = DateTime.now()
-) : EntityUpdatedAt
-
-class EntityDeletedAtImp(
-    override val deletedAt: DateTime? = null
-) : EntityDeletedAt
-
-/* Author */
-interface EntityCreatedBy<T : EntityI> {
-    val createdBy: T
-}
-interface EntityUpdatedBy<T : EntityI> {
-    val updatedBy: T
-}
-
-interface EntityDeletedBy<T : EntityI> {
-    val deletedBy: T?
-}
-
-class EntityCreatedByImp<UserT : EntityI>(
-    override val createdBy: UserT
-) : EntityCreatedBy<UserT>
-
-class EntityUpdatedByImp<UserT : EntityI>(
-    override val updatedBy: UserT
-) : EntityUpdatedBy<UserT>
-
-class EntityDeletedByImp<UserT : EntityI>(
-    override val deletedBy: UserT?
-) : EntityDeletedBy<UserT>
-
-/* Mixed */
-class EntityCreatedImp<UserT : EntityI>(
-    override val createdAt: DateTime = DateTime.now(),
-    createdBy: UserT
-) : EntityCreatedBy<UserT> by EntityCreatedByImp(createdBy),
-    EntityCreatedAt by EntityCreatedAtImp()
-
-class EntityUpdatedImp<UserT : EntityI>(
-    updatedAt: DateTime = DateTime.now(),
-    override val updatedBy: UserT
-) : EntityUpdatedBy<UserT>,
-    EntityUpdatedAt by EntityUpdatedAtImp(updatedAt)
-
-/* Published */
-interface Published<UserT : EntityI> {
-    val publishedAt: DateTime?
-    val publishedBy: UserT?
-}
-
-class EntityPublishedImp<UserT : EntityI>(
-    override val publishedBy: UserT?
-) : Published<UserT> {
-    override val publishedAt: DateTime? = null
-}
-
-/* Implementation */
-abstract class EntityImp<T, UserT : EntityI>(
-    updatedBy: UserT,
-    updatedAt: DateTime = DateTime.now()
-) : UuidEntity(),
-    EntityCreatedAt by EntityCreatedAtImp(updatedAt),
-    EntityUpdatedAt by EntityUpdatedAtImp(updatedAt),
-    EntityDeletedAt by EntityDeletedAtImp(),
-    EntityCreatedBy<UserT> by EntityCreatedByImp(updatedBy),
-    EntityUpdatedBy<UserT> by EntityUpdatedByImp(updatedBy),
-    EntityDeletedBy<UserT> by EntityDeletedByImp(updatedBy)
-
-abstract class UuidEntityExtended<T, UserT : EntityI>(
-    updatedBy: UserT,
-    publishedBy: UserT?
-) :
-    EntityImp<T, UserT>(updatedBy),
-    EntityVersioning<UUID, Int> by UuidEntityVersioning(0),
-    Published<UserT> by EntityPublishedImp(publishedBy)

src/main/kotlin/fr/postgresjson/entity/Entity.kt

@@ -1,5 +0,0 @@
-package fr.postgresjson.entity
-
-interface Serializable
-interface EntityI : Serializable
-interface Parameter : Serializable

src/main/kotlin/fr/postgresjson/functionGenerator/FunctionGenerator.kt

@@ -103,23 +103,21 @@ class FunctionGenerator(private val functionsDirectories: List<URI>) {
         val hasReturn: Boolean = parameters.any { it.direction != IN } || (returns != "" && returns != "void")
 
         val generics = mutableListOf<String>()
-        if (hasReturn) generics.add("reified E: Any?")
+        if (hasReturn) generics.add("reified E: Any")
-        if (hasInputArgs) generics.add("S: Serializable")
+        if (hasInputArgs) generics.add("S: Any?")
 
         val functionDecl = if (generics.isNotEmpty()) "inline fun <${generics.joinToString(", ")}>" else "fun"
 
-        val importSerializable = if (hasInputArgs) "import fr.postgresjson.entity.Serializable\n" else ""
-
         if (hasReturn) {
             return """
             |package fr.postgresjson.functionGenerator.generated
             |
             |import com.fasterxml.jackson.core.type.TypeReference
             |import fr.postgresjson.connexion.Requester
-            |$importSerializable
+            |
-            |$functionDecl Requester.$kotlinName($args): E {
+            |$functionDecl Requester.$kotlinName($args): E? {
             |    return getFunction("$name")
-            |        .selectAny<E>(object : TypeReference<E>() {}, ${parameters.toMapOf()})
+            |        .execute<E>(object : TypeReference<E>() {}, ${parameters.toMapOf()})
             |}
         """.trimMargin()
         } else {
@@ -127,7 +125,7 @@ class FunctionGenerator(private val functionsDirectories: List<URI>) {
             |package fr.postgresjson.functionGenerator.generated
             |
             |import fr.postgresjson.connexion.Requester
-            |$importSerializable
+            |
             |$functionDecl Requester.$kotlinName($args): Unit {
             |    getFunction("$name")
             |        .exec(${parameters.toMapOf()})

src/main/kotlin/fr/postgresjson/migration/Function.kt

@@ -2,7 +2,7 @@ package fr.postgresjson.migration
 
 import com.github.jasync.sql.db.postgresql.exceptions.GenericDatabaseException
 import fr.postgresjson.connexion.Connection
-import fr.postgresjson.connexion.selectOne
+import fr.postgresjson.connexion.execute
 import fr.postgresjson.migration.Migration.Action
 import fr.postgresjson.migration.Migration.Status
 import java.util.Date
@@ -50,11 +50,11 @@ data class Function(
 
             this::class.java.classLoader
                 .getResource("sql/migration/insertFunction.sql")!!.readText()
-                .let { connection.selectOne<MigrationEntity>(it, listOf(up.name, up.getDefinition(), up.script, down.script)) }
+                .let { connection.execute<MigrationEntity>(it, listOf(up.name, up.getDefinition(), up.script, down.script)) }
-                ?.let { function ->
+                ?.let { migration: MigrationEntity ->
-                    executedAt = function.executedAt
+                    executedAt = migration.executedAt
                     doExecute = Action.OK
-                }
+                } ?: error("No migration executed")
 
             Status.OK
         } catch (e: Throwable) {

src/main/kotlin/fr/postgresjson/migration/MigrationScript.kt

@@ -1,9 +1,9 @@
 package fr.postgresjson.migration
 
 import fr.postgresjson.connexion.Connection
-import fr.postgresjson.connexion.selectOne
+import fr.postgresjson.connexion.execute
-import fr.postgresjson.entity.Entity
 import fr.postgresjson.migration.Migration.Action
+import fr.postgresjson.migration.Migration.Status
 import java.util.Date
 
 data class MigrationScript(
@@ -12,40 +12,44 @@ data class MigrationScript(
     val down: String,
     private val connection: Connection,
     override var executedAt: Date? = null
-) : Migration, Entity<String?>(name) {
+) : Migration {
     override var doExecute: Action? = null
 
-    override fun up(): Migration.Status {
+    override fun up(): Status {
-        connection.sendQuery(up)
+        return try {
+            connection.sendQuery(up)
 
-        this::class.java.classLoader.getResource("sql/migration/insertHistory.sql")!!.readText().let {
+            this::class.java.classLoader.getResource("sql/migration/insertHistory.sql")!!.readText().let {
-            connection.selectOne<MigrationEntity>(it, listOf(name, up, down))?.let { query ->
+                connection.execute<MigrationEntity>(it, listOf(name, up, down))?.let { query ->
-                executedAt = query.executedAt
+                    executedAt = query.executedAt
-                doExecute = Action.OK
+                    doExecute = Action.OK
+                } ?: error("No migration executed")
             }
-        }
 
-        return Migration.Status.OK
+            Status.OK
+        } catch (e: Throwable) {
+            Status.UP_FAIL
+        }
     }
 
-    override fun down(): Migration.Status {
+    override fun down(): Status {
         connection.sendQuery(down)
 
         this::class.java.classLoader.getResource("sql/migration/deleteHistory.sql")!!.readText().let {
             connection.exec(it, listOf(name))
         }
 
-        return Migration.Status.OK
+        return Status.OK
     }
 
-    override fun test(): Migration.Status {
+    override fun test(): Status {
         connection.inTransaction {
             up()
             down()
             sendQuery("ROLLBACK")
         }
 
-        return Migration.Status.OK
+        return Status.OK
     }
 
     fun copy(): MigrationScript {

src/main/kotlin/fr/postgresjson/migration/Migrations.kt

@@ -2,7 +2,6 @@ package fr.postgresjson.migration
 
 import com.fasterxml.jackson.core.type.TypeReference
 import fr.postgresjson.connexion.Connection
-import fr.postgresjson.entity.Entity
 import fr.postgresjson.migration.Migration.Action
 import fr.postgresjson.migration.Migration.Status
 import fr.postgresjson.utils.LoggerDelegate
@@ -20,7 +19,7 @@ class MigrationEntity(
     val up: String,
     val down: String,
     val version: Int
-) : Entity<String?>(filename)
+)
 
 interface Migration {
     var executedAt: Date?
@@ -76,15 +75,15 @@ class Migrations private constructor(
      */
     private fun getMigrationFromDB() {
         this::class.java.classLoader.getResource("sql/migration/findAllFunction.sql")!!.readText().let {
-            connection.select(it, object : TypeReference<List<MigrationEntity>>() {})
+            connection.execute(it, object : TypeReference<List<MigrationEntity>>() {})
-                .map { function ->
+                ?.map { function ->
                     functions[function.filename] = Function(function.up, function.down, connection, function.executedAt)
                 }
         }
 
         this::class.java.classLoader.getResource("sql/migration/findAllHistory.sql")!!.readText().let {
-            connection.select(it, object : TypeReference<List<MigrationEntity>>() {})
+            connection.execute(it, object : TypeReference<List<MigrationEntity>>() {})
-                .map { query ->
+                ?.map { query ->
                     migrationsScripts[query.filename] = MigrationScript(query.filename, query.up, query.down, connection, query.executedAt)
                 }
         }

src/main/kotlin/fr/postgresjson/serializer/Serializer.kt

@@ -9,7 +9,7 @@ import com.fasterxml.jackson.databind.module.SimpleModule
 import com.fasterxml.jackson.datatype.joda.JodaModule
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.fasterxml.jackson.module.kotlin.readValue
-import fr.postgresjson.entity.Serializable
+import com.github.jasync.sql.db.QueryResult
 
 class Serializer(val mapper: ObjectMapper = jacksonObjectMapper()) {
     init {
@@ -44,8 +44,13 @@ class Serializer(val mapper: ObjectMapper = jacksonObjectMapper()) {
     }
 }
 
-fun Serializable.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
+inline fun <reified E : Any?> QueryResult.deserialize(): E? {
-fun List<Serializable>.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
+    val value = this.rows.firstOrNull()?.getString(0)
-inline fun <reified E : Serializable> String.deserialize() = Serializer().deserialize<E>(this)
+    return if (value == null) {
+        null
+    } else {
+        Serializer().deserialize<E>(value)
+    }
+}
 
-inline fun <reified T : Serializable> T.toTypeReference(): TypeReference<T> = object : TypeReference<T>() {}
+inline fun <reified T : Any> T.toTypeReference(): TypeReference<T> = object : TypeReference<T>() {}

src/test/kotlin/fr/postgresjson/ConnectionTest.kt

@@ -1,48 +1,59 @@
 package fr.postgresjson
 
 import com.fasterxml.jackson.core.type.TypeReference
-import fr.postgresjson.connexion.Connection.QueryError
+import fr.postgresjson.connexion.DataNotFoundException
-import fr.postgresjson.connexion.Paginated
+import fr.postgresjson.connexion.SqlSerializable
-import fr.postgresjson.connexion.select
+import fr.postgresjson.connexion.execute
-import fr.postgresjson.connexion.selectOne
-import fr.postgresjson.entity.Parameter
-import fr.postgresjson.entity.UuidEntity
 import fr.postgresjson.serializer.deserialize
 import fr.postgresjson.serializer.toTypeReference
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import org.junit.jupiter.api.assertThrows
 import java.util.UUID
-import kotlin.test.assertContains
+import kotlin.reflect.full.hasAnnotation
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
+import org.junit.jupiter.api.assertThrows
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class ConnectionTest : TestAbstract() {
-    private class ObjTest(val name: String, id: UUID = UUID.fromString("2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00")) : UuidEntity(id)
+    @SqlSerializable
-    private class ObjTest2(val title: String, var test: ObjTest?) : UuidEntity()
+    private class ObjTest(val name: String, val id: UUID = UUID.fromString("2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00"))
-    private class ObjTest3(val first: String, var second: String, var third: Int) : UuidEntity()
+    @SqlSerializable
-    private class ObjTestWithParameterObject(var first: ParameterObject, var second: ParameterObject) : UuidEntity()
+    private class ObjTest2(val id: UUID, val title: String, var test: ObjTest?)
-    private class ParameterObject(var third: String) : Parameter
+    @SqlSerializable
+    private class ObjTest3(val id: UUID, val first: String, var second: String, var third: Int)
+    @SqlSerializable
+    private class ObjTestWithParameterObject(val id: UUID, var first: ParameterObject, var second: ParameterObject)
+    @SqlSerializable
+    private class ParameterObject(var third: String)
+    private class ObjTest4(var third: String)
+
+    @Test
+    fun serializable() {
+        assertTrue(ObjTest("plop")::class.hasAnnotation<SqlSerializable>())
+        assertFalse(ObjTest4("plop")::class.hasAnnotation<SqlSerializable>())
+    }
 
     @Test
     fun getObject() {
-        val obj: ObjTest? = connection.selectOne("select to_json(a) from test a limit 1")
+        val obj: ObjTest? = connection.execute("select to_json(a) from test a limit 1")
-        assertTrue(obj is ObjTest)
+        assertNotNull(obj)
         assertEquals(UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"), obj.id)
     }
 
     @Test
     fun getExistingObject() {
-        val objs: List<ObjTest2> = connection.select(
+        val objs: List<ObjTest2>? = connection.execute<List<ObjTest2>>(
             """
             select
                 json_agg(j)
                 FROM (
                 SELECT
-                    t.id, t.title,
+                    t.id, 
+                    t.title,
                     t2 as test
                 from test2 t
                 JOIN test t2 ON t.test_id = t2.id
@@ -57,15 +68,15 @@ class ConnectionTest : TestAbstract() {
 
     @Test
     fun `test call request with args`() {
-        val result: ObjTest? = connection.selectOne("select json_build_object('id', '2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00', 'name', ?::text)", listOf("myName"))
+        val result: ObjTest? = connection.execute("select json_build_object('id', '2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00', 'name', ?::text)", listOf("myName"))
         assertNotNull(result)
         assertEquals("myName", result.name)
     }
 
     @Test
     fun `test call request without args`() {
-        val result: ObjTest? = connection.selectOne("select json_build_object('id', '2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00', 'name', 'myName')", object : TypeReference<ObjTest>() {}) {
+        val result: ObjTest? = connection.execute("select json_build_object('id', '2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00', 'name', 'myName')", object : TypeReference<ObjTest>() {}) {
-            assertEquals("myName", this.rows[0].getString(0)?.deserialize<ObjTest>()?.name)
+            assertEquals("myName", this.deserialize<ObjTest>()?.name)
         }
         assertNotNull(result)
         assertEquals("myName", result.name)
@@ -73,20 +84,21 @@ class ConnectionTest : TestAbstract() {
 
     @Test
     fun `test call request return null`() {
-        val result: ObjTest? = connection.selectOne("select null;", object : TypeReference<ObjTest>() {})
+        val result: ObjTest? = connection.execute("select null;", object : TypeReference<ObjTest>() {})
         assertNull(result)
     }
 
     @Test
     fun `test call request return nothing`() {
-        val result: ObjTest? = connection.selectOne("select * from test where false;", object : TypeReference<ObjTest>() {})
+        assertThrows<DataNotFoundException> {
-        assertNull(result)
+            connection.execute("select * from test where false;", object : TypeReference<ObjTest>() {})
+        }
     }
 
     @Test
     fun callRequestWithArgsEntity() {
         val o = ObjTest("myName", id = UUID.fromString("2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00"))
-        val obj: ObjTest? = connection.selectOne("select json_build_object('id', id, 'name', name) FROM json_to_record(?::json) as o(id uuid, name text);", listOf(o))
+        val obj: ObjTest? = connection.execute("select json_build_object('id', id, 'name', name) FROM json_to_record(?::json) as o(id uuid, name text);", listOf(o))
         assertNotNull(obj)
         assertEquals(UUID.fromString("2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00"), obj.id)
         assertEquals("myName", obj.name)
@@ -95,8 +107,8 @@ class ConnectionTest : TestAbstract() {
     @Test
     fun `test update Entity`() {
         val obj = ObjTest("before", id = UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
-        val objUpdated: ObjTest? = connection.update("select ?::jsonb || jsonb_build_object('name', 'after');", obj.toTypeReference(), obj)
+        val objUpdated: ObjTest? = connection.execute("select ?::jsonb || jsonb_build_object('name', 'after');", obj.toTypeReference(), obj)
-        assertTrue(objUpdated is ObjTest)
+        assertNotNull(objUpdated)
         assertEquals(UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"), objUpdated.id)
         assertEquals("after", objUpdated.name)
     }
@@ -110,8 +122,8 @@ class ConnectionTest : TestAbstract() {
 
     @Test
     fun `select one with named parameters`() {
-        val result: ObjTest3? = connection.selectOne(
+        val result: ObjTest3? = connection.execute(
-            "SELECT json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int)",
+            "SELECT json_build_object('id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 'first', :first::text, 'second', :second::text, 'third', :third::int)",
             mapOf(
                 "first" to "ff",
                 "second" to "sec",
@@ -126,8 +138,8 @@ class ConnectionTest : TestAbstract() {
 
     @Test
     fun `select one with named parameters object`() {
-        val result: ObjTestWithParameterObject? = connection.selectOne(
+        val result: ObjTestWithParameterObject? = connection.execute(
-            "SELECT json_build_object('first', :first::json, 'second', :second::json)",
+            "SELECT json_build_object('id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 'first', :first::json, 'second', :second::json)",
             mapOf(
                 "first" to ParameterObject("one"),
                 "second" to ParameterObject("two")
@@ -140,11 +152,11 @@ class ConnectionTest : TestAbstract() {
 
     @Test
     fun `select with named parameters`() {
-        val result: List<ObjTest3> = connection.select(
+        val result: List<ObjTest3>? = connection.execute(
             """
             SELECT json_build_array(
-                json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int),
+                json_build_object('id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 'first', :first::text, 'second', :second::text, 'third', :third::int),
-                json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int)
+                json_build_object('id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 'first', :first::text, 'second', :second::text, 'third', :third::int)
             )
             """.trimIndent(),
             mapOf(
@@ -153,6 +165,7 @@ class ConnectionTest : TestAbstract() {
                 "second" to "sec"
             )
         )
+        assertNotNull(result)
         assertEquals("ff", result[0].first)
         assertEquals("sec", result[0].second)
         assertEquals(123, result[0].third)
@@ -160,179 +173,33 @@ class ConnectionTest : TestAbstract() {
 
     @Test
     fun `select with named parameters as vararg of Pair`() {
-        val result: List<ObjTest3> = connection.select(
+        val result: List<ObjTest3>? = connection.execute(
             """
             SELECT json_build_array(
-                json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int),
+                json_build_object('id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 'first', :first::text, 'second', :second::text, 'third', :third::int),
-                json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int)
+                json_build_object('id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 'first', :first::text, 'second', :second::text, 'third', :third::int)
             )
             """.trimIndent(),
             "first" to "ff",
             "third" to 123,
             "second" to "sec"
         )
+        assertNotNull(result)
         assertEquals("ff", result[0].first)
         assertEquals("sec", result[0].second)
         assertEquals(123, result[0].third)
     }
 
     @Test
-    fun `select paginated`() {
+    fun `execute with extra parameters`() {
-        val result: Paginated<ObjTest> = connection.select(
-            """
-            SELECT json_build_array(
-                json_build_object('id', '417aaa7e-7bc6-49b7-9fe8-6c8433b3f430', 'name', :name::text),
-                json_build_object('id', 'abd46e7a-e749-4ce4-8361-e7b64da89da6', 'name', :name::text || '-2')
-            ), 10 as total
-            LIMIT :limit OFFSET :offset
-            """.trimIndent(),
-            1,
-            2,
-            mapOf("name" to "ff")
-
-        )
-        assertNotNull(result)
-        assertEquals("ff", result.result[0].name)
-        assertEquals("ff-2", result.result[1].name)
-        assertEquals(10, result.total)
-        assertEquals(0, result.offset)
-    }
-
-    @Test
-    fun `test select paginated without result`() {
-        val result: Paginated<ObjTest> = connection.select(
-            """
-            SELECT null, 
-            10 as total
-            LIMIT :limit 
-            OFFSET :offset
-            """.trimIndent(),
-            1,
-            2,
-            object : TypeReference<List<ObjTest>>() {}
-        )
-        assertNotNull(result)
-        assertTrue(result.result.isEmpty())
-        assertEquals(0, result.result.size)
-        assertEquals(10, result.total)
-        assertEquals(0, result.offset)
-    }
-
-    @Test
-    fun `test select paginated`() {
-        val result: Paginated<ObjTest> = connection.select(
-            """
-            SELECT json_build_array(
-                jsonb_build_object(
-                    'name', :name::text,
-                    'id', 'e9f9a0f0-237c-47cf-98c5-be353f2f2ce3'
-                )
-            ), 
-            10 as total
-            LIMIT :limit 
-            OFFSET :offset
-            """.trimIndent(),
-            1,
-            2,
-            object : TypeReference<List<ObjTest>>() {},
-            mapOf(
-                "name" to "myName"
-            )
-        )
-        assertNotNull(result)
-        assertEquals("myName", result.result[0].name)
-        assertEquals(1, result.result.size)
-        assertEquals(10, result.total)
-        assertEquals(0, result.offset)
-    }
-
-    @Test
-    fun `test select paginated with no result`() {
-        assertThrows<QueryError> {
-            connection.select(
-                """
-                SELECT :name as name,
-                10 as total
-                LIMIT :limit 
-                OFFSET :offset
-                """.trimIndent(),
-                100,
-                10,
-                object : TypeReference<List<ObjTest>>() {},
-                mapOf(
-                    "name" to "myName"
-                )
-            )
-        }.run {
-            assertNotNull(message)
-            assertContains(message!!, "The query has no return")
-        }
-    }
-
-    @Test
-    fun `test select paginated with total was not integer`() {
-        assertThrows<QueryError> {
-            connection.select(
-                """
-                SELECT :name as name,
-                'plop' as total
-                LIMIT :limit 
-                OFFSET :offset
-                """.trimIndent(),
-                1,
-                10,
-                object : TypeReference<List<ObjTest>>() {},
-                mapOf(
-                    "name" to "myName"
-                )
-            )
-        }.run {
-            assertNotNull(message)
-            assertContains(message!!, """Column "total" must be an integer""")
-        }
-    }
-
-    @Test
-    fun `test select paginated without total`() {
-        val exception = assertThrows<QueryError> {
-            val result: Paginated<ObjTest> = connection.select(
-                """
-            SELECT null
-            LIMIT :limit 
-            OFFSET :offset
-                """.trimIndent(),
-                1,
-                2,
-                object : TypeReference<List<ObjTest>>() {}
-            )
-        }
-
-        assertEquals(
-            """
-            The query not return the "total" column
-            
-              > :offset = 0, :limit = 2
-              > SELECT null
-              > LIMIT :limit 
-              > OFFSET :offset
-              > -----
-              > ?column?
-              > null
-            """.trimIndent(),
-            exception.message
-        )
-    }
-
-    @Test
-    fun `selectOne with extra parameters`() {
         val params: Map<String, Any?> = mapOf(
             "first" to "ff",
             "third" to 123,
             "second" to "sec"
         )
-        val result: ObjTest3? = connection.selectOne(
+        val result: ObjTest3? = connection.execute(
             """
-            SELECT json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int), 'plop'::text as other
+            SELECT json_build_object('id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 'first', :first::text, 'second', :second::text, 'third', :third::int), 'plop'::text as other
             """.trimIndent(),
             params
         ) {
@@ -365,8 +232,8 @@ class ConnectionTest : TestAbstract() {
     @Test
     fun `select one in transaction`() {
         connection.inTransaction {
-            selectOne<ObjTestWithParameterObject>(
+            execute<ObjTestWithParameterObject>(
-                "SELECT json_build_object('first', :first::json, 'second', :second::json)",
+                "SELECT json_build_object('id', 'bf0e5605-3a8f-4db9-8b98-c8e0691dd576', 'first', :first::json, 'second', :second::json)",
                 mapOf(
                     "first" to ParameterObject("one"),
                     "second" to ParameterObject("two")

src/test/kotlin/fr/postgresjson/EntityTest.kt

@@ -1,34 +0,0 @@
-package fr.postgresjson
-
-import fr.postgresjson.entity.Entity
-import fr.postgresjson.entity.EntityCreatedAt
-import fr.postgresjson.entity.EntityCreatedBy
-import fr.postgresjson.entity.EntityI
-import fr.postgresjson.entity.EntityUpdatedAt
-import fr.postgresjson.entity.EntityUpdatedBy
-import fr.postgresjson.entity.Published
-import fr.postgresjson.entity.UuidEntityExtended
-import org.junit.jupiter.api.Assertions.assertTrue
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.TestInstance
-import java.util.UUID
-
-@TestInstance(TestInstance.Lifecycle.PER_CLASS)
-class EntityTest() {
-    private class User(id: UUID = UUID.randomUUID()) : Entity<UUID>(id)
-    private class ObjTest(val name: String) : UuidEntityExtended<Int?, User>(User(), User())
-
-    @Test
-    fun getObject() {
-        val obj = ObjTest("plop")
-        assertTrue(obj is ObjTest)
-        assertTrue(obj is UuidEntityExtended<Int?, User>)
-        assertTrue(obj is EntityI)
-        assertTrue(obj is Entity<UUID>)
-        assertTrue(obj is Published<User>)
-        assertTrue(obj is EntityCreatedBy<User>)
-        assertTrue(obj is EntityUpdatedBy<User>)
-        assertTrue(obj is EntityCreatedAt)
-        assertTrue(obj is EntityUpdatedAt)
-    }
-}

src/test/kotlin/fr/postgresjson/MigrationTest.kt

@@ -1,7 +1,7 @@
 package fr.postgresjson
 
 import fr.postgresjson.connexion.Requester
-import fr.postgresjson.connexion.selectOne
+import fr.postgresjson.connexion.execute
 import fr.postgresjson.migration.Migration
 import fr.postgresjson.migration.Migrations
 import org.amshove.kluent.invoking
@@ -12,6 +12,8 @@ import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import java.util.UUID
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class MigrationTest : TestAbstract() {
@@ -83,12 +85,12 @@ class MigrationTest : TestAbstract() {
         val resourcesFunctions = this::class.java.getResource("/sql/function/Test")!!.toURI()
         Migrations(listOf(resources, resourcesFunctions), connection).apply {
             up().apply {
-                size `should be equal to` 7
+                size `should be equal to` 6
             }
         }
         Migrations(listOf(resources, resourcesFunctions), connection).apply {
             forceAllDown().apply {
-                size `should be equal to` 7
+                size `should be equal to` 6
             }
         }
     }
@@ -97,15 +99,16 @@ class MigrationTest : TestAbstract() {
     fun `run functions migrations`() {
         val resources = this::class.java.getResource("/sql/function/Test")!!.toURI()
         Migrations(resources, connection).apply {
-            run().size `should be equal to` 6
+            run().size `should be equal to` 5
         }
 
         val objTest: RequesterTest.ObjTest? = Requester(connection, functionsDirectory = resources)
             .getFunction("test_function")
-            .selectOne(listOf("test", "plip"))
+            .execute(listOf("test", "plip"))
 
-        Assertions.assertEquals(objTest!!.id, UUID.fromString("457daad5-4f1b-4eb7-80ec-6882adb8cc7d"))
+        assertNotNull(objTest)
-        Assertions.assertEquals(objTest.name, "test")
+        assertEquals(objTest.id, UUID.fromString("457daad5-4f1b-4eb7-80ec-6882adb8cc7d"))
+        assertEquals(objTest.name, "test")
     }
 
     @Test
@@ -117,7 +120,7 @@ class MigrationTest : TestAbstract() {
 
         val objTest: RequesterTest.ObjTest? = Requester(connection, functionsDirectory = resources)
             .getFunction("test_function_duplicate")
-            .selectOne(listOf("test"))
+            .execute(listOf("test"))
 
         Assertions.assertEquals(objTest!!.id, UUID.fromString("457daad5-4f1b-4eb7-80ec-6882adb8cc7d"))
         Assertions.assertEquals(objTest.name, "test")

src/test/kotlin/fr/postgresjson/RequesterTest.kt

@@ -2,14 +2,11 @@ package fr.postgresjson
 
 import com.fasterxml.jackson.core.type.TypeReference
 import fr.postgresjson.connexion.Connection.QueryError
-import fr.postgresjson.connexion.Paginated
 import fr.postgresjson.connexion.Requester
 import fr.postgresjson.connexion.Requester.NoFunctionDefined
 import fr.postgresjson.connexion.Requester.NoQueryDefined
-import fr.postgresjson.connexion.select
+import fr.postgresjson.connexion.SqlSerializable
-import fr.postgresjson.connexion.selectOne
+import fr.postgresjson.connexion.execute
-import fr.postgresjson.connexion.update
-import fr.postgresjson.entity.UuidEntity
 import fr.postgresjson.serializer.deserialize
 import org.junit.jupiter.api.Assertions.assertThrows
 import org.junit.jupiter.api.Test
@@ -18,7 +15,8 @@ import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 
 class RequesterTest : TestAbstract() {
-    class ObjTest(val name: String, id: UUID = UUID.fromString("5623d902-3067-42f3-bfd9-095dbb12c29f")) : UuidEntity(id)
+    @SqlSerializable
+    class ObjTest(val name: String, val id: UUID = UUID.fromString("5623d902-3067-42f3-bfd9-095dbb12c29f"))
 
     @Test
     fun `requester constructor empty`() {
@@ -99,7 +97,7 @@ class RequesterTest : TestAbstract() {
         val objTest: ObjTest? = Requester(connection)
             .apply { addQuery(resources) }
             .getQuery("selectOne")
-            .selectOne()
+            .execute()
 
         assertNotNull(objTest)
         assertEquals(objTest.id, UUID.fromString("829b1a29-5db8-47f9-9562-961c561ac528"))
@@ -138,7 +136,7 @@ class RequesterTest : TestAbstract() {
         val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
         val objTest: ObjTest? = Requester(connection, functionsDirectory = resources)
             .getFunction("test_function")
-            .selectOne(listOf("test", "plip"))
+            .execute(listOf("test", "plip"))
 
         assertNotNull(objTest)
         assertEquals(objTest.id, UUID.fromString("457daad5-4f1b-4eb7-80ec-6882adb8cc7d"))
@@ -162,7 +160,7 @@ class RequesterTest : TestAbstract() {
             .getQuery("selectOneWithParameters")
             .exec(listOf("myName"))
 
-        assertEquals("myName", result.rows[0].getString(0)?.deserialize<ObjTest>()?.name)
+        assertEquals("myName", result.deserialize<ObjTest>()?.name)
     }
 
     @Test
@@ -285,23 +283,23 @@ class RequesterTest : TestAbstract() {
     }
 
     @Test
-    fun `call selectOne on function`() {
+    fun `call execute on function`() {
         val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
         val obj: ObjTest? = Requester(connection, functionsDirectory = resources)
             .getFunction("test_function")
-            .selectOne(mapOf("name" to "myName"))
+            .execute(mapOf("name" to "myName"))
 
         assertNotNull(obj)
         assertEquals("myName", obj.name)
     }
 
     @Test
-    fun `call selectOne on function with object and named argument`() {
+    fun `call execute on function with object and named argument`() {
         val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
         val obj2 = ObjTest("original")
         val obj: ObjTest? = Requester(connection, functionsDirectory = resources)
             .getFunction("test_function_object")
-            .selectOne("resource" to obj2)
+            .execute("resource" to obj2)
 
         assertNotNull(obj)
         assertEquals("changedName", obj.name)
@@ -309,12 +307,12 @@ class RequesterTest : TestAbstract() {
     }
 
     @Test
-    fun `call selectOne on function with object`() {
+    fun `call execute on function with object`() {
         val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
         val obj2 = ObjTest("original")
         val obj: ObjTest? = Requester(connection, functionsDirectory = resources)
             .getFunction("test_function_object")
-            .update(obj2)
+            .execute(listOf(obj2))
 
         assertNotNull(obj)
         assertEquals("changedName", obj.name)
@@ -322,22 +320,22 @@ class RequesterTest : TestAbstract() {
     }
 
     @Test
-    fun `call selectOne on function with object and no arguments`() {
+    fun `call execute on function with object and no arguments`() {
         val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
         val obj: ObjTest? = Requester(connection, functionsDirectory = resources)
             .getFunction("test_function")
-            .selectOne()
+            .execute()
 
         assertNotNull(obj)
         assertEquals("plop", obj.name)
     }
 
     @Test
-    fun `call selectOne on query`() {
+    fun `call execute on query`() {
         val resources = this::class.java.getResource("/sql/query")?.toURI()
         val obj: ObjTest? = Requester(connection, queriesDirectory = resources)
             .getQuery("selectOneWithParameters")
-            .selectOne(mapOf("name" to "myName"))
+            .execute(mapOf("name" to "myName"))
 
         assertNotNull(obj)
         assertEquals("myName", obj.name)
@@ -346,10 +344,11 @@ class RequesterTest : TestAbstract() {
     @Test
     fun `call select (multiple) on function with named argument`() {
         val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val obj: List<ObjTest> = Requester(connection, functionsDirectory = resources)
+        val obj: List<ObjTest>? = Requester(connection, functionsDirectory = resources)
             .getFunction("test_function_multiple")
-            .select(mapOf("name" to "myName"))
+            .execute(mapOf("name" to "myName"))
 
+        assertNotNull(obj)
         assertNotNull(obj[0])
         assertEquals("myName", obj[0].name)
         assertEquals("myName", obj[0].name)
@@ -358,10 +357,11 @@ class RequesterTest : TestAbstract() {
     @Test
     fun `call select (multiple) on function with ordered arguments`() {
         val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val obj: List<ObjTest> = Requester(connection, functionsDirectory = resources)
+        val obj: List<ObjTest>? = Requester(connection, functionsDirectory = resources)
             .getFunction("test_function_multiple")
-            .select(listOf("myName"))
+            .execute(listOf("myName"))
 
+        assertNotNull(obj)
         assertEquals("myName", obj[0].name)
     }
 
@@ -370,13 +370,13 @@ class RequesterTest : TestAbstract() {
         val resources = this::class.java.getResource("/sql/query")?.toURI()
         Requester(connection, queriesDirectory = resources)
             .getQuery("selectMultiple").apply {
-                select<ObjTest>(mapOf("name" to "ff")).let { result ->
+                execute<List<ObjTest>>(mapOf("name" to "ff")).let { result ->
                     assertNotNull(result)
                     assertEquals("ff", result[0].name)
                     assertEquals("ff-2", result[1].name)
                 }
             }.apply {
-                select(object : TypeReference<List<ObjTest>>() {}, mapOf("name" to "ff")).let { result ->
+                execute(object : TypeReference<List<ObjTest>>() {}, mapOf("name" to "ff")).let { result ->
                     assertNotNull(result)
                     assertEquals("ff", result[0].name)
                     assertEquals("ff-2", result[1].name)
@@ -389,13 +389,13 @@ class RequesterTest : TestAbstract() {
         val resources = this::class.java.getResource("/sql/query")?.toURI()
         Requester(connection, queriesDirectory = resources)
             .getQuery("selectMultiple").apply {
-                select<ObjTest>("name" to "ff").let { result ->
+                execute<List<ObjTest>>("name" to "ff").let { result ->
                     assertNotNull(result)
                     assertEquals("ff", result[0].name)
                     assertEquals("ff-2", result[1].name)
                 }
             }.apply {
-                select(object : TypeReference<List<ObjTest>>() {}, "name" to "ff").let { result ->
+                execute(object : TypeReference<List<ObjTest>>() {}, "name" to "ff").let { result ->
                     assertNotNull(result)
                     assertEquals("ff", result[0].name)
                     assertEquals("ff-2", result[1].name)
@@ -408,13 +408,13 @@ class RequesterTest : TestAbstract() {
         val resources = this::class.java.getResource("/sql/query")?.toURI()
         Requester(connection, queriesDirectory = resources)
             .getQuery("selectMultipleOrderedArgs").apply {
-                select<ObjTest>(listOf("ff", "aa")).let { result ->
+                execute<List<ObjTest>>(listOf("ff", "aa")).let { result ->
                     assertNotNull(result)
                     assertEquals("ff", result[0].name)
                     assertEquals("aa-2", result[1].name)
                 }
             }.apply {
-                select(object : TypeReference<List<ObjTest>>() {}, listOf("ff", "aa")).let { result ->
+                execute(object : TypeReference<List<ObjTest>>() {}, listOf("ff", "aa")).let { result ->
                     assertNotNull(result)
                     assertEquals("ff", result[0].name)
                     assertEquals("aa-2", result[1].name)
@@ -423,71 +423,11 @@ class RequesterTest : TestAbstract() {
     }
 
     @Test
-    fun `call select paginated on query`() {
+    fun `call execute on query with extra parameter`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val result: Paginated<ObjTest> = Requester(connection, queriesDirectory = resources)
-            .getQuery("selectPaginated")
-            .select(1, 2, mapOf("name" to "ff"))
-        assertNotNull(result)
-        assertEquals("ff", result.result[0].name)
-        assertEquals("ff-2", result.result[1].name)
-        assertEquals(10, result.total)
-        assertEquals(0, result.offset)
-    }
-
-    @Test
-    fun `call select paginated on function`() {
-        val resources = this::class.java.getResource("/sql/function")?.toURI()
-        Requester(connection, functionsDirectory = resources)
-            .getFunction("test_function_paginated").apply {
-                select<ObjTest>(1, 2, mapOf("name" to "ff")).run {
-                    assertNotNull(result)
-                    assertEquals("ff", result[0].name)
-                    assertEquals("ff-2", result[1].name)
-                    assertEquals(10, total)
-                    assertEquals(0, offset)
-                }
-            }.apply {
-                select(1, 2, object : TypeReference<List<ObjTest>>() {}, mapOf("name" to "ff")).run {
-                    assertNotNull(result)
-                    assertEquals("ff", result[0].name)
-                    assertEquals("ff-2", result[1].name)
-                    assertEquals(10, total)
-                    assertEquals(0, offset)
-                }
-            }
-    }
-
-    @Test
-    fun `call select paginated on function with vararg`() {
-        val resources = this::class.java.getResource("/sql/function")?.toURI()
-        Requester(connection, functionsDirectory = resources)
-            .getFunction("test_function_paginated")
-            .select<ObjTest>(1, 2, "name" to "ff").run {
-                assertNotNull(result)
-                assertEquals("ff", result[0].name)
-                assertEquals("ff-2", result[1].name)
-                assertEquals(10, total)
-                assertEquals(0, offset)
-            }
-
-        Requester(connection, functionsDirectory = resources)
-            .getFunction("test_function_paginated")
-            .select(1, 2, object : TypeReference<List<ObjTest>>() {}, "name" to "ff").run {
-                assertNotNull(result)
-                assertEquals("ff", result[0].name)
-                assertEquals("ff-2", result[1].name)
-                assertEquals(10, total)
-                assertEquals(0, offset)
-            }
-    }
-
-    @Test
-    fun `call selectOne on query with extra parameter`() {
         val resources = this::class.java.getResource("/sql/query")?.toURI()
         Requester(connection, queriesDirectory = resources)
             .getQuery("selectOneWithParameters").apply {
-                selectOne<ObjTest>(mapOf("name" to "myName")) {
+                execute<ObjTest>(mapOf("name" to "myName")) {
                     assertNotNull(it)
                     assertEquals("myName", it.name)
                     assertEquals("plop", rows[0].getString("other"))
@@ -495,7 +435,7 @@ class RequesterTest : TestAbstract() {
                     assertEquals("selectOneWithParameters", name)
                 }
             }.apply {
-                selectOne(typeReference = object : TypeReference<ObjTest>() {}, values = mapOf("name" to "myName")) {
+                execute(typeReference = object : TypeReference<ObjTest>() {}, values = mapOf("name" to "myName")) {
                     assertNotNull(it)
                     assertEquals("myName", it.name)
                     assertEquals("plop", rows[0].getString("other"))

src/test/kotlin/fr/postgresjson/SerializerTest.kt

@@ -1,8 +1,6 @@
 package fr.postgresjson
 
-import fr.postgresjson.entity.UuidEntity
 import fr.postgresjson.serializer.Serializer
-import fr.postgresjson.serializer.serialize
 import org.joda.time.DateTime
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
@@ -13,8 +11,8 @@ import java.util.UUID
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 internal class SerializerTest {
-    private class ObjTest(var val1: String, var val2: Int, id: UUID = UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96")) : UuidEntity(id)
+    private class ObjTest(var val1: String, var val2: Int,val  id: UUID = UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
-    private class ObjTestDate(var val1: DateTime, id: UUID = UUID.fromString("829b1a29-5db8-47f9-9562-961c561ac528")) : UuidEntity(id)
+    private class ObjTestDate(var val1: DateTime, val id: UUID = UUID.fromString("829b1a29-5db8-47f9-9562-961c561ac528"))
 
     private val serializer = Serializer()
 
@@ -33,16 +31,10 @@ internal class SerializerTest {
         assertTrue(json.contains(""""val1":"plop","val2":123"""))
     }
 
-    @Test
-    fun serialize2() {
-        val json = obj.serialize()
-        assertTrue(json.contains(""""val1":"plop","val2":123"""))
-    }
-
     @Test
     fun serializeList() {
         val list = listOf(ObjTest("one", 1), ObjTest("two", 2))
-        val json = list.serialize()
+        val json = serializer.serialize(list)
         assertTrue(json.contains(""""val1":"one","val2":1"""))
         assertTrue(json.contains(""""val1":"two","val2":2"""))
     }
@@ -50,7 +42,7 @@ internal class SerializerTest {
     @Test
     fun serializeDate() {
         val objDate = ObjTestDate(DateTime.parse("2019-07-30T14:08:51.420108+04:00"))
-        val json = objDate.serialize()
+        val json = serializer.serialize(objDate)
         assertTrue(json.contains(""""val1":"2019-07-30T10:08:51.420Z""""), json)
     }
 

src/test/kotlin/fr/postgresjson/functionGenerator/FunctionGeneratorTest.kt

@@ -27,11 +27,10 @@ class FunctionGeneratorTest : StringSpec({
             |
             |import com.fasterxml.jackson.core.type.TypeReference
             |import fr.postgresjson.connexion.Requester
-            |import fr.postgresjson.entity.Serializable
             |
-            |inline fun <reified E: Any?, S: Serializable> Requester.testFunctionObject(resource: S): E {
+            |inline fun <reified E: Any, S: Any?> Requester.testFunctionObject(resource: S): E? {
             |    return getFunction("test_function_object")
-            |        .selectAny<E>(object : TypeReference<E>() {}, mapOf("resource" to resource))
+            |        .execute<E>(object : TypeReference<E>() {}, mapOf("resource" to resource))
             |}
         """.trimMargin()
 
@@ -85,9 +84,9 @@ class FunctionGeneratorTest : StringSpec({
             |import com.fasterxml.jackson.core.type.TypeReference
             |import fr.postgresjson.connexion.Requester
             |
-            |inline fun <reified E: Any?> Requester.testFunctionMultiple(name: String = "plop", hi: String = "hello"): E {
+            |inline fun <reified E: Any> Requester.testFunctionMultiple(name: String = "plop", hi: String = "hello"): E? {
             |    return getFunction("test_function_multiple")
-            |        .selectAny<E>(object : TypeReference<E>() {}, mapOf("name" to name, "hi" to hi))
+            |        .execute<E>(object : TypeReference<E>() {}, mapOf("name" to name, "hi" to hi))
             |}
         """.trimMargin()
 

src/test/resources/sql/function/Test/test_function_paginated.sql

@@ -1,21 +0,0 @@
-create or replace function test_function_paginated(
-    name text default 'plop',
-    in "limit" int default 10,
-    in "offset" int default 0,
-    out result json,
-    out total int
-)
-    language plpgsql
-as
-$$
-begin
-    select
-        json_build_array(
-            json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name::text),
-            json_build_object('id', '8d20abb0-7f77-4b6c-9991-44acd3c88faa', 'name', name::text || '-2')
-        ),
-        10
-    into result, total
-    limit "limit" offset "offset";
-end;
-$$