Add ShadowJar compatibility and Query file can be define name with comment

Add Migration and Query definition class Add Docker DB for tests
set JVM to 11 for jitpack
2020-05-10 21:45:50 +02:00 · 2020-03-25 16:35:18 +01:00 · 2020-03-25 16:25:55 +01:00 · 2020-03-25 16:18:17 +01:00 · 2020-03-25 15:26:19 +01:00 · 2020-03-25 00:30:54 +01:00
75 changed files with 998 additions and 2366 deletions
--- a/.github/workflows/gradle.yml
+++ b/.github/workflows/gradle.yml
@@ -1,76 +0,0 @@
-name: Tests
-
-on:
-  push:
-    branches:
-      - 'master'
-  pull_request:
-    branches:
-      - 'master'
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up JDK 11
-        uses: actions/setup-java@v1
-        with:
-          java-version: 11
-
-      - name: Cache Gradle packages
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.gradle/caches
-            ~/.gradle/wrapper
-          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
-          restore-keys: |
-            ${{ runner.os }}-gradle-
-
-      - name: Build
-        uses: eskatos/gradle-command-action@v1
-        with:
-          gradle-version: '7.1'
-          arguments: build -x test -x ktlintKotlinScriptCheck -x ktlintTestSourceSetCheck -x ktlintMainSourceSetCheck
-      - name: Cleanup Gradle Cache
-        # Remove some files from the Gradle cache, so they aren't cached by GitHub Actions.
-        # Restoring these files from a GitHub Actions cache might cause problems for future builds.
-        run: |
-          rm -f ~/.gradle/caches/modules-2/modules-2.lock
-          rm -f ~/.gradle/caches/modules-2/gc.properties
-
-      - name: Lint
-        uses: eskatos/gradle-command-action@v1
-        with:
-          gradle-version: '7.1'
-          arguments: ktlintCheck
-
-      - name: Test
-        uses: eskatos/gradle-command-action@v1
-        with:
-          gradle-version: '7.1'
-          arguments: test
-
-      - name: Coverage
-        uses: eskatos/gradle-command-action@v1
-        with:
-          gradle-version: '7.1'
-          arguments: jacocoTestReport
-
-      - name: Cache SonarCloud packages
-        uses: actions/cache@v1
-        with:
-          path: ~/.sonar/cache
-          key: ${{ runner.os }}-sonar
-          restore-keys: ${{ runner.os }}-sonar
-
-      - name: Push analyse to sonarqube
-        uses: eskatos/gradle-command-action@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
-          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-        with:
-          gradle-version: '7.1'
-          arguments: sonarqube --info
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -1,53 +0,0 @@
-name: Publish
-
-on:
-  release:
-    types: [ published ]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up JDK 11
-      uses: actions/setup-java@v1
-      with:
-        java-version: 11
-
-    - name: Cache Gradle packages
-      uses: actions/cache@v2
-      with:
-        path: |
-          ~/.gradle/caches
-          ~/.gradle/wrapper
-        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
-        restore-keys: |
-          ${{ runner.os }}-gradle-
-
-    - name: Build
-      uses: eskatos/gradle-command-action@v1
-      with:
-        gradle-version: '7.1'
-        arguments: build -x test -x ktlintKotlinScriptCheck -x ktlintTestSourceSetCheck -x ktlintMainSourceSetCheck
-    - name: Cleanup Gradle Cache
-      # Remove some files from the Gradle cache, so they aren't cached by GitHub Actions.
-      # Restoring these files from a GitHub Actions cache might cause problems for future builds.
-      run: |
-        rm -f ~/.gradle/caches/modules-2/modules-2.lock
-        rm -f ~/.gradle/caches/modules-2/gc.properties
-
-    - name: Test
-      uses: eskatos/gradle-command-action@v1
-      with:
-        gradle-version: '7.1'
-        arguments: test
-
-    - name: Publish
-      uses: eskatos/gradle-command-action@v1
-      with:
-        gradle-version: '7.1'
-        arguments: publish
-      env:
-        GITHUB_ACTOR: ${{ secrets.GITHUB_ACTOR }}
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@@ -5,5 +5,6 @@
 /dataSources.local.xml
 /compiler.xml
 /uiDesigner.xml
+/dataSources.xml
 /sonarlint/
 /jarRepositories.xml
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -2,18 +2,12 @@
  <code_scheme name="Project" version="173">
    <JetCodeStyleSettings>
      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
-        <value />
-      </option>
-      <option name="PACKAGES_IMPORT_LAYOUT">
        <value>
-          <package name="" alias="false" withSubpackages="true" />
-          <package name="" alias="true" withSubpackages="true" />
+          <package name="java.util" withSubpackages="true" static="false" />
        </value>
      </option>
      <option name="SPACE_BEFORE_EXTEND_COLON" value="false" />
      <option name="NAME_COUNT_TO_USE_STAR_IMPORT" value="2147483647" />
-      <option name="NAME_COUNT_TO_USE_STAR_IMPORT_FOR_MEMBERS" value="2147483647" />
-      <option name="IMPORT_NESTED_CLASSES" value="true" />
      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
    </JetCodeStyleSettings>
    <codeStyleSettings language="kotlin">
--- a/.idea/dataSources.xml
+++ b/.idea/dataSources.xml
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="DataSourceManagerImpl" format="xml" multifile-model="true">
-    <data-source source="LOCAL" name="json_test@localhost" uuid="1191ff9a-6823-4b18-af90-483ddf0e4b69">
-      <driver-ref>postgresql</driver-ref>
-      <synchronize>true</synchronize>
-      <jdbc-driver>org.postgresql.Driver</jdbc-driver>
-      <jdbc-url>jdbc:postgresql://localhost:5555/json_test</jdbc-url>
-      <working-dir>$ProjectFileDir$</working-dir>
-    </data-source>
-  </component>
-</project>
--- a/.idea/kotlinc.xml
+++ b/.idea/kotlinc.xml
@@ -3,7 +3,4 @@
  <component name="Kotlin2JvmCompilerArguments">
    <option name="jvmTarget" value="11" />
  </component>
-  <component name="KotlinJpsPluginSettings">
-    <option name="version" value="1.7.20" />
-  </component>
 </project>
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -3,7 +3,7 @@
  <component name="FrameworkDetectionExcludesConfiguration">
    <file type="web" url="file://$PROJECT_DIR$" />
  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="openjdk-17" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="adopt-openjdk-11" project-jdk-type="JavaSDK">
    <output url="file://$PROJECT_DIR$/out" />
  </component>
  <component name="TaskProjectConfiguration">
--- a/.idea/runConfigurations/Check.xml
+++ b/.idea/runConfigurations/Check.xml
@@ -1,6 +1,5 @@
 <component name="ProjectRunConfigurationManager">
  <configuration default="false" name="Check" type="CompoundRunConfigurationType">
-    <toRun name="run DB" type="docker-deploy" />
    <toRun name="Lint" type="GradleRunConfiguration" />
    <toRun name="tests" type="JUnit" />
    <method v="2" />
--- a/.idea/runConfigurations/Test_and_Publish_To_MavenLocal.xml
+++ b/.idea/runConfigurations/Test_and_Publish_To_MavenLocal.xml
@@ -0,0 +1,34 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Test and Publish To MavenLocal" type="GradleRunConfiguration" factoryName="Gradle" singleton="true">
+    <ExternalSystemSettings>
+      <option name="executionName" />
+      <option name="externalProjectPath" value="$PROJECT_DIR$" />
+      <option name="externalSystemIdString" value="GRADLE" />
+      <option name="scriptParameters" value="" />
+      <option name="taskDescriptions">
+        <list />
+      </option>
+      <option name="taskNames">
+        <list>
+          <option value="publishToMavenLocal" />
+        </list>
+      </option>
+      <option name="vmOptions" value="" />
+    </ExternalSystemSettings>
+    <extension name="net.ashald.envfile">
+      <option name="IS_ENABLED" value="false" />
+      <option name="IS_SUBST" value="false" />
+      <option name="IS_PATH_MACRO_SUPPORTED" value="false" />
+      <option name="IS_IGNORE_MISSING_FILES" value="false" />
+      <option name="IS_ENABLE_EXPERIMENTAL_INTEGRATIONS" value="false" />
+      <ENTRIES>
+        <ENTRY IS_ENABLED="true" PARSER="runconfig" />
+      </ENTRIES>
+    </extension>
+    <GradleScriptDebugEnabled>true</GradleScriptDebugEnabled>
+    <method v="2">
+      <option name="RunConfigurationTask" enabled="true" run_configuration_name="Lint" run_configuration_type="GradleRunConfiguration" />
+      <option name="RunConfigurationTask" enabled="true" run_configuration_name="tests" run_configuration_type="JUnit" />
+    </method>
+  </configuration>
+</component>
--- a/.idea/runConfigurations/tests.xml
+++ b/.idea/runConfigurations/tests.xml
@@ -2,12 +2,6 @@
  <configuration default="false" name="tests" type="JUnit" factoryName="JUnit" singleton="false">
    <module name="postgres-json.test" />
    <useClassPathOnly />
-    <extension name="coverage">
-      <pattern>
-        <option name="PATTERN" value="fr.postgresjson.*" />
-        <option name="ENABLED" value="true" />
-      </pattern>
-    </extension>
    <extension name="net.ashald.envfile">
      <option name="IS_ENABLED" value="false" />
      <option name="IS_SUBST" value="false" />
--- a/README.md
+++ b/README.md
@@ -1,39 +0,0 @@
-PostgresJson
-============
-_Kotlin library to request postgres with native SQL queries_
-
-[![Tests](https://github.com/flecomte/postgres-json/actions/workflows/gradle.yml/badge.svg)](https://github.com/flecomte/postgres-json/actions/workflows/gradle.yml)
-[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=postgres-json&metric=coverage)](https://sonarcloud.io/dashboard?id=postgres-json)
-
-[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=postgres-json&metric=alert_status)](https://sonarcloud.io/dashboard?id=postgres-json)
-[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=postgres-json&metric=ncloc)](https://sonarcloud.io/dashboard?id=postgres-json)
-
---
-
-## What is this lib for?
-This library allows you to make sql requests and return the result in json format, then deserialize it into an entity.
-It also allows you to save an entity (INSERT) by serializing it and sending the json to the database, allowing you to insert several entities with their children, in a single request.
-
-It also manages the migrations of the schema of tables and stored procedures.
-
-All sql requests are handled manually for full control over what you do.
-
---
-
-## The best benefits
-
-* Total control of all Postgresql features and SQL language
-* More speed and flexible than an ORM
-* [Multi level request](./docs/usage/multi-level.md) (Can return multiple tables and these children in a single request)
-* Queries are written in separate native `.sql` files
-* Unit testing of SQL queries
-* Migrations are written in separate native `.sql` files
-* Automatic tested database migration and rollback
---
-## Documentation: Table of Contents
-
-* [Installation](./docs/installation.md)
-* [Migrations](./docs/migrations/migrations.md)
-* [Usage](./docs/usage/usage.md)
-* [How that works](./docs/call%20function.png) (Diagram)
-* [How to begin](./docs/checklist.md)
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,80 +1,45 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-val containerAlwaysOn: String by project
-val disableLint: String by project

 plugins {
    jacoco

    id("maven-publish")
-    kotlin("jvm") version "1.7.20"
+    id("org.jetbrains.kotlin.jvm") version "1.3.50"

-    id("org.jlleitschuh.gradle.ktlint") version "11.0.0"
-    id("org.owasp.dependencycheck") version "7.2.0"
-    id("fr.coppernic.versioning") version "3.2.1"
-    id("com.avast.gradle.docker-compose") version "0.16.9"
-    id("org.sonarqube") version "+"
+    id("org.jlleitschuh.gradle.ktlint") version "8.2.0"
+    id("org.owasp.dependencycheck") version "5.1.0"
+    id("fr.coppernic.versioning") version "3.1.2"
 }

-group = "io.github.flecomte"
+group = "flecomte"
 version = versioning.info.tag

 repositories {
    mavenCentral()
+    jcenter()
 }

 tasks.withType<KotlinCompile> {
    kotlinOptions {
        jvmTarget = "11"
+        sourceCompatibility = "11"
+        targetCompatibility = "11"
    }
 }

-val compileKotlin: KotlinCompile by tasks
-compileKotlin.kotlinOptions {
-    jvmTarget = "11"
-}
-val compileTestKotlin: KotlinCompile by tasks
-compileTestKotlin.kotlinOptions {
-    jvmTarget = "11"
-}
-
-tasks.test {
-    useJUnit()
-    useJUnitPlatform()
-    systemProperty("junit.jupiter.execution.parallel.enabled", true)
-    if (!disableLint.toBoolean()) {
-        finalizedBy(tasks.ktlintCheck)
-    }
-}
-
-tasks.jacocoTestReport {
-    dependsOn(tasks.test)
-    reports {
-        xml.required.set(true)
-    }
-}
-
-tasks.sonarqube.configure {
-    dependsOn(tasks.jacocoTestReport)
-}
-
-tasks.publishToMavenLocal {
-    dependsOn(tasks.test)
-}
-
 dependencies {
-    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.7.20")
-    implementation("org.jetbrains.kotlin:kotlin-reflect:1.7.20")
-    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.14.0-rc1")
-    implementation("com.fasterxml.jackson.datatype:jackson-datatype-joda:2.14.0-rc1")
-    implementation("com.github.jasync-sql:jasync-postgresql:2.1.7")
-    implementation("org.slf4j:slf4j-api:2.0.3")
+    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
+    implementation("org.jetbrains.kotlin:kotlin-reflect:1.3.31")
+    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.9.9")
+    implementation("com.fasterxml.jackson.datatype:jackson-datatype-joda:2.9.9")
+    implementation("com.github.jasync-sql:jasync-postgresql:1.0.7")
+    implementation("org.slf4j:slf4j-api:1.7.26")

-    testImplementation("ch.qos.logback:logback-classic:1.4.3")
-    testImplementation("ch.qos.logback:logback-core:1.4.3")
-    testImplementation("io.mockk:mockk:1.13.2")
-    testImplementation("org.junit.jupiter:junit-jupiter:5.9.0")
-    testImplementation("org.jetbrains.kotlin:kotlin-test-junit:1.7.20")
-    testImplementation("org.amshove.kluent:kluent:1.68")
+    testImplementation("ch.qos.logback:logback-classic:1.2.3")
+    testImplementation("ch.qos.logback:logback-core:1.2.3")
+    testImplementation("io.mockk:mockk:1.9")
+    testImplementation("org.junit.jupiter:junit-jupiter:5.4.2")
+    testImplementation("org.amshove.kluent:kluent:1.47")
 }

 val sourcesJar by tasks.creating(Jar::class) {
@@ -82,14 +47,6 @@ val sourcesJar by tasks.creating(Jar::class) {
    from(sourceSets.getByName("main").allSource)
 }

-apply(plugin = "docker-compose")
-dockerCompose {
-    setProjectName("postgres-json")
-    setProperty("useComposeFiles", listOf("docker-compose.yml"))
-    setProperty("stopContainers", !containerAlwaysOn.toBoolean())
-    isRequiredBy(project.tasks.test)
-}
-
 publishing {
    repositories {
        maven {
@@ -108,14 +65,4 @@ publishing {
            artifact(sourcesJar)
        }
    }
-}
-
-tasks.withType<PublishToMavenRepository>().configureEach {
-    onlyIf {
-        versioning.info.run {
-            !dirty && tag != null && tag.matches("""[0-9]+\.[0-9]+\.[0-9]+""".toRegex())
-        }
-    }
-
-    dependsOn(tasks.test)
-}
+}
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,6 +1,6 @@
 # To execute this docker-compose yml file use docker-compose -f <file_name> up
 # Add the "-d" flag at the end for detached execution
-version: '3.8'
+version: '3.7'
 services:
  db:
    container_name: postgres_json
@@ -8,8 +8,18 @@ services:
      context: docker/postgresql
    restart: always
    ports:
-      - "5555:5432"
+      - 5555:5432
    environment:
      POSTGRES_DB: json_test
      POSTGRES_USER: test
      POSTGRES_PASSWORD: test
+
+  pgadmin:
+    container_name: pgadmin4_json
+    image: dpage/pgadmin4
+    restart: always
+    ports:
+      - 8585:80
+    environment:
+      PGADMIN_DEFAULT_EMAIL: rusk23@gmail.com
+      PGADMIN_DEFAULT_PASSWORD: azerty
--- a/docker/postgresql/Dockerfile
+++ b/docker/postgresql/Dockerfile
@@ -1,4 +1,4 @@
-FROM postgres:13
+FROM postgres:11

 COPY postgresql.conf /tmp/postgresql.conf
 COPY extension.sh    /docker-entrypoint-initdb.d/000-extension.sh
--- a/docker/postgresql/postgresql.conf
+++ b/docker/postgresql/postgresql.conf
@@ -664,3 +664,5 @@ log_rotation_size = 100MB
 #------------------------------------------------------------------------------

 # Add settings for extensions here
+
+zdb.default_elasticsearch_url = 'http://elasticsearch:9200/'
--- a/function.png
+++ b/function.png
--- a/function.puml
+++ b/function.puml
@@ -1,52 +0,0 @@
-@startuml
-
-participant  Gradle
-participant  App
-control  Migration
-control  Repository
-control  Requester
-control  Function
-control  Connection
-database Database
-
-== Migration ==
-
-[-> Gradle++ : run gradle
-    Gradle -> Migration** : Init Migration
-        Migration -> Migration : Read Schemas
-        Migration -> Migration : Read SQL Function
-    Gradle -> Migration++ : Run Migrations
-        Migration -> Migration : Run Migrations
-    return
-    Gradle -> Migration!!
-return
-
-== Application ==
-
-[-> App : run app
-    App -> Connection** : Create Connection
-        Connection -> Database : Connect to the database
-    App -> Requester** : Create Requester
-        Requester -> Requester: Read all Function file
-        Requester -> Function** : Create Function object
-            Function -> Function : Parse function
-            Function -> Function : Store parameters and function name
-    App -> Repository** : Create Repository
-
-... wait request ...
-
-[-> Repository++ : call repository with args
-    Repository -> Repository : Define function name
-    Repository -> Requester++ : get function
-        Requester -> Function++ : select()
-            Function -> Function : Compile args
-            Function -> Function : Compile SQL
-            Function -> Connection++ : select()
-                Connection -> Database++ : Send Prepared Statement
-                return
-                Connection -> Connection : Convert json to Entity
-            return entity
-        return entity
-    return entity
-return entity
-@enduml
--- a/docs/checklist.md
+++ b/docs/checklist.md
@@ -1,9 +0,0 @@
-# Checklist
-
- [ ] Define schemas with migrations files (*.up.sql & *.down.sql)
- [ ] Define query with sql function (*.sql)
- [ ] Create Entity (*.kt)
- [ ] Create repository (*.kt)
- [ ] Configure migrations in gradle
- [ ] Execute migrations functions
- [ ] Call Repository
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -1,9 +0,0 @@
-# Installation
-
-## Gradle
-```kotlin
-// build.gradle.kts
-dependencies {
-    implementation("com.github.flecomte:postgres-json:+")
-}
-```
--- a/docs/migrations/migrations-application.md
+++ b/docs/migrations/migrations-application.md
@@ -1,16 +0,0 @@
-# Execute migration in application
-```kotlin
-import fr.postgresjson.migration.Migrations
-import fr.postgresjson.connexion.Connection
-
-val conn: Connection = TODO()
-val migrations = Migrations(
-    conn,
-    this::class.java.getResource("/sql/migrations")?.toURI() ?: error("No migrations found"),
-    this::class.java.getResource("/sql/functions")?.toURI() ?: error("No sql function found")
-)
-
-migrations.status() // Show executed and not executed migrations
-migrations.runDry() // Execute migration in transaction and rollback at the end
-migrations.run() // Execute migration in transaction and commit if no error
-```
--- a/docs/migrations/migrations-gradle.md
+++ b/docs/migrations/migrations-gradle.md
@@ -1,37 +0,0 @@
-# Execute Migrations with Gradle
-
-You can execute migration with a Gradle task like this:
-
-```kotlin
-// build.gradle.kts
-import fr.postgresjson.connexion.Connection
-import fr.postgresjson.connexion.Requester
-import fr.postgresjson.migration.Migrations
-
-buildscript {
-    dependencies {
-        classpath("com.github.flecomte:postgres-json:+")
-    }
-}
-
-val migration by tasks.registering {
-    doLast {
-        val connection = Connection(
-            host = "localhost",
-            port = 5432,
-            database = "database",
-            username = "username",
-            password = "password"
-        )
-        Migrations(
-            connection,
-            file("$buildDir/resources/main/sql/migrations").toURI(),
-            file("$buildDir/resources/main/sql/functions").toURI()
-        ).run()
-    }
-}
-```
-
-```shell
-$ gradle migration
-```
--- a/docs/migrations/migrations.md
+++ b/docs/migrations/migrations.md
@@ -1,71 +0,0 @@
-# Migration
-## Schemas migration
-Migrations are just manually written `*.sql` files that represent the database schemas.
-Each file is executed one after the other in alphabetical order.
-Each execution is stored in the `migration.history` table.
-
-A migration contains a `*.up.sql` file and a `*.down.sql` file to rollback the migration.
-The content of the `*.down.sql` file is also stored in the database.
-This allows the `*.down.sql` to be executed even if the code is already rollback.
-
-Example:
-```postgresql
-- resources/sql/migrations/0000-init_schema.up.sql
-create table "user"
-(
-    id         uuid        default uuid_generate_v4() not null primary key,
-    created_at timestamptz default now()              not null,
-    blocked_at timestamptz default null               null,
-    username   varchar(64)                            not null check ( username != '' and lower(username) = username) unique,
-    password   text                                   not null check ( password != '' ),
-    roles      text[]      default '{}'               not null
-);
-```
-
-```postgresql
-- resources/sql/migrations/0000-init_schema.down.sql
-drop table if exists "user";
-```
-## Stored procedure migrations
-
-Migrations are also stored procedures and other functions.
-Each function is updated with each migration.
-
-Example:
-```postgresql
-- resources/sql/functions/insert_user.sql
-create or replace function insert_user(inout resource json) language plpgsql as
-$$
-declare
-    new_id uuid;
-begin
-    insert into "user" (id, username, password, blocked_at, roles)
-    select
-        coalesce(t.id, uuid_generate_v4()),
-        t.username,
-        crypt(resource->>'password', gen_salt('bf', 8)),
-        case when t.blocked_at is not null then now() else null end,
-        t.roles
-    from json_populate_record(null::"user", resource) t
-    returning id into new_id;
-
-    select find_user_by_id(new_id) into resource;
-end;
-$$;
-```
-
-```postgresql
-- resources/sql/functions/find_user_by_id.sql
-create or replace function find_user_by_id(in _id uuid, out resource json) language plpgsql as
-$$
-begin
-    select to_jsonb(u) - 'password' into resource
-    from "user" as u
-    where u.id = _id;
-end;
-$$;
-```
-
-* [Execute migrations in application](./migrations-application.md)
-* [Execute migrations with gradle](./migrations-gradle.md)
-
--- a/docs/usage/init-connection.md
+++ b/docs/usage/init-connection.md
@@ -1,14 +0,0 @@
-# Init connection
-
-Before execute any query you must instantiate the connection.
-```kotlin
-import fr.postgresjson.connexion.Connection
-
-val connection = Connection(
-    host = "localhost",
-    port = 5432,
-    database = "mydb",
-    username = "john",
-    password = "azerty"
-)
-```
--- a/docs/usage/multi-level.md
+++ b/docs/usage/multi-level.md
@@ -1,93 +0,0 @@
-Multi Level Queries
-===================
-
-## Define schema, query and kotlin object
-1. Schema
-```postgresql
-create table parent (
-    id uuid primary key,
-    name text not null
-);
-
-create table child (
-    id uuid primary key,
-    name text not null,
-    parent_id uuid not null references parent
-)
-```
-2. Insert some data for tests
-```postgresql
-insert into parent (id, name) VALUES ('379e0687-9e4a-4781-b0e9-d94a62e4261f', 'Bernard');
-insert into child (id, name, parent_id) VALUES (uuid_generate_v4(), 'Noé', '379e0687-9e4a-4781-b0e9-d94a62e4261f');
-insert into child (id, name, parent_id) VALUES (uuid_generate_v4(), 'John', '379e0687-9e4a-4781-b0e9-d94a62e4261f');
-```
-3. Define Model
-```kotlin
-import java.util.UUID
-
-class Parent(val id: UUID, val name: String, val children: List<Child>)
-class Child(val id: UUID, val name: String)
-```
-
-4. Define request function
-```postgresql
-- resource/sql/functions/find_parent_by_id.sql
-create or replace function find_parent_by_id(in _id uuid, out resource json) language plpgsql as
-$$
-begin
-    select to_json(t) into resource
-    from (
-        select 
-            p.*,
-            json_agg(to_jsonb(c) - 'parent_id') as children   
-        from parent p
-        join child c on c.parent_id = p.id
-        where p.id = _id
-        group by p.id
-    ) t;
-end;
-$$;
-```
-
-## Execute the function
-
-You just to use `Requester` and set the sql function name, then pass arguments.
-
-If you need to return more than one entry, use `.select()` instead of `.selecteOne()`
-
-See the [Paginated example](./paginated.md)
-```kotlin
-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")
-```
-
-The requester create dynamically this request
-```postgresql
-select * from find_parent_by_id(_id => '379e0687-9e4a-4781-b0e9-d94a62e4261f');
-```
-*Watch the underscore as prefix is added if necessary.
-The requester known the parameters because it parses all SQL functions and reads the names of the parameters from them.*
-
-
-And the SQL return is a JSON like follow:
-```json
-{
-  "id": "379e0687-9e4a-4781-b0e9-d94a62e4261f",
-  "name": "Bernard",
-  "child": [
-    {
-      "id": "c2d0ec81-7cac-4689-8086-2644a3b309b5",
-      "name": "Noé"
-    },
-    {
-      "id": "255d911a-0cbc-4156-bf8c-0204e89494d9",
-      "name": "John"
-    }
-  ]
-}
-```
-But the requester deserialize the result automatically into a Kotlin object with their children objects. **And do that in only one request**.
--- a/docs/usage/paginated.md
+++ b/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"
-    )
-```
--- a/docs/usage/raw-request.md
+++ b/docs/usage/raw-request.md
@@ -1,86 +0,0 @@
-# Raw request
-You can execute query directly from the code like this:
-(*see [Init connection](./init-connection.md) before*)
-
-```kotlin
-import fr.postgresjson.connexion.Connection
-
-val connection: Connection = TODO()
-
-val result: QueryResult = connection.exec(
-    "SELECT id FROM inventor WHERE name = :name",
-    mapOf("name" to "Nikola Tesla")
-)
-val id: String = result.rows[0].getString(0)
-```
-
-And if you must map the query result with an entity, you can do it like this:
-```kotlin
-import java.util.UUID
-import fr.postgresjson.entity.Serializable
-import fr.postgresjson.connexion.Connection
-
-val connection: Connection = TODO()
-
-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(
-    """
-    SELECT json_build_object(
-        'id', '9e65de49-712e-47ce-8bf2-dfffae53a82e', 
-        'name', :name
-    )
-    """,
-    mapOf("name" to "Nikola Tesla")
-)
-
-// Select multiple entities
-val result = connection.select<List<Inventor>>(
-    """
-    SELECT json_build_array(
-        json_build_object(
-           'id', '9e65de49-712e-47ce-8bf2-dfffae53a82e',
-           'name', :name
-        ),
-        json_build_object(
-           'id', '32f67ed3-af6d-403b-a3b9-5fe3540c3412',
-           'name', :name2
-        )
-    )
-    """,
-    mapOf(
-        "name" to "Nikola Tesla",
-        "name2" to "Albert Einstein",
-    )
-)
-
-// Select multiple with real query
-val result: List<Inventor> = connection.select(
-    """
-        select json_agg(i)
-        from inventor i
-        where roles @> ARRAY[:role];
-    """,
-    mapOf("role" to "ADMIN")
-)
-
-
-// Select multiple with only some rows
-val result: List<Inventor> = connection.select(
-    """
-        select json_agg(i)
-        from (
-             select id, name
-             from inventor
-        ) i;
-    """
-)
-```
-
-
-See [ConnectionTest.kt](/src/test/kotlin/fr/postgresjson/ConnectionTest.kt) for more examples.
--- a/docs/usage/stored-procedure.md
+++ b/docs/usage/stored-procedure.md
@@ -1,85 +0,0 @@
-# Stored Procedure
-*Execute stored procedure with requester*
-
-You can execute a stored procedure (previously defined in a migration) via the Requester
-
-To do that:
-
-1. First, instantiate the requester
-```kotlin
-import fr.postgresjson.connexion.Requester
-import fr.postgresjson.connexion.Connection
-
-val connection: Connection = TODO()
-
-val requester = Requester(
-    connection = connection,
-    functionsDirectory = this::class.java.getResource("/sql/functions")?.toURI() ?: error("No sql function found")
-).createRequester()
-```
-
-2. then, define Entities
-```kotlin
-import java.util.UUID
-import org.joda.time.DateTime
-import fr.postgresjson.entity.Serializable
-
-enum class Roles { ROLE_USER, ROLE_ADMIN }
-
-class User(
-    id: UUID = UUID.randomUUID(),
-    override var username: String,
-    var blockedAt: DateTime? = null,
-    var roles: List<Roles> = emptyList()
-): Serializable
-
-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)
-
-```kotlin
-import fr.postgresjson.connexion.Requester
-import fr.postgresjson.repository.RepositoryI
-import java.util.UUID
-
-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(
-                "id" to id // You can pass parameters by their names. The underscore prefix on parameters is not required to be mapped. 
-            ) ?: throw UserNotFound(id) // Throw exception if user not found
-    }
-
-    fun insert(user: UserForCreate): User {
-        return requester
-            .getFunction("insert_user")
-            .selectOne("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)
-    }
-}
-```
-
-4. And at last, execute queries
-```kotlin
-import fr.postgresjson.connexion.Requester
-import java.util.UUID
-
-val requester: Requester = TODO()
-val userRepo = UserRepository(requester)
-
-val user: User = userRepo.findById(UUID.fromString(id))
-
-val newUser: UserForCreate = TODO()
-val userInserted: User = userRepo.insert(newUser)
-```
--- a/docs/usage/usage.md
+++ b/docs/usage/usage.md
@@ -1,7 +0,0 @@
-## Usage
-
-1. [Init connection](./init-connection.md)
-2. [Raw request](./raw-request.md)
-3. [Stored Procedure](./stored-procedure.md)
-4. [Paginated request](./paginated.md)
-5. [Multi level request](./multi-level.md)
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,10 +1,2 @@
 kotlin.code.style=official
-systemProp.sonar.host.url=https://sonarcloud.io
-systemProp.sonar.projectKey=postgres-json
-systemProp.sonar.projectName=PostgresJson
-systemProp.sonar.organization=flecomte
-systemProp.sonar.java.coveragePlugin=jacoco
-systemProp.sonar.coverage.jacoco.xmlReportPaths=build/reports/jacoco/test/jacocoTestReport.xml
-org.gradle.jvmargs=-Xmx4096M
-containerAlwaysOn=false
-disableLint=false
+kotlin_version=1.3.31
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,4 +1,4 @@
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.2-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
--- a/src/main/kotlin/fr/postgresjson/connexion/Connection.kt
+++ b/src/main/kotlin/fr/postgresjson/connexion/Connection.kt
@@ -1,9 +1,8 @@
 package fr.postgresjson.connexion

 import com.fasterxml.jackson.core.type.TypeReference
+import com.github.jasync.sql.db.Connection
 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
@@ -13,7 +12,7 @@ import fr.postgresjson.entity.Serializable
 import fr.postgresjson.serializer.Serializer
 import fr.postgresjson.utils.LoggerDelegate
 import org.slf4j.Logger
-import kotlin.random.Random
+import java.util.concurrent.*

 typealias SelectOneCallback<T> = QueryResult.(T?) -> Unit
 typealias SelectCallback<T> = QueryResult.(List<T>) -> Unit
@@ -26,87 +25,80 @@ class Connection(
    private val host: String = "localhost",
    private val port: Int = 5432
 ) : Executable {
-    private var connection: ConnectionPool<PostgreSQLConnection>? = null
+    private lateinit var connection: ConnectionPool<PostgreSQLConnection>
    private val serializer = Serializer()
    private val logger: Logger? by LoggerDelegate()

    internal fun connect(): ConnectionPool<PostgreSQLConnection> {
-        return connection.let { connectionPool ->
-            if (connectionPool == null || !connectionPool.isConnected()) {
-                PostgreSQLConnectionBuilder.createConnectionPool(
-                    "jdbc:postgresql://$host:$port/$database?user=$username&password=$password"
-                ).also {
-                    connection = it
-                }
-            } else {
-                connectionPool
-            }
+        if (!::connection.isInitialized || !connection.isConnected()) {
+            connection = PostgreSQLConnectionBuilder.createConnectionPool(
+                "jdbc:postgresql://$host:$port/$database?user=$username&password=$password"
+            )
        }
+        return connection
    }

-    fun disconnect() {
-        connection?.disconnect()
-    }
+    fun <A> inTransaction(f: (Connection) -> CompletableFuture<A>) = connect().inTransaction(f)

-    fun <A> inTransaction(block: Connection.() -> A?): A? = connect().run {
-        sendQuery("BEGIN")
-        try {
-            block().apply { sendQuery("COMMIT") }
-        } catch (e: Throwable) {
-            sendQuery("ROLLBACK")
-            throw e
-        }
-    }
-
-    /**
-     * Select One [EntityI] with [List] of parameters
-     */
-    override fun <R : EntityI> selectOne(
+    override fun <R : EntityI> select(
        sql: String,
        typeReference: TypeReference<R>,
        values: List<Any?>,
        block: (QueryResult, R?) -> Unit
    ): R? {
+        val primaryObject = values.firstOrNull {
+            it is EntityI && typeReference.type.typeName == it::class.java.name
+        } as R?
        val result = exec(sql, compileArgs(values))
-        val json = result.rows.firstOrNull()?.getString(0)
+        val json = result.rows[0].getString(0)
        return if (json === null) {
            null
        } else {
-            serializer.deserialize(json, typeReference)
+            if (primaryObject != null) {
+                serializer.deserialize(json, primaryObject)
+            } else {
+                serializer.deserialize(json, typeReference)
+            }
        }.also {
            block(result, it)
        }
    }

-    /**
-     * Select One [EntityI] with named parameters
-     */
-    override fun <R : EntityI> selectOne(
+    inline fun <reified R : EntityI> selectOne(
+        sql: String,
+        values: List<Any?> = emptyList(),
+        noinline block: SelectOneCallback<R> = {}
+    ): R? =
+        select(sql, object : TypeReference<R>() {}, values, block)
+
+    override fun <R : EntityI> select(
        sql: String,
        typeReference: TypeReference<R>,
        values: Map<String, Any?>,
        block: (QueryResult, R?) -> Unit
    ): R? {
        return replaceArgs(sql, values) {
-            selectOne(this.sql, typeReference, parameters, block)
+            select(this.sql, typeReference, this.parameters, block)
        }
    }

-    /* Select Multiples */
+    inline fun <reified R : EntityI> selectOne(
+        sql: String,
+        values: Map<String, Any?>,
+        noinline block: SelectOneCallback<R> = {}
+    ): R? =
+        select(sql, object : TypeReference<R>() {}, values, block)

-    /**
-     * 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
+        block: (QueryResult, List<R>) -> Unit
    ): List<R> {
-        val result = exec(sql, values)
+        val result = exec(sql, compileArgs(values))
        val json = result.rows[0].getString(0)
        return if (json === null) {
-            emptyList()
+            listOf<EntityI>() as List<R>
        } else {
            serializer.deserializeList(json, typeReference)
        }.also {
@@ -114,32 +106,20 @@ class Connection(
        }
    }

-    /**
-     * Select multiple [EntityI] with [Map] of parameters
-     */
-    override fun <R : EntityI> select(
+    inline fun <reified 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)
-        }
-    }
+        values: List<Any?> = emptyList(),
+        noinline block: SelectCallback<R> = {}
+    ): List<R> =
+        select(sql, object : TypeReference<List<R>>() {}, values, block)

-    /* 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
+        block: (QueryResult, Paginated<R>) -> Unit
    ): Paginated<R> {
        val offset = (page - 1) * limit
        val newValues = values
@@ -151,16 +131,9 @@ class Connection(
        }

        return line.run {
-            val firstLine = rows.firstOrNull() ?: queryError("The query has no return", sql, newValues)
-            if (!(firstLine as ArrayRowData).mapping.keys.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()
+            val json = rows[0].getString(0)
+            val entities = if (json === null) {
+                listOf<EntityI>() as List<R>
            } else {
                serializer.deserializeList(json, typeReference)
            }
@@ -168,17 +141,44 @@ class Connection(
                entities,
                offset,
                limit,
-                total
+                rows[0].getInt("total") ?: error("The query not return total")
            )
        }.also {
            block(line, it)
        }
    }

+    inline fun <reified R : EntityI> 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)
+
+    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)
+        }
+    }
+
+    inline fun <reified R : EntityI> select(
+        sql: String,
+        values: Map<String, Any?>,
+        noinline block: SelectCallback<R> = {}
+    ): List<R> =
+        select(sql, object : TypeReference<List<R>>() {}, values, block)
+
    override fun exec(sql: String, values: List<Any?>): QueryResult {
        val compiledValues = compileArgs(values)
        return stopwatchQuery(sql, compiledValues) {
-            connect().sendPreparedStatement(replaceNamedArgByQuestionMark(sql), compiledValues).join()
+            connect().sendPreparedStatement(sql, compiledValues).join()
        }
    }

@@ -188,22 +188,16 @@ class Connection(
        }
    }

-    /**
-     * Warning: this method not use prepared statement
-     */
-    override fun sendQuery(sql: String, values: List<Any?>): QueryResult {
+    override fun sendQuery(sql: String, values: List<Any?>): Int {
        val compiledValues = compileArgs(values)
        return stopwatchQuery(sql, compiledValues) {
            replaceArgsIntoSql(sql, compiledValues) {
-                connect().sendQuery(it).join()
+                connect().sendQuery(it).join().rowsAffected.toInt()
            }
        }
    }

-    /**
-     * Warning: this method not use prepared statement
-     */
-    override fun sendQuery(sql: String, values: Map<String, Any?>): QueryResult {
+    override fun sendQuery(sql: String, values: Map<String, Any?>): Int {
        return replaceArgs(sql, values) {
            sendQuery(this.sql, this.parameters)
        }
@@ -220,64 +214,36 @@ class Connection(
    }

    private fun <T> replaceArgs(sql: String, values: Map<String, Any?>, block: ParametersQuery.() -> T): T {
-        val paramRegex = "(?<!:):([a-z0-9_-]+)".toRegex(RegexOption.IGNORE_CASE)
-        val orderedArgs = paramRegex.findAll(sql).map { match ->
+        val paramRegex = "(?<!:):([a-zA-Z0-9_-]+)".toRegex(RegexOption.IGNORE_CASE)
+        val newArgs = paramRegex.findAll(sql).map { match ->
            val name = match.groups[1]!!.value
-            values[name] ?: values[name.trimStart('_')] ?: queryError("""Parameter "$name" missing""", sql, values)
+            values[name] ?: values[name.trimStart('_')] ?: error("Parameter $name missing")
        }.toList()

-        return block(ParametersQuery(replaceNamedArgByQuestionMark(sql), orderedArgs))
-    }
+        var newSql = sql
+        values.forEach { (key, _) ->
+            val regex = ":_?$key".toRegex()
+            newSql = newSql.replace(regex, "?")
+        }

-    private fun replaceNamedArgByQuestionMark(sql: String): String =
-        "(?<!:):([a-z0-9_-]+)"
-            .toRegex(RegexOption.IGNORE_CASE)
-            .replace(sql, "?")
-
-    private fun insertArgsValuesIntoSql(sql: String, values: List<Any?>): String {
-        var i = 0
-
-        /* The regular expression matches a question mark "?" alone, not preceded or followed by another question mark */
-        return """(?<!\?)(\?)(?!\?)"""
-            .toRegex(RegexOption.IGNORE_CASE)
-            .replace(sql) {
-                values.getOrNull(i)
-                    ?.toString()
-                    ?.also { ++i }
-                    ?.let(this::escapeParameter)
-                    ?: queryError("Parameter $i missing", sql, values)
-            }
+        return block(ParametersQuery(newSql, newArgs))
    }

    private fun <T> replaceArgsIntoSql(sql: String, values: List<Any?>, block: (String) -> T): T {
-        return if (values.isNotEmpty()) {
-            sql
-                .let(this::replaceNamedArgByQuestionMark)
-                .let { insertArgsValuesIntoSql(it, values) }
-                .let(block)
-        } else block(sql)
-    }
+        val paramRegex = "(?<!\\?)(\\?)(?!\\?)".toRegex(RegexOption.IGNORE_CASE)
+        var i = 0
+        if (values.isNotEmpty()) {
+            val newSql = paramRegex.replace(sql) {
+                values[i] ?: error("Parameter $i missing")
+                val valToReplace = values[i].toString()
+                ++i
+                "'$valToReplace'"
+            }

-    /**
-     * Escape parameter by generate a random tag to prevent SQL injection
-     */
-    private fun escapeParameter(parameter: String): String {
-        val escapeTag = escapeTag().let {
-            if (parameter.indexOf(it) >= 0) escapeParameter(parameter) else it
+            return block(newSql)
        }
-        return """$escapeTag$parameter$escapeTag"""
-    }

-    /**
-     * Generate a random alphaNum tag of 8 characters
-     */
-    private fun escapeTag(): String {
-        val charPool: List<Char> = ('a'..'z') + ('A'..'Z')
-        val tagName = (1..8)
-            .map { _ -> Random.nextInt(0, charPool.size) }
-            .map(charPool::get)
-            .joinToString("")
-        return "\$$tagName\$"
+        return block(sql)
    }

    data class ParametersQuery(val sql: String, val parameters: List<Any?>)
@@ -305,51 +271,12 @@ class Connection(
            logger?.debug("Query executed in $duration ms \n{}", args)
            return result
        } catch (e: Throwable) {
-            logger?.info(
-                """
+            logger?.info("""
                Query Error: 
                ${sql.prependIndent()}, 
                ${values.joinToString(", ").prependIndent()}
-                """.trimIndent(),
-                e
-            )
+            """.trimIndent(), e)
            throw e
        }
    }
-
-    class QueryError(msg: String) : Exception(msg)
-
-    private fun queryError(
-        msg: String,
-        sql: String,
-        parameters: List<Any?>,
-        result: ResultSet? = null
-    ): Nothing = throw QueryError(
-        """
-        |$msg
-        |
-        |${parameters.joinToString(", ") { it.toString() }.prependIndent("  > ")}
-        |${sql.prependIndent("  > ")}
-        |${result?.let { "-----" }?.prependIndent("  > ") ?: ""}
-        |${result?.columnNames()?.joinToString(" | ")?.prependIndent("  > ") ?: ""}
-        |${result?.map { it.joinToString(" | ") }?.joinToString("\n")?.prependIndent("  > ") ?: ""}
-        """.trimMargin().trim(' ', '\n')
-    )
-
-    private fun queryError(
-        msg: String,
-        sql: String,
-        parameters: Map<String, Any?>,
-        result: ResultSet? = null
-    ): Nothing = throw QueryError(
-        """
-        |$msg
-        |
-        |${parameters.map { ":" + it.key + " = " + it.value }.joinToString(", ").prependIndent("  > ")}
-        |${sql.prependIndent("  > ")}
-        |${result?.let { "-----" }?.prependIndent("  > ") ?: ""}
-        |${result?.columnNames()?.joinToString(" | ")?.prependIndent("  > ") ?: ""}
-        |${result?.map { it.joinToString(" | ") }?.joinToString("\n")?.prependIndent("  > ") ?: ""}
-        """.trimMargin().trim(' ', '\n')
-    )
 }
--- a/src/main/kotlin/fr/postgresjson/connexion/EmbedExecutable.kt
+++ b/src/main/kotlin/fr/postgresjson/connexion/EmbedExecutable.kt
@@ -4,86 +4,41 @@ import com.fasterxml.jackson.core.type.TypeReference
 import com.github.jasync.sql.db.QueryResult
 import fr.postgresjson.entity.EntityI

-sealed interface EmbedExecutable {
+interface EmbedExecutable {
    val connection: Connection
    override fun toString(): String
    val name: String

    /* Select One */
-
    /**
-     * Update [EntityI] with one entity as argument
+     * Select One entity with list of parameters
     */
-    fun <R : EntityI> update(
+    fun <R : EntityI> select(
        typeReference: TypeReference<R>,
-        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?>,
+        values: List<Any?> = emptyList(),
        block: SelectOneCallback<R> = {}
    ): R?

-    /**
-     * Select One [EntityI] with [Map] of parameters
-     */
-    fun <R : EntityI> selectOne(
+    fun <R : EntityI> select(
        typeReference: TypeReference<R>,
        values: Map<String, Any?>,
        block: SelectOneCallback<R> = {}
    ): R?

-    /**
-     * Select One [EntityI] with multiple [Pair] of parameters
-     */
-    fun <R : EntityI> selectOne(
-        typeReference: TypeReference<R>,
-        vararg values: Pair<String, Any?>,
-        block: SelectOneCallback<R> = {}
-    ): R? =
-        selectOne(typeReference, values.toMap(), block)
-
-    /* Select Multiples */
-
-    /**
-     * Select Multiple [EntityI] with [List] of parameters
-     */
+    /* Select Miltiples */
    fun <R : EntityI> select(
        typeReference: TypeReference<List<R>>,
-        values: List<Any?>,
+        values: List<Any?> = emptyList(),
        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 Paginated */
-
-    /**
-     * Select Paginated [EntityI] with [Map] of parameters
-     */
    fun <R : EntityI> select(
        page: Int,
        limit: Int,
@@ -92,19 +47,16 @@ sealed interface EmbedExecutable {
        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: List<Any?> = emptyList()): QueryResult
    fun exec(values: Map<String, Any?>): QueryResult
    fun exec(vararg values: Pair<String, Any?>): QueryResult = exec(values.toMap())
-}
+
+    fun perform(values: List<Any?>) { exec(values) }
+    fun perform(values: Map<String, Any?>) { exec(values) }
+    fun perform(vararg values: Pair<String, Any?>) = perform(values.toMap())
+
+    fun sendQuery(values: List<Any?> = emptyList()): Int
+    fun sendQuery(values: Map<String, Any?>): Int
+    fun sendQuery(vararg values: Pair<String, Any?>): Int =
+        sendQuery(values.toMap())
+}
--- a/src/main/kotlin/fr/postgresjson/connexion/EmbedExecutableReified.kt
+++ b/src/main/kotlin/fr/postgresjson/connexion/EmbedExecutableReified.kt
@@ -1,68 +0,0 @@
-package fr.postgresjson.connexion
-
-import com.fasterxml.jackson.core.type.TypeReference
-import fr.postgresjson.entity.EntityI
-
-/* Select One */
-
-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> =
-    select(object : TypeReference<List<R>>() {}, values, block)
-
-inline fun <reified R : EntityI> EmbedExecutable.select(
-    values: Map<String, Any?>,
-    noinline block: SelectCallback<R> = {}
-): List<R> =
-    select(object : TypeReference<List<R>>() {}, values, block)
-
-inline fun <reified R : EntityI> EmbedExecutable.select(
-    vararg values: Pair<String, Any?>,
-    noinline block: SelectCallback<R> = {}
-): List<R> =
-    select(object : TypeReference<List<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)
--- a/src/main/kotlin/fr/postgresjson/connexion/Executable.kt
+++ b/src/main/kotlin/fr/postgresjson/connexion/Executable.kt
@@ -5,58 +5,24 @@ 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(
+    fun <R : EntityI> select(
        sql: String,
        typeReference: TypeReference<R>,
-        values: List<Any?>,
+        values: List<Any?> = emptyList(),
        block: SelectOneCallback<R> = {}
    ): R?

-    /**
-     * Select One [EntityI] with [Map] of parameters
-     */
-    fun <R : EntityI> selectOne(
+    fun <R : EntityI> select(
        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 Miltiples */

-    /* Select Multiples */
-
-    /**
-     * Select Multiple [EntityI] with [List] of parameters
-     */
    fun <R : EntityI> select(
        sql: String,
        typeReference: TypeReference<List<R>>,
@@ -64,9 +30,6 @@ interface Executable {
        block: SelectCallback<R> = {}
    ): List<R>

-    /**
-     * Select Multiple [EntityI] with [Map] of parameters
-     */
    fun <R : EntityI> select(
        sql: String,
        typeReference: TypeReference<List<R>>,
@@ -74,22 +37,8 @@ interface Executable {
        block: SelectCallback<R> = {}
    ): List<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,
@@ -99,38 +48,8 @@ interface Executable {
        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: List<Any?> = emptyList()): 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())
-}
+    fun sendQuery(sql: String, values: List<Any?> = emptyList()): Int
+    fun sendQuery(sql: String, values: Map<String, Any?>): Int
+}
--- a/src/main/kotlin/fr/postgresjson/connexion/ExecutableReified.kt
+++ b/src/main/kotlin/fr/postgresjson/connexion/ExecutableReified.kt
@@ -1,106 +0,0 @@
-package fr.postgresjson.connexion
-
-import com.fasterxml.jackson.core.type.TypeReference
-import fr.postgresjson.entity.EntityI
-
-/* Update */
-
-/**
- * Update [EntityI] with one entity as argument
- */
-inline fun <reified R : EntityI> Executable.update(
-    sql: String,
-    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> =
-    select(sql, object : TypeReference<List<R>>() {}, values, block)
-
-/**
- * Select Multiple [EntityI] with [Map] of parameters
- */
-inline fun <reified R : EntityI> Executable.select(
-    sql: String,
-    values: Map<String, Any?>,
-    noinline block: SelectCallback<R> = {}
-): List<R> =
-    select(sql, object : TypeReference<List<R>>() {}, values, block)
-
-/**
- * Select Multiple [EntityI] with multiple [Pair] of parameters
- */
-inline fun <reified R : EntityI> Executable.select(
-    sql: String,
-    vararg values: Pair<String, Any?>,
-    noinline block: SelectCallback<R> = {}
-): List<R> =
-    select(sql, object : TypeReference<List<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)
--- a/src/main/kotlin/fr/postgresjson/connexion/Function.kt
+++ b/src/main/kotlin/fr/postgresjson/connexion/Function.kt
@@ -15,51 +15,109 @@ class Function(val definition: Function, override val connection: Connection) :
    /* Select One */

    /**
-     * Select One [EntityI] with [List] of parameters
+     * Select One entity with list of parameters
     */
-    override fun <R : EntityI> selectOne(
+    override fun <R : EntityI> select(
        typeReference: TypeReference<R>,
        values: List<Any?>,
        block: (QueryResult, R?) -> Unit
+    ): R? {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.select(sql, typeReference, values, block)
+    }
+
+    inline fun <reified R : EntityI> selectOne(
+        values: List<Any?> = emptyList(),
+        noinline block: SelectOneCallback<R> = {}
    ): R? =
-        connection.selectOne(compileSql(values), typeReference, values, block)
+        select(object : TypeReference<R>() {}, values, block)
+
+    inline fun <reified R : EntityI> selectOne(
+        value: R,
+        noinline block: SelectOneCallback<R> = {}
+    ): R? =
+        select(object : TypeReference<R>() {}, listOf(value), block)

    /**
-     * Select One [EntityI] with named parameters
+     * Select One entity with named parameters
     */
-    override fun <R : EntityI> selectOne(
+    override fun <R : EntityI> select(
        typeReference: TypeReference<R>,
        values: Map<String, Any?>,
        block: (QueryResult, R?) -> Unit
+    ): R? {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.select(sql, typeReference, values, block)
+    }
+
+    inline fun <reified R : EntityI> selectOne(
+        values: Map<String, Any?>,
+        noinline block: SelectOneCallback<R> = {}
    ): R? =
-        connection.selectOne(compileSql(values), typeReference, values, block)
+        select(object : TypeReference<R>() {}, values, block)
+
+    inline fun <reified R : EntityI> selectOne(
+        vararg values: Pair<String, Any?>,
+        noinline block: SelectOneCallback<R> = {}
+    ): R? =
+        selectOne(values.toMap(), block)

    /* Select Multiples */

    /**
-     * Select multiple [EntityI] with [List] of parameters
+     * Select list of entities with list of parameters
     */
    override fun <R : EntityI> select(
        typeReference: TypeReference<List<R>>,
        values: List<Any?>,
        block: (QueryResult, List<R>) -> Unit
+    ): List<R> {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.select(sql, typeReference, values, block)
+    }
+
+    inline fun <reified R : EntityI> select(
+        values: List<Any?> = emptyList(),
+        noinline block: SelectCallback<R> = {}
    ): List<R> =
-        connection.select(compileSql(values), typeReference, values, block)
+        select(object : TypeReference<List<R>>() {}, values, block)

    /**
-     * Select multiple [EntityI] with named parameters
+     * Select list of entities with named parameters
     */
    override fun <R : EntityI> select(
        typeReference: TypeReference<List<R>>,
        values: Map<String, Any?>,
        block: (QueryResult, List<R>) -> Unit
+    ): List<R> {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.select(sql, typeReference, values, block)
+    }
+
+    inline fun <reified R : EntityI> select(
+        values: Map<String, Any?>,
+        noinline block: SelectCallback<R> = {}
    ): List<R> =
-        connection.select(compileSql(values), typeReference, values, block)
+        select(object : TypeReference<List<R>>() {}, values, block)
+
+    inline fun <reified R : EntityI> select(
+        vararg values: Pair<String, Any?>,
+        noinline block: SelectCallback<R> = {}
+    ): List<R> =
+        select(values.toMap(), block)

    /* Select Paginated */

    /**
-     * Select Multiple [EntityI] with pagination
+     * Select Multiple with pagination
     */
    override fun <R : EntityI> select(
        page: Int,
@@ -73,16 +131,53 @@ class Function(val definition: Function, override val connection: Connection) :
            .plus("offset" to offset)
            .plus("limit" to limit)

-        return connection.select(compileSql(newValues), page, limit, typeReference, values, block)
+        val args = compileArgs(newValues)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.select(sql, page, limit, typeReference, values, block)
    }

-    /* Execute function without treatments */
+    inline fun <reified R : EntityI> 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)

-    override fun exec(values: List<Any?>): QueryResult = connection.exec(compileSql(values), values)
+    inline fun <reified R : EntityI> select(
+        page: Int,
+        limit: Int,
+        vararg values: Pair<String, Any?>,
+        noinline block: SelectPaginatedCallback<R> = {}
+    ): Paginated<R> =
+        select(page, limit, object : TypeReference<List<R>>() {}, values.toMap(), block)

-    override fun exec(values: Map<String, Any?>): QueryResult = connection.exec(compileSql(values), values)
+    /* Execute function without traitements */

-    private fun <R : EntityI> compileArgs(value: R): String = compileArgs(listOf(value))
+    override fun exec(values: List<Any?>): QueryResult {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.exec(sql, values)
+    }
+
+    override fun exec(values: Map<String, Any?>): QueryResult {
+        val args = compileArgs(values)
+        val sql = "SELECT * FROM ${definition.name} ($args)"
+
+        return connection.exec(sql, values)
+    }
+
+    override fun sendQuery(values: List<Any?>): Int {
+        exec(values)
+        return 0
+    }
+
+    override fun sendQuery(values: Map<String, Any?>): Int {
+        exec(values)
+        return 0
+    }

    private fun compileArgs(values: List<Any?>): String {
        val placeholders = values
@@ -110,8 +205,4 @@ 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)})"
-    private fun compileSql(values: Map<String, Any?>): String = "SELECT * FROM ${definition.name} (${compileArgs(values)})"
-}
+}
--- a/src/main/kotlin/fr/postgresjson/connexion/FunctionConverter.kt
+++ b/src/main/kotlin/fr/postgresjson/connexion/FunctionConverter.kt
@@ -1,16 +0,0 @@
-package fr.postgresjson.connexion
-
-import fr.postgresjson.utils.searchSqlFiles
-import java.net.URI
-import fr.postgresjson.definition.Function as DefinitionFunction
-
-fun DefinitionFunction.toRunnable(connection: Connection): Function = Function(this, connection)
-
-fun Sequence<DefinitionFunction>.toRunnable(connection: Connection): Sequence<Function> = map { it.toRunnable(connection) }
-
-fun Sequence<Function>.toMutableMap(): MutableMap<String, Function> = map { it.name to it }.toMap().toMutableMap()
-
-internal fun URI.toFunction(connection: Connection): MutableMap<String, Function> = searchSqlFiles()
-    .filterIsInstance(DefinitionFunction::class.java)
-    .toRunnable(connection)
-    .toMutableMap()
--- a/src/main/kotlin/fr/postgresjson/connexion/Paginated.kt
+++ b/src/main/kotlin/fr/postgresjson/connexion/Paginated.kt
@@ -14,12 +14,12 @@ data class Paginated<T : EntityI>(
    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")
+        if (offset < 0) error("offset must be greather or equal than 0")
+        if (limit < 1) error("limit must be greather or equal than 1")
+        if (total < 0) error("total must be greather or equal than 0")
    }

    fun isLastPage(): Boolean = currentPage >= totalPages

    private fun Double.ceil(): Int = ceil(this).toInt()
-}
+}
--- a/src/main/kotlin/fr/postgresjson/connexion/Query.kt
+++ b/src/main/kotlin/fr/postgresjson/connexion/Query.kt
@@ -11,79 +11,99 @@ class Query(override val name: String, private val sql: String, override val con

    /* Select One */

-    /**
-     * Select One [EntityI] with [List] of parameters
-     */
-    override fun <R : EntityI> selectOne(
+    override fun <R : EntityI> select(
        typeReference: TypeReference<R>,
        values: List<Any?>,
-        block: SelectOneCallback<R>
-    ): R? =
-        connection.selectOne(sql, typeReference, values, block)
+        block: (QueryResult, R?) -> Unit
+    ): R? {
+        return connection.select(this.toString(), typeReference, values, block)
+    }

-    /**
-     * Select One [EntityI] with named parameters
-     */
-    override fun <R : EntityI> selectOne(
+    inline fun <reified R : EntityI> selectOne(
+        values: List<Any?> = emptyList(),
+        noinline block: SelectOneCallback<R> = {}
+    ): R? =
+        select(object : TypeReference<R>() {}, values, block)
+
+    override fun <R : EntityI> select(
        typeReference: TypeReference<R>,
        values: Map<String, Any?>,
-        block: SelectOneCallback<R>
+        block: (QueryResult, R?) -> Unit
+    ): R? {
+        return connection.select(this.toString(), typeReference, values, block)
+    }
+
+    inline fun <reified R : EntityI> selectOne(
+        values: Map<String, Any?>,
+        noinline block: SelectOneCallback<R> = {}
    ): R? =
-        connection.selectOne(sql, typeReference, values, block)
+        select(object : TypeReference<R>() {}, values, block)

    /* Select Multiples */

-    /**
-     * Select multiple [EntityI] with [List] of parameters
-     */
    override fun <R : EntityI> select(
        typeReference: TypeReference<List<R>>,
        values: List<Any?>,
-        block: SelectCallback<R>
-    ): List<R> =
-        connection.select(sql, typeReference, values, block)
+        block: (QueryResult, List<R>) -> Unit
+    ): List<R> {
+        return connection.select(this.toString(), typeReference, values, block)
+    }
+
+    inline fun <reified R : EntityI> select(
+        values: List<Any?> = emptyList(),
+        noinline block: SelectCallback<R> = {}
+    ): List<R> =
+        select(object : TypeReference<List<R>>() {}, 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>
+        block: (QueryResult, List<R>) -> Unit
+    ): List<R> {
+        return connection.select(this.toString(), typeReference, values, block)
+    }
+
+    inline fun <reified R : EntityI> select(
+        values: Map<String, Any?>,
+        noinline block: SelectCallback<R> = {}
    ): List<R> =
-        connection.select(sql, typeReference, values, block)
+        select(object : TypeReference<List<R>>() {}, 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> {
+        return connection.select(this.toString(), page, limit, typeReference, values, block)
+    }
+
+    /* Select Paginated */
+
+    inline fun <reified R : EntityI> select(
+        page: Int,
+        limit: Int,
+        values: Map<String, Any?> = emptyMap(),
+        noinline block: SelectPaginatedCallback<R> = {}
    ): Paginated<R> =
-        connection.select(sql, page, limit, typeReference, values, block)
+        select(page, limit, object : TypeReference<List<R>>() {}, values, block)

-    /* Execute function without treatments */
+    /* Execute function without traitements */

-    override fun exec(values: List<Any?>): QueryResult = connection.exec(sql, values)
+    override fun exec(values: List<Any?>): QueryResult {
+        return connection.exec(sql, values)
+    }

-    override fun exec(values: Map<String, Any?>): QueryResult = connection.exec(sql, values)
+    override fun exec(values: Map<String, Any?>): QueryResult {
+        return connection.exec(sql, values)
+    }

-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun sendQuery(values: List<Any?>): QueryResult = connection.sendQuery(sql, values)
+    override fun sendQuery(values: List<Any?>): Int {
+        return connection.sendQuery(sql, values)
+    }

-    /**
-     * 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
-     */
-    fun sendQuery(vararg values: Pair<String, Any?>): QueryResult = sendQuery(values.toMap())
-}
+    override fun sendQuery(values: Map<String, Any?>): Int {
+        return connection.sendQuery(sql, values)
+    }
+}
--- a/src/main/kotlin/fr/postgresjson/connexion/QueryConverter.kt
+++ b/src/main/kotlin/fr/postgresjson/connexion/QueryConverter.kt
@@ -1,16 +0,0 @@
-package fr.postgresjson.connexion
-
-import fr.postgresjson.utils.searchSqlFiles
-import java.net.URI
-import fr.postgresjson.definition.Query as QueryDefinition
-
-fun QueryDefinition.toRunnable(connection: Connection): Query = Query(name, script, connection)
-
-fun Sequence<QueryDefinition>.toRunnable(connection: Connection): Sequence<Query> = map { it.toRunnable(connection) }
-
-fun Sequence<Query>.toMutableMap(): MutableMap<String, Query> = map { it.name to it }.toMap().toMutableMap()
-
-internal fun URI.toQuery(connection: Connection): MutableMap<String, Query> = searchSqlFiles()
-    .filterIsInstance(QueryDefinition::class.java)
-    .toRunnable(connection)
-    .toMutableMap()
--- a/src/main/kotlin/fr/postgresjson/connexion/Requester.kt
+++ b/src/main/kotlin/fr/postgresjson/connexion/Requester.kt
@@ -3,6 +3,7 @@ package fr.postgresjson.connexion
 import fr.postgresjson.utils.searchSqlFiles
 import java.net.URI
 import fr.postgresjson.definition.Function as DefinitionFunction
+import fr.postgresjson.definition.Function as FunctionDefinition
 import fr.postgresjson.definition.Query as QueryDefinition

 class Requester(
@@ -10,59 +11,101 @@ class Requester(
    private val queries: MutableMap<String, Query> = mutableMapOf(),
    private val functions: MutableMap<String, Function> = mutableMapOf()
 ) {
-    constructor(connection: Connection) : this(connection, mutableMapOf(), mutableMapOf())
-
-    constructor(
-        connection: Connection,
-        queriesDirectory: URI? = null,
-        functionsDirectory: URI? = null
-    ) : this(
-        connection = connection,
-        queries = queriesDirectory?.toQuery(connection) ?: mutableMapOf(),
-        functions = functionsDirectory?.toFunction(connection) ?: mutableMapOf(),
-    )
-
-    fun addQuery(query: Query) {
+    fun addQuery(query: Query): Requester {
        queries[query.name] = query
+        return this
    }

-    fun addQuery(query: QueryDefinition) = addQuery(query.toRunnable(connection))
+    fun addQuery(query: QueryDefinition): Requester = addQuery(query.name, query.script)

-    fun addQuery(name: String, sql: String) {
+    fun addQuery(name: String, sql: String): Requester {
        addQuery(Query(name, sql, connection))
+        return this
    }

-    fun addQuery(queriesDirectory: URI) {
-        queriesDirectory
-            .searchSqlFiles()
-            .filterIsInstance(QueryDefinition::class.java)
-            .forEach(this::addQuery)
+    fun addQuery(queriesDirectory: URI): Requester {
+        queriesDirectory.searchSqlFiles()
+            .forEach {
+                if (it is QueryDefinition) {
+                    addQuery(it)
+                }
+            }
+        return this
    }

-    fun getQueries(): List<Query> = queries.map { it.value }
-
-    fun addFunction(definition: DefinitionFunction) {
-        definition
-            .run { toRunnable(connection) }
-            .run { functions[name] = this }
+    fun getQueries(): List<Query> {
+        return queries.map { it.value }
    }

-    fun addFunction(sql: String) {
-        DefinitionFunction(sql)
-            .run { toRunnable(connection) }
-            .run { functions[name] = this }
+    fun addFunction(definition: DefinitionFunction): Requester {
+        functions[definition.name] = Function(definition, connection)
+        return this
    }

-    fun addFunctions(functionsDirectory: URI) {
+    fun addFunction(sql: String): Requester {
+        DefinitionFunction(sql).let {
+            functions[it.name] = Function(it, connection)
+        }
+        return this
+    }
+
+    fun addFunction(functionsDirectory: URI): Requester {
        functionsDirectory.searchSqlFiles()
-            .filterIsInstance(DefinitionFunction::class.java)
-            .forEach(this::addFunction)
+            .forEach {
+                if (it is FunctionDefinition) {
+                    addFunction(it)
+                }
+            }
+        return this
    }

-    fun getFunction(name: String): Function = functions[name] ?: throw NoFunctionDefined(name)
+    fun getFunction(name: String): Function {
+        if (functions[name] === null) {
+            throw Exception("No function defined for $name")
+        }
+        return functions[name]!!
+    }

-    fun getQuery(path: String): Query = queries[path] ?: throw NoQueryDefined(path)
+    fun getQuery(path: String): Query {
+        if (queries[path] === null) {
+            throw Exception("No query defined in $path")
+        }
+        return queries[path]!!
+    }

-    class NoFunctionDefined(name: String) : Exception("No function defined for $name")
-    class NoQueryDefined(path: String) : Exception("No query defined in $path")
+    class RequesterFactory(
+        private val connection: Connection,
+        private val queriesDirectory: URI? = null,
+        private val functionsDirectory: URI? = null
+    ) {
+        constructor(
+            host: String = "localhost",
+            port: Int = 5432,
+            database: String = "dc-project",
+            username: String = "dc-project",
+            password: String = "dc-project",
+            queriesDirectory: URI? = null,
+            functionsDirectory: URI? = null
+        ) : this(
+            Connection(host = host, port = port, database = database, username = username, password = password),
+            queriesDirectory,
+            functionsDirectory
+        )
+
+        fun createRequester(): Requester {
+            return initRequester(Requester(connection))
+        }
+
+        private fun initRequester(req: Requester): Requester {
+            if (queriesDirectory !== null) {
+                req.addQuery(queriesDirectory)
+            }
+
+            if (functionsDirectory !== null) {
+                req.addFunction(functionsDirectory)
+            }
+
+            return req
+        }
+    }
 }
--- a/src/main/kotlin/fr/postgresjson/definition/Function.kt
+++ b/src/main/kotlin/fr/postgresjson/definition/Function.kt
@@ -1,10 +1,11 @@
 package fr.postgresjson.definition

+import java.io.File
 import java.nio.file.Path

 class Function(
    override val script: String,
-    override val source: Path? = null
+    override var source: Path? = null
 ) : Resource, ParametersInterface {
    val returns: String
    override val name: String
@@ -21,7 +22,7 @@ class Function(

        val queryMatch = functionRegex.find(script)
        if (queryMatch !== null) {
-            val functionName = queryMatch.groups["name"]?.value?.trim() ?: error("Function name not found")
+            val functionName = queryMatch.groups.get("name")?.value?.trim() ?: error("Function name not found")
            val functionParameters = queryMatch.groups["params"]?.value?.trim()
            this.returns = queryMatch.groups["return"]?.value?.trim() ?: ""

@@ -51,12 +52,15 @@ class Function(
    fun getDefinition(): String {
        return parameters
            .filter { it.direction == Parameter.Direction.IN }
-            .joinToString(", ") { "${it.name} ${it.type}" }
-            .let { "$name ($it)" }
+            .joinToString(", ") { "${it.name} ${it.type}" }.let {
+                "$name ($it)"
+            }
    }

    fun getParametersIndexedByName(): Map<String, Parameter> {
-        return parameters.associateBy { it.name }
+        return parameters.map {
+            it.name to it
+        }.toMap()
    }

    infix fun `has same definition`(other: Function): Boolean {
@@ -66,4 +70,21 @@ class Function(
    infix fun `is different from`(other: Function): Boolean {
        return other.script != this.script
    }
-}
+
+    companion object {
+        fun build(source: File): List<Function> {
+            return source.readText()
+                .split(
+                    "CREATE +(OR REPLACE +)?(PROCEDURE|FUNCTION)".toRegex(
+                        setOf(
+                            RegexOption.IGNORE_CASE,
+                            RegexOption.MULTILINE
+                        )
+                    )
+                )
+                .map {
+                    Function("CREATE OR REPLACE FUNCTION $it")
+                }
+        }
+    }
+}
--- a/src/main/kotlin/fr/postgresjson/definition/Migration.kt
+++ b/src/main/kotlin/fr/postgresjson/definition/Migration.kt
@@ -4,12 +4,14 @@ import java.nio.file.Path

 class Migration(
    override val script: String,
-    override var source: Path
+    source: Path
 ) : Resource {
    override val name: String
    val direction: Direction
+    override var source: Path? = null

    init {
+        this.source = source
        this.direction = source.fileName.toString()
            .let {
                when {
@@ -30,4 +32,4 @@ class Migration(

    class MigrationNotFound(cause: Throwable? = null) : Resource.ParseException("Migration not found in script", cause)
    enum class Direction { UP, DOWN }
-}
+}
--- a/src/main/kotlin/fr/postgresjson/definition/Parameter.kt
+++ b/src/main/kotlin/fr/postgresjson/definition/Parameter.kt
@@ -1,7 +1,5 @@
 package fr.postgresjson.definition

-import java.util.Locale
-
 interface ParameterI {
    val name: String
    val type: String
@@ -23,7 +21,7 @@ class Parameter(val name: String, val type: String, direction: Direction? = Dire
    constructor(name: String, type: String, direction: String? = "IN", default: Any? = null) : this(
        name = name,
        type = type,
-        direction = direction?.let { Direction.valueOf(direction.uppercase(Locale.getDefault())) },
+        direction = direction?.let { Direction.valueOf(direction.toUpperCase()) },
        default = default
    )

@@ -32,4 +30,4 @@ class Parameter(val name: String, val type: String, direction: Direction? = Dire

 interface ParametersInterface {
    val parameters: List<Parameter>
-}
+}
--- a/src/main/kotlin/fr/postgresjson/definition/Query.kt
+++ b/src/main/kotlin/fr/postgresjson/definition/Query.kt
@@ -4,8 +4,9 @@ import java.nio.file.Path

 class Query(
    override val script: String,
-    override var source: Path
+    source: Path
 ) : Resource {
+    override var source: Path? = source
    override val name: String = getNameFromComment(script) ?: getNameFromFile(source)

    /** Try to get name from comment in file */
@@ -13,12 +14,12 @@ class Query(
        """-- *name ?: ?(?<name>[^ \n]+)"""
            .toRegex(setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE))
            .find(script)?.let {
-                it.groups["name"]?.value?.trim()
-            }
+            it.groups["name"]?.value?.trim()
+        }

    /** Try to get name from the filename */
    private fun getNameFromFile(source: Path): String = source
        .fileName.toString()
        .substringAfterLast("/")
        .substringBeforeLast(".sql")
-}
+}
--- a/src/main/kotlin/fr/postgresjson/definition/Resource.kt
+++ b/src/main/kotlin/fr/postgresjson/definition/Resource.kt
@@ -4,10 +4,10 @@ import java.io.File
 import java.net.URL
 import java.nio.file.Path

-sealed interface Resource {
+interface Resource {
    val name: String
    val script: String
-    val source: Path?
+    var source: Path?

    open class ParseException(message: String, cause: Throwable? = null) : Exception(message, cause)

@@ -20,10 +20,10 @@ sealed interface Resource {

        fun build(resource: String, path: Path): Resource =
            try {
-                Migration(resource, path)
+                Function(resource, path)
            } catch (e: ParseException) {
                try {
-                    Function(resource, path)
+                    Migration(resource, path)
                } catch (e: ParseException) {
                    try {
                        Query(resource, path)
@@ -34,3 +34,7 @@ sealed interface Resource {
            }
    }
 }
+
+interface ResourceCollection {
+    val parameters: List<Parameter>
+}
--- a/src/main/kotlin/fr/postgresjson/entity/immutable/ImmutableEntity.kt
+++ b/src/main/kotlin/fr/postgresjson/entity/immutable/ImmutableEntity.kt
@@ -1,7 +1,12 @@
-package fr.postgresjson.entity
+package fr.postgresjson.entity.immutable

+import fr.postgresjson.entity.EntityI
+import fr.postgresjson.entity.mutable.EntityDeletedAt
+import fr.postgresjson.entity.mutable.EntityDeletedAtImp
+import fr.postgresjson.entity.mutable.EntityDeletedBy
+import fr.postgresjson.entity.mutable.EntityDeletedByImp
 import org.joda.time.DateTime
-import java.util.UUID
+import java.util.*

 interface EntityRefI<T> : EntityI {
    val id: T
@@ -12,7 +17,7 @@ interface UuidEntityI : EntityRefI<UUID> {
 }

 abstract class Entity<T>(override val id: T) : EntityRefI<T>
-open class UuidEntity(id: UUID? = null) : UuidEntityI, Entity<UUID>(id ?: UUID.randomUUID())
+open class UuidEntity(override val id: UUID = UUID.randomUUID()) : UuidEntityI, Entity<UUID>(id)

 /* Version */
 interface EntityVersioning<ID, NUMBER> {
@@ -21,27 +26,16 @@ interface EntityVersioning<ID, NUMBER> {
 }

 class UuidEntityVersioning(
-    override val versionNumber: Int,
-    versionId: UUID? = null
-) : EntityVersioning<UUID, Int> {
-    override val versionId: UUID = versionId ?: UUID.randomUUID()
-}
+    override var versionNumber: Int? = null,
+    override val versionId: UUID = UUID.randomUUID()
+) : EntityVersioning<UUID, Int?>

 /* 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
-    }
+    var updatedAt: DateTime
 }

 class EntityCreatedAtImp(
@@ -49,23 +43,15 @@ class EntityCreatedAtImp(
 ) : EntityCreatedAt

 class EntityUpdatedAtImp(
-    override val updatedAt: DateTime = DateTime.now()
+    override var 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?
+    var updatedBy: T
 }

 class EntityCreatedByImp<UserT : EntityI>(
@@ -73,13 +59,9 @@ class EntityCreatedByImp<UserT : EntityI>(
 ) : EntityCreatedBy<UserT>

 class EntityUpdatedByImp<UserT : EntityI>(
-    override val updatedBy: UserT
+    override var 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(),
@@ -89,22 +71,10 @@ class EntityCreatedImp<UserT : EntityI>(

 class EntityUpdatedImp<UserT : EntityI>(
    updatedAt: DateTime = DateTime.now(),
-    override val updatedBy: UserT
+    override var 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,
@@ -115,12 +85,4 @@ abstract class EntityImp<T, UserT : EntityI>(
    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)
+    EntityDeletedBy<UserT> by EntityDeletedByImp(updatedBy)
--- a/src/main/kotlin/fr/postgresjson/entity/mutable/MutableEntity.kt
+++ b/src/main/kotlin/fr/postgresjson/entity/mutable/MutableEntity.kt
@@ -0,0 +1,135 @@
+package fr.postgresjson.entity.mutable
+
+import fr.postgresjson.entity.EntityI
+import org.joda.time.DateTime
+import java.util.*
+
+interface EntityRefI<T> : EntityI {
+    var id: T?
+}
+
+interface UuidEntityI : EntityRefI<UUID> {
+    override var id: UUID?
+}
+
+interface IdEntityI : EntityRefI<Int> {
+    override var id: Int?
+}
+
+abstract class Entity<T>(override var id: T? = null) : EntityRefI<T>
+open class UuidEntity(override var id: UUID? = UUID.randomUUID()) : UuidEntityI, Entity<UUID>(id)
+open class IdEntity(override var id: Int? = null) : IdEntityI, Entity<Int>(id)
+
+/* Version */
+interface EntityVersioning<ID, NUMBER> {
+    var versionId: ID
+    var versionNumber: NUMBER?
+}
+
+class UuidEntityVersioning(
+    override var versionNumber: Int? = null,
+    override var versionId: UUID = UUID.randomUUID()
+) : EntityVersioning<UUID, Int>
+
+/* Dates */
+interface EntityCreatedAt {
+    var createdAt: DateTime?
+}
+
+interface EntityUpdatedAt {
+    var updatedAt: DateTime?
+}
+
+interface EntityDeletedAt {
+    var deletedAt: DateTime?
+    fun isDeleted(): Boolean {
+        val deletedAt = deletedAt
+        return deletedAt != null && deletedAt < DateTime.now()
+    }
+}
+
+class EntityCreatedAtImp : EntityCreatedAt {
+    override var createdAt: DateTime? = null
+}
+
+class EntityUpdatedAtImp : EntityUpdatedAt {
+    override var updatedAt: DateTime? = null
+}
+
+class EntityDeletedAtImp : EntityDeletedAt {
+    override var deletedAt: DateTime? = null
+}
+
+/* Author */
+interface EntityCreatedBy<T : EntityI> {
+    var createdBy: T?
+}
+
+interface EntityUpdatedBy<T : EntityI> {
+    var updatedBy: T?
+}
+
+interface EntityDeletedBy<T : EntityI> {
+    var deletedBy: T?
+}
+
+class EntityCreatedByImp<UserT : EntityI>(
+    override var createdBy: UserT?
+) : EntityCreatedBy<UserT>
+
+class EntityUpdatedByImp<UserT : EntityI>(
+    override var updatedBy: UserT?
+) : EntityUpdatedBy<UserT>
+
+class EntityDeletedByImp<UserT : EntityI>(
+    override var deletedBy: UserT?
+) : EntityDeletedBy<UserT>
+
+/* Mixed */
+class EntityDeletedImp<UserT : EntityI>(
+    override var deletedBy: UserT? = null
+) : EntityDeletedBy<UserT>,
+    EntityDeletedAt by EntityDeletedAtImp()
+
+class EntityUpdatedImp<UserT : EntityI>(
+    override var updatedAt: DateTime? = null,
+    override var updatedBy: UserT? = null
+) : EntityUpdatedBy<UserT>,
+    EntityUpdatedAt by EntityUpdatedAtImp()
+
+class EntityCreatedImp<UserT : EntityI>(
+    override var createdAt: DateTime? = null,
+    override var createdBy: UserT? = null
+) : EntityCreatedBy<UserT>,
+    EntityCreatedAt by EntityCreatedAtImp()
+
+/* Published */
+interface Published<UserT : EntityI> {
+    var publishedAt: DateTime?
+    var publishedBy: UserT?
+}
+
+class EntityPublishedImp<UserT : EntityI>(
+    override var publishedBy: UserT?
+) : Published<UserT> {
+    override var publishedAt: DateTime? = null
+}
+
+/* Implementation */
+abstract class EntityImp<T, UserT : EntityI>(
+    updatedBy: UserT?
+) : Entity<T>(),
+    EntityCreatedAt by EntityCreatedAtImp(),
+    EntityUpdatedAt by EntityUpdatedAtImp(),
+    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(),
+    Published<UserT> by EntityPublishedImp(publishedBy)
--- a/src/main/kotlin/fr/postgresjson/migration/Function.kt
+++ b/src/main/kotlin/fr/postgresjson/migration/Function.kt
@@ -2,11 +2,10 @@ 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.migration.Migration.Action
 import fr.postgresjson.migration.Migration.Status
-import java.util.Date
-import java.util.concurrent.CompletionException
+import java.util.*
+import java.util.concurrent.*
 import fr.postgresjson.definition.Function as DefinitionFunction

 data class Function(
@@ -37,59 +36,61 @@ data class Function(
    )

    override fun up(): Status {
-        return try {
-            try {
+        try {
+            connection.sendQuery(up.script)
+        } catch (e: CompletionException) {
+            val cause = e.cause
+            if (cause is GenericDatabaseException && cause.errorMessage.fields['C'] == "42P13") {
+                connection.sendQuery("drop function ${down.getDefinition()}")
                connection.sendQuery(up.script)
-            } catch (e: CompletionException) {
-                val cause = e.cause
-                if (cause is GenericDatabaseException && cause.errorMessage.fields['C'] == "42P13") {
-                    connection.sendQuery("drop function ${down.getDefinition()}")
-                    connection.sendQuery(up.script)
-                }
            }
-
-            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 { function ->
-                    executedAt = function.executedAt
-                    doExecute = Action.OK
-                }
-
-            Status.OK
-        } catch (e: Throwable) {
-            Status.UP_FAIL
        }
+
+        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 { function ->
+                executedAt = function.executedAt
+                doExecute = Action.OK
+            }
+        }
+        return Status.OK
    }

    override fun down(): Status {
-        return try {
-            connection.sendQuery(down.script)
+        connection.sendQuery(down.script)

-            this::class.java.classLoader
-                .getResource("sql/migration/deleteFunction.sql")!!
-                .readText()
-                .let { connection.sendQuery(it, listOf(down.name)) }
-
-            Status.OK
-        } catch (e: Throwable) {
-            Status.DOWN_FAIL
+        this::class.java.classLoader.getResource("sql/migration/deleteFunction.sql")!!.readText().let {
+            connection.sendQuery(it, listOf(down.name))
        }
+        return Status.OK
    }

    override fun test(): Status {
        connection.inTransaction {
            up()
            down()
-            sendQuery("ROLLBACK")
-        }
+            it.sendQuery("ROLLBACK")
+        }.join()

-        return Status.OK
+        return Status.OK // TODO
    }

-    fun copy(): Function = this
-        .copy(up = up, down = down, connection = connection, executedAt = executedAt)
-        .also { it.doExecute = this.doExecute }
+    override fun status(): Status {
+        connection.inTransaction {
+            up()
+            down()
+            it.sendQuery("ROLLBACK")
+        }.join()

-    infix fun `is different from`(other: DefinitionFunction): Boolean = other.script != this.up.script
-}
+        return Status.OK // TODO
+    }
+
+    fun copy(): Function {
+        return this.copy(up = up, down = down, connection = connection, executedAt = executedAt).also {
+            it.doExecute = this.doExecute
+        }
+    }
+
+    infix fun `is different from`(other: DefinitionFunction): Boolean {
+        return other.script != this.up.script
+    }
+}
--- a/src/main/kotlin/fr/postgresjson/migration/Migrations.kt
+++ b/src/main/kotlin/fr/postgresjson/migration/Migrations.kt
@@ -2,7 +2,8 @@ package fr.postgresjson.migration

 import com.fasterxml.jackson.core.type.TypeReference
 import fr.postgresjson.connexion.Connection
-import fr.postgresjson.entity.Entity
+import fr.postgresjson.definition.Migration as DefinitionMigration
+import fr.postgresjson.entity.mutable.Entity
 import fr.postgresjson.migration.Migration.Action
 import fr.postgresjson.migration.Migration.Status
 import fr.postgresjson.utils.LoggerDelegate
@@ -10,9 +11,8 @@ import fr.postgresjson.utils.searchSqlFiles
 import org.slf4j.Logger
 import java.io.FileNotFoundException
 import java.net.URI
-import java.util.Date
+import java.util.*
 import fr.postgresjson.definition.Function as DefinitionFunction
-import fr.postgresjson.definition.Migration as DefinitionMigration

 class MigrationEntity(
    val filename: String,
@@ -28,20 +28,20 @@ interface Migration {
    fun up(): Status
    fun down(): Status
    fun test(): Status
+    fun status(): Status

-    enum class Status(val i: Int) { OK(2), UP_FAIL(0), DOWN_FAIL(1) }
+    enum class Status(i: Int) { OK(2), UP_FAIL(0), DOWN_FAIL(1) }
    enum class Action { OK, UP, DOWN }
 }

-class Migrations private constructor(
+data class Migrations private constructor(
    private val connection: Connection,
-    private val migrationsScripts: MutableMap<String, MigrationScript> = mutableMapOf(),
+    private val migrationsScripts: MutableMap<String, Query> = mutableMapOf(),
    private val functions: MutableMap<String, Function> = mutableMapOf()
 ) {
    private var directories: List<URI> = emptyList()
    private val logger: Logger? by LoggerDelegate()
    constructor(directory: URI, connection: Connection) : this(listOf(directory), connection)
-    constructor(connection: Connection, vararg directory: URI) : this(directory.toList(), connection)

    constructor(directories: List<URI>, connection: Connection) : this(connection) {
        initDB()
@@ -49,7 +49,7 @@ class Migrations private constructor(
        reset()
    }

-    private fun reset() {
+    fun reset() {
        migrationsScripts.clear()
        functions.clear()

@@ -76,16 +76,16 @@ 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.select<MigrationEntity>(it, object : TypeReference<List<MigrationEntity>>() {})
                .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.select<MigrationEntity>(it, object : TypeReference<List<MigrationEntity>>() {})
                .map { query ->
-                    migrationsScripts[query.filename] = MigrationScript(query.filename, query.up, query.down, connection, query.executedAt)
+                    migrationsScripts[query.filename] = Query(query.filename, query.up, query.down, connection, query.executedAt)
                }
        }
    }
@@ -105,8 +105,8 @@ class Migrations private constructor(
    private fun getMigrationFromDirectory(directory: URI) {
        val downs: MutableMap<String, DefinitionMigration> = mutableMapOf()

+        /* Set Down Migration */
        directory.searchSqlFiles().apply {
-            /* Set Down Migration */
            forEach { migration ->
                if (migration is DefinitionMigration && migration.direction == DefinitionMigration.Direction.DOWN) {
                    downs += migration.name to migration
@@ -119,7 +119,7 @@ class Migrations private constructor(
                    val down = downs[migration.name] ?: throw DownMigrationNotDefined(migration.name + ".down.sql")
                    downs -= migration.name

-                    addMigrationScript(migration, down)
+                    addQuery(migration, down)
                } else if (migration is DefinitionFunction) {
                    addFunction(migration)
                }
@@ -130,7 +130,7 @@ class Migrations private constructor(
    enum class Direction { UP, DOWN }

    internal class DownMigrationNotDefined(path: String, cause: FileNotFoundException? = null) :
-        Throwable("The file $path was not found", cause)
+        Throwable("The file $path whas not found", cause)

    fun addFunction(newDefinition: DefinitionFunction, callback: (Function) -> Unit = {}): Migrations {
        val currentFunction = functions[newDefinition.name]
@@ -153,12 +153,12 @@ class Migrations private constructor(
        return this
    }

-    fun addMigrationScript(up: DefinitionMigration, down: DefinitionMigration, callback: (MigrationScript) -> Unit = {}): Migrations =
-        addMigrationScript(up.name, up.script, down.script, callback)
+    fun addQuery(up: DefinitionMigration, down: DefinitionMigration, callback: (Query) -> Unit = {}): Migrations =
+        addQuery(up.name, up.script, down.script, callback)

-    fun addMigrationScript(name: String, up: String, down: String, callback: (MigrationScript) -> Unit = {}): Migrations {
+    fun addQuery(name: String, up: String, down: String, callback: (Query) -> Unit = {}): Migrations {
        if (migrationsScripts[name] === null) {
-            migrationsScripts[name] = MigrationScript(name, up, down, connection).apply {
+            migrationsScripts[name] = Query(name, up, down, connection).apply {
                doExecute = Action.UP
            }
        } else {
@@ -174,10 +174,10 @@ class Migrations private constructor(

    private fun initDB() {
        if (!initialized) {
-            this::class.java.classLoader.getResource("sql/migration/createHistorySchema.sql")!!.readText().let {
+            this::class.java.classLoader.getResource("sql/migration/createHistoryShema.sql")!!.readText().let {
                connection.sendQuery(it)
            }
-            this::class.java.classLoader.getResource("sql/migration/createFunctionSchema.sql")!!.readText().let {
+            this::class.java.classLoader.getResource("sql/migration/createFunctionShema.sql")!!.readText().let {
                connection.sendQuery(it)
            }
            initialized = true
@@ -297,7 +297,7 @@ class Migrations private constructor(
        return list.toMap()
    }

-    private fun copy(): Migrations {
+    fun copy(): Migrations {
        val queriesCopy = migrationsScripts.map {
            it.key to it.value.copy()
        }.toMap().toMutableMap()
@@ -312,4 +312,4 @@ class Migrations private constructor(
    fun status(): Map<String, Int> {
        TODO("not implemented")
    }
-}
+}
--- a/src/main/kotlin/fr/postgresjson/migration/MigrationScript.kt
+++ b/src/main/kotlin/fr/postgresjson/migration/MigrationScript.kt
@@ -1,12 +1,11 @@
 package fr.postgresjson.migration

 import fr.postgresjson.connexion.Connection
-import fr.postgresjson.connexion.selectOne
-import fr.postgresjson.entity.Entity
+import fr.postgresjson.entity.mutable.Entity
 import fr.postgresjson.migration.Migration.Action
-import java.util.Date
+import java.util.*

-data class MigrationScript(
+data class Query(
    val name: String,
    val up: String,
    val down: String,
@@ -42,15 +41,25 @@ data class MigrationScript(
        connection.inTransaction {
            up()
            down()
-            sendQuery("ROLLBACK")
-        }
+            it.sendQuery("ROLLBACK")
+        }.join()

-        return Migration.Status.OK
+        return Migration.Status.OK // TODO
    }

-    fun copy(): MigrationScript {
+    override fun status(): Migration.Status {
+        connection.inTransaction {
+            up()
+            down()
+            it.sendQuery("ROLLBACK")
+        }.join()
+
+        return Migration.Status.OK // TODO
+    }
+
+    fun copy(): Query {
        return this.copy(name = name, up = up, down = down, connection = connection, executedAt = executedAt).also {
            it.doExecute = this.doExecute
        }
    }
-}
+}
--- a/src/main/kotlin/fr/postgresjson/serializer/Serializer.kt
+++ b/src/main/kotlin/fr/postgresjson/serializer/Serializer.kt
@@ -3,7 +3,7 @@ package fr.postgresjson.serializer
 import com.fasterxml.jackson.core.type.TypeReference
 import com.fasterxml.jackson.databind.DeserializationFeature
 import com.fasterxml.jackson.databind.ObjectMapper
-import com.fasterxml.jackson.databind.PropertyNamingStrategies
+import com.fasterxml.jackson.databind.PropertyNamingStrategy
 import com.fasterxml.jackson.databind.SerializationFeature
 import com.fasterxml.jackson.databind.module.SimpleModule
 import com.fasterxml.jackson.datatype.joda.JodaModule
@@ -15,7 +15,7 @@ class Serializer(val mapper: ObjectMapper = jacksonObjectMapper()) {
    init {
        val module = SimpleModule()
        mapper.registerModule(module)
-        mapper.propertyNamingStrategy = PropertyNamingStrategies.SNAKE_CASE
+        mapper.propertyNamingStrategy = PropertyNamingStrategy.SNAKE_CASE

        mapper.registerModule(JodaModule())
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
@@ -42,10 +42,13 @@ class Serializer(val mapper: ObjectMapper = jacksonObjectMapper()) {
    inline fun <reified E> deserializeList(json: String): E {
        return deserializeList(json, object : TypeReference<E>() {})
    }
+
+    fun <E> deserialize(json: String, target: E): E {
+        return mapper.readerForUpdating(target).readValue<E>(json)
+    }
 }

 fun Serializable.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
 fun List<Serializable>.serialize(pretty: Boolean = false) = Serializer().serialize(this, pretty)
-inline fun <reified E : Serializable> String.deserialize() = Serializer().deserialize<E>(this)
-
-inline fun <reified T : Serializable> T.toTypeReference(): TypeReference<T> = object : TypeReference<T>() {}
+inline fun <reified E : Serializable> E.deserialize(json: String) = Serializer().deserialize(json, this)
+inline fun <reified E : Serializable> String.deserialize() = Serializer().deserialize<E>(this)
--- a/src/main/kotlin/fr/postgresjson/utils/LoggerDelegate.kt
+++ b/src/main/kotlin/fr/postgresjson/utils/LoggerDelegate.kt
@@ -6,5 +6,5 @@ import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty

 internal class LoggerDelegate<in R : Any> : ReadOnlyProperty<R, Logger> {
-    override fun getValue(thisRef: R, property: KProperty<*>): Logger = LoggerFactory.getLogger(thisRef.javaClass.packageName)
-}
+    override fun getValue(thisRef: R, property: KProperty<*>) = LoggerFactory.getLogger(thisRef.javaClass.packageName)
+}
--- a/src/main/kotlin/fr/postgresjson/utils/searchSqlFiles.kt
+++ b/src/main/kotlin/fr/postgresjson/utils/searchSqlFiles.kt
@@ -5,7 +5,6 @@ import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import java.net.URI
 import java.net.URL
-import java.nio.file.FileSystemNotFoundException
 import java.nio.file.FileSystems
 import java.nio.file.FileVisitOption
 import java.nio.file.Files
@@ -14,22 +13,18 @@ import kotlin.streams.asSequence

 fun URL.searchSqlFiles() = this.toURI().searchSqlFiles()

-fun URI.searchSqlFiles() = sequence {
+fun URI.searchSqlFiles() = sequence<Resource> {
    val logger: Logger = LoggerFactory.getLogger("sqlFilesSearch")
    val uri: URI = this@searchSqlFiles
-    logger.debug("""SQL files found in "${uri.toString().substringAfter('!')}" :""")
    if (uri.scheme == "jar") {
-        try {
-            FileSystems.getFileSystem(uri)
-        } catch (e: FileSystemNotFoundException) {
-            FileSystems.newFileSystem(uri, emptyMap<String, Any>())
-        }
-
-        uri
+        val relativePath = uri.toString().substringAfter('!')
+        FileSystems
+            .newFileSystem(uri, emptyMap<String, Any>())
+            .getPath(relativePath)
            .walk(5)
            .asSequence()
            .filter { it.fileName.toString().endsWith(".sql") }
-            .map { it.toUri().toURL() }
+            .map { this::class.java.getResource(path.toString()) }
            .forEach {
                logger.debug(it.toString())
                yield(Resource.build(it))
@@ -47,5 +42,5 @@ fun URI.searchSqlFiles() = sequence {
    }
 }

-private fun Path.walk(maxDepth: Int = 2147483647, vararg options: FileVisitOption) = Files.walk(this, maxDepth, *options).sorted()
-private fun URI.walk(maxDepth: Int = 2147483647, vararg options: FileVisitOption) = Files.walk(Path.of(this), maxDepth, *options).sorted()
+private fun Path.walk(maxDepth: Int = 2147483647, vararg options: FileVisitOption) = Files.walk(this, maxDepth, *options)
+private fun URI.walk(maxDepth: Int = 2147483647, vararg options: FileVisitOption) = Files.walk(Path.of(this), maxDepth, *options)
--- a/src/main/resources/sql/migration/createFunctionSchema.sql
+++ b/src/main/resources/sql/migration/createFunctionSchema.sql
--- a/src/main/resources/sql/migration/createHistorySchema.sql
+++ b/src/main/resources/sql/migration/createHistorySchema.sql
--- a/src/test/kotlin/fr/postgresjson/ConnectionTest.kt
+++ b/src/test/kotlin/fr/postgresjson/ConnectionTest.kt
@@ -1,179 +1,139 @@
 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.select
-import fr.postgresjson.connexion.selectOne
+import fr.postgresjson.entity.mutable.IdEntity
 import fr.postgresjson.entity.Parameter
-import fr.postgresjson.entity.UuidEntity
-import fr.postgresjson.serializer.deserialize
-import fr.postgresjson.serializer.toTypeReference
+import org.junit.Assert.*
+import org.junit.jupiter.api.Assertions
 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.test.assertEquals
-import kotlin.test.assertNotNull
-import kotlin.test.assertNull
-import kotlin.test.assertTrue

@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)
-    private class ObjTest2(val title: String, var test: ObjTest?) : UuidEntity()
-    private class ObjTest3(val first: String, var second: String, var third: Int) : UuidEntity()
-    private class ObjTestWithParameterObject(var first: ParameterObject, var second: ParameterObject) : UuidEntity()
+class ConnectionTest() : TestAbstract() {
+    private class ObjTest(var name: String) : IdEntity()
+    private class ObjTest2(var title: String, var test: ObjTest?) : IdEntity()
+    private class ObjTest3(var first: String, var seconde: String, var third: Int) : IdEntity()
+    private class ObjTestWithParameterObject(var first: ParameterObject, var seconde: ParameterObject) : IdEntity()
    private class ParameterObject(var third: String) : Parameter

    @Test
    fun getObject() {
        val obj: ObjTest? = connection.selectOne("select to_json(a) from test a limit 1")
        assertTrue(obj is ObjTest)
-        assertEquals(UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"), obj.id)
+        assertTrue(obj!!.id == 1)
    }

    @Test
    fun getExistingObject() {
-        val objs: List<ObjTest2> = connection.select(
-            """
-            select
-                json_agg(j)
-                FROM (
-                SELECT
-                    t.id, t.title,
-                    t2 as test
-                from test2 t
-                JOIN test t2 ON t.test_id = t2.id
-            ) j;
-            """.trimIndent()
+        val objs: List<ObjTest2> = connection.select("""
+        select
+            json_agg(j)
+            FROM (
+            SELECT
+                t.id, t.title,
+                t2 as test
+            from test2 t
+            JOIN test t2 ON t.test_id = t2.id
+        ) j;
+        """.trimIndent()
        )
        assertNotNull(objs)
        assertEquals(objs.size, 2)
-        assertEquals(objs[0].id, UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
-        assertEquals(objs[0].test!!.id, UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"))
+        assertEquals(objs[0].id, 1)
+        assertEquals(objs[0].test!!.id, 1)
    }

    @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"))
+    fun callRequestWithArgs() {
+        val result: ObjTest? = connection.selectOne("select json_build_object('id', 1, '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>() {}) {
-            assertEquals("myName", this.rows[0].getString(0)?.deserialize<ObjTest>()?.name)
-        }
-        assertNotNull(result)
-        assertEquals("myName", result.name)
-    }
-
-    @Test
-    fun `test call request return null`() {
-        val result: ObjTest? = connection.selectOne("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>() {})
-        assertNull(result)
+        assertEquals("myName", result!!.name)
    }

    @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 o = ObjTest("myName")
+        o.id = 88
+        val obj: ObjTest? = connection.selectOne("select json_build_object('id', id, 'name', name) FROM json_to_record(?::json) as o(id int, name text);", listOf(o))
        assertNotNull(obj)
-        assertEquals(UUID.fromString("2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00"), obj.id)
-        assertEquals("myName", obj.name)
-    }
-
-    @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)
-        assertTrue(objUpdated is ObjTest)
-        assertEquals(UUID.fromString("1e5f5d41-6d14-4007-897b-0ed2616bec96"), objUpdated.id)
-        assertEquals("after", objUpdated.name)
+        assertTrue(obj is ObjTest)
+        assertEquals(obj!!.id, 88)
+        assertEquals(obj.name, "myName")
    }

    @Test
    fun callExec() {
        val o = ObjTest("myName")
-        val result = connection.exec("select json_build_object('id', '2c0243ed-ff4d-4b9f-a52b-e38c71b0ed00', 'name', ?::json->>'name')", listOf(o))
-        assertEquals(1, result.rowsAffected)
+        val result = connection.exec("select json_build_object('id', 1, 'name', ?::json->>'name')", listOf(o))
+        Assertions.assertEquals(1, result.rowsAffected)
    }

    @Test
    fun `select one with named parameters`() {
        val result: ObjTest3? = connection.selectOne(
-            "SELECT json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int)",
+            "SELECT json_build_object('first', :first::text, 'seconde', :seconde::text, 'third', :third::int)",
            mapOf(
                "first" to "ff",
-                "second" to "sec",
+                "seconde" to "sec",
                "third" to 123
            )
        )
-        assertNotNull(result)
-        assertEquals("ff", result.first)
-        assertEquals("sec", result.second)
-        assertEquals(123, result.third)
+        assertEquals(result!!.first, "ff")
+        assertEquals(result.seconde, "sec")
+        assertEquals(result.third, 123)
    }

    @Test
    fun `select one with named parameters object`() {
        val result: ObjTestWithParameterObject? = connection.selectOne(
-            "SELECT json_build_object('first', :first::json, 'second', :second::json)",
+            "SELECT json_build_object('first', :first::json, 'seconde', :seconde::json)",
            mapOf(
                "first" to ParameterObject("one"),
-                "second" to ParameterObject("two")
+                "seconde" to ParameterObject("two")
            )
        )
-        assertNotNull(result)
-        assertEquals("one", result.first.third)
-        assertEquals("two", result.second.third)
+        assertEquals("one", result!!.first.third)
+        assertEquals("two", result.seconde.third)
    }

    @Test
    fun `select with named parameters`() {
+        val params: Map<String, Any?> = mapOf(
+            "first" to "ff",
+            "third" to 123,
+            "seconde" to "sec"
+        )
        val result: List<ObjTest3> = connection.select(
            """
            SELECT json_build_array(
-                json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int),
-                json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int)
+                json_build_object('first', :first::text, 'seconde', :seconde::text, 'third', :third::int),
+                json_build_object('first', :first::text, 'seconde', :seconde::text, 'third', :third::int)
            )
            """.trimIndent(),
-            mapOf(
-                "first" to "ff",
-                "third" to 123,
-                "second" to "sec"
-            )
+            params
        )
-        assertEquals("ff", result[0].first)
-        assertEquals("sec", result[0].second)
-        assertEquals(123, result[0].third)
+        assertEquals(result[0].first, "ff")
+        assertEquals(result[0].seconde, "sec")
+        assertEquals(result[0].third, 123)
    }

    @Test
-    fun `select with named parameters as vararg of Pair`() {
-        val result: List<ObjTest3> = connection.select(
-            """
-            SELECT json_build_array(
-                json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int),
-                json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int)
-            )
-            """.trimIndent(),
+    fun `selectOne with named parameters`() {
+        val params: Map<String, Any?> = mapOf(
            "first" to "ff",
            "third" to 123,
-            "second" to "sec"
+            "seconde" to "sec"
        )
-        assertEquals("ff", result[0].first)
-        assertEquals("sec", result[0].second)
-        assertEquals(123, result[0].third)
+        val result: ObjTest3? = connection.selectOne(
+            """
+            SELECT json_build_object('first', :first::text, 'seconde', :seconde::text, 'third', :third::int)
+            """.trimIndent(),
+            params
+        )
+        assertNotNull(result)
+        assertEquals(result!!.first, "ff")
+        assertEquals(result.seconde, "sec")
+        assertEquals(result.third, 123)
    }

    @Test
@@ -181,8 +141,8 @@ class ConnectionTest : TestAbstract() {
        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')
+                json_build_object('id', 3, 'name', :name::text),
+                json_build_object('id', 4, 'name', :name::text || '-2')
            ), 10 as total
            LIMIT :limit OFFSET :offset
            """.trimIndent(),
@@ -192,135 +152,10 @@ class ConnectionTest : TestAbstract() {

        )
        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
-        )
+        assertEquals(result.result[0].name, "ff")
+        assertEquals(result.result[1].name, "ff-2")
+        assertEquals(result.total, 10)
+        assertEquals(result.offset, 0)
    }

    @Test
@@ -328,54 +163,20 @@ class ConnectionTest : TestAbstract() {
        val params: Map<String, Any?> = mapOf(
            "first" to "ff",
            "third" to 123,
-            "second" to "sec"
+            "seconde" to "sec"
        )
        val result: ObjTest3? = connection.selectOne(
            """
-            SELECT json_build_object('first', :first::text, 'second', :second::text, 'third', :third::int), 'plop'::text as other
+            SELECT json_build_object('first', :first::text, 'seconde', :seconde::text, 'third', :third::int), 'plop'::text as other
            """.trimIndent(),
            params
        ) {
-            assertNotNull(it)
-            assertEquals("ff", it.first)
+            assertEquals("ff", it!!.first)
            assertEquals("plop", rows[0].getString("other"))
        }
        assertNotNull(result)
-        assertEquals("ff", result.first)
-        assertEquals("sec", result.second)
+        assertEquals("ff", result!!.first)
+        assertEquals("sec", result.seconde)
        assertEquals(123, result.third)
    }
-
-    @Test
-    fun `test exec without parameters`() {
-        connection.exec("select 42, 'hello';").run {
-            assertEquals(42, rows[0].getInt(0))
-            assertEquals("hello", rows[0].getString(1))
-        }
-    }
-
-    @Test
-    fun `test exec with one object as parameter`() {
-        val obj = ObjTest("myName", UUID.fromString("c606e216-53b3-43c8-a900-e727cb4a017c"))
-        connection.exec("select ?::jsonb->>'name'", obj).run {
-            assertEquals("myName", rows[0].getString(0))
-        }
-    }
-
-    @Test
-    fun `select one in transaction`() {
-        connection.inTransaction {
-            selectOne<ObjTestWithParameterObject>(
-                "SELECT json_build_object('first', :first::json, 'second', :second::json)",
-                mapOf(
-                    "first" to ParameterObject("one"),
-                    "second" to ParameterObject("two")
-                )
-            ).let { result ->
-                assertNotNull(result)
-                assertEquals("one", result.first.third)
-                assertEquals("two", result.second.third)
-            }
-        }
-    }
-}
+}
--- a/src/test/kotlin/fr/postgresjson/EntityTest.kt
+++ b/src/test/kotlin/fr/postgresjson/EntityTest.kt
@@ -1,34 +1,27 @@
 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 fr.postgresjson.entity.mutable.*
 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())
+    private class User(id: Int?) : Entity<Int?>(id)
+    private class ObjTest(var name: String) : UuidEntityExtended<Int?, User>(User(1), User(2))

    @Test
    fun getObject() {
-        val obj = ObjTest("plop")
+        val obj: ObjTest? = ObjTest("plop")
        assertTrue(obj is ObjTest)
        assertTrue(obj is UuidEntityExtended<Int?, User>)
        assertTrue(obj is EntityI)
-        assertTrue(obj is Entity<UUID>)
+        assertTrue(obj is Entity<Int?>)
        assertTrue(obj is Published<User>)
        assertTrue(obj is EntityCreatedBy<User>)
        assertTrue(obj is EntityUpdatedBy<User>)
        assertTrue(obj is EntityCreatedAt)
        assertTrue(obj is EntityUpdatedAt)
    }
-}
+}
--- a/src/test/kotlin/fr/postgresjson/MigrationTest.kt
+++ b/src/test/kotlin/fr/postgresjson/MigrationTest.kt
@@ -1,24 +1,22 @@
 package fr.postgresjson

 import fr.postgresjson.connexion.Requester
-import fr.postgresjson.connexion.selectOne
 import fr.postgresjson.migration.Migration
 import fr.postgresjson.migration.Migrations
-import org.amshove.kluent.invoking
 import org.amshove.kluent.`should be equal to`
 import org.amshove.kluent.`should contain`
+import org.amshove.kluent.invoking
 import org.amshove.kluent.shouldThrow
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import java.util.UUID

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
-class MigrationTest : TestAbstract() {
+class MigrationTest() : TestAbstract() {
    @Test
    fun `run up query`() {
-        val resources = this::class.java.getResource("/sql/migrations")!!.toURI()
-        val m = Migrations(connection, resources)
+        val resources = this::class.java.getResource("/sql/migrations").toURI()
+        val m = Migrations(resources, connection)
        m.up().apply {
            this `should contain` Pair("1", Migration.Status.OK)
            size `should be equal to` 1
@@ -29,7 +27,7 @@ class MigrationTest : TestAbstract() {

    @Test
    fun `migration up Query should throw error if no down`() {
-        val resources = this::class.java.getResource("/sql/migration_without_down")!!.toURI()
+        val resources = this::class.java.getResource("/sql/migration_without_down").toURI()
        invoking {
            Migrations(resources, connection)
        } shouldThrow Migrations.DownMigrationNotDefined::class
@@ -37,7 +35,7 @@ class MigrationTest : TestAbstract() {

    @Test
    fun `run forced down query`() {
-        val resources = this::class.java.getResource("/sql/migrations")!!.toURI()
+        val resources = this::class.java.getResource("/sql/migrations").toURI()
        val m = Migrations(resources, connection)
        repeat(3) {
            m.down(true).apply {
@@ -49,7 +47,7 @@ class MigrationTest : TestAbstract() {

    @Test
    fun `run dry migrations`() {
-        val resources = this::class.java.getResource("/sql/real_migrations")!!.toURI()
+        val resources = this::class.java.getResource("/sql/real_migrations").toURI()
        Migrations(resources, connection).apply {
            runDry().size `should be equal to` 2
        }
@@ -60,7 +58,7 @@ class MigrationTest : TestAbstract() {

    @Test
    fun `run dry migrations launch twice`() {
-        val resources = this::class.java.getResource("/sql/real_migrations")!!.toURI()
+        val resources = this::class.java.getResource("/sql/real_migrations").toURI()
        Migrations(resources, connection).apply {
            runDry().size `should be equal to` 2
            runDry().size `should be equal to` 2
@@ -69,7 +67,7 @@ class MigrationTest : TestAbstract() {

    @Test
    fun `run migrations`() {
-        val resources = this::class.java.getResource("/sql/real_migrations")!!.toURI()
+        val resources = this::class.java.getResource("/sql/real_migrations").toURI()
        Migrations(resources, connection).apply {
            run().apply {
                size `should be equal to` 1
@@ -79,8 +77,8 @@ class MigrationTest : TestAbstract() {

    @Test
    fun `run migrations force down`() {
-        val resources = this::class.java.getResource("/sql/real_migrations")!!.toURI()
-        val resourcesFunctions = this::class.java.getResource("/sql/function/Test")!!.toURI()
+        val resources = this::class.java.getResource("/sql/real_migrations").toURI()
+        val resourcesFunctions = this::class.java.getResource("/sql/function/Test").toURI()
        Migrations(listOf(resources, resourcesFunctions), connection).apply {
            up().apply {
                size `should be equal to` 6
@@ -95,36 +93,38 @@ class MigrationTest : TestAbstract() {

    @Test
    fun `run functions migrations`() {
-        val resources = this::class.java.getResource("/sql/function/Test")!!.toURI()
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
        Migrations(resources, connection).apply {
            run().size `should be equal to` 5
        }

-        val objTest: RequesterTest.ObjTest? = Requester(connection, functionsDirectory = resources)
+        val objTest: RequesterTest.ObjTest? = Requester(connection)
+            .addFunction(resources)
            .getFunction("test_function")
            .selectOne(listOf("test", "plip"))

-        Assertions.assertEquals(objTest!!.id, UUID.fromString("457daad5-4f1b-4eb7-80ec-6882adb8cc7d"))
+        Assertions.assertEquals(objTest!!.id, 3)
        Assertions.assertEquals(objTest.name, "test")
    }

    @Test
    fun `run functions migrations and drop if exist`() {
-        val resources = this::class.java.getResource("/sql/function/Test1")!!.toURI()
+        val resources = this::class.java.getResource("/sql/function/Test1").toURI()
        Migrations(resources, connection).apply {
            run().size `should be equal to` 1
        }

-        val objTest: RequesterTest.ObjTest? = Requester(connection, functionsDirectory = resources)
+        val objTest: RequesterTest.ObjTest? = Requester(connection)
+            .addFunction(resources)
            .getFunction("test_function_duplicate")
            .selectOne(listOf("test"))

-        Assertions.assertEquals(objTest!!.id, UUID.fromString("457daad5-4f1b-4eb7-80ec-6882adb8cc7d"))
+        Assertions.assertEquals(objTest!!.id, 3)
        Assertions.assertEquals(objTest.name, "test")

-        val resources2 = this::class.java.getResource("/sql/function/Test2")!!.toURI()
+        val resources2 = this::class.java.getResource("/sql/function/Test2").toURI()
        Migrations(resources2, connection).apply {
            run().size `should be equal to` 1
        }
    }
-}
+}
--- a/src/test/kotlin/fr/postgresjson/RequesterTest.kt
+++ b/src/test/kotlin/fr/postgresjson/RequesterTest.kt
@@ -1,174 +1,55 @@
 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.selectOne
-import fr.postgresjson.connexion.update
-import fr.postgresjson.entity.UuidEntity
-import fr.postgresjson.serializer.deserialize
-import org.junit.jupiter.api.Assertions.assertThrows
+import fr.postgresjson.entity.mutable.IdEntity
+import org.junit.Assert
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
-import java.util.UUID
-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)
-
-    @Test
-    fun `requester constructor empty`() {
-        val resources = this::class.java.getResource("/sql/function/Test")!!.toURI()
-        val name: String = Requester(connection)
-            .apply { addFunctions(resources) }
-            .getFunction("test_function")
-            .name
-
-        assertEquals("test_function", name)
-    }
-
-    @Test
-    fun `requester constructor function directory`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val name: String = Requester(connection, functionsDirectory = resources)
-            .getFunction("test_function")
-            .name
-
-        assertEquals("test_function", name)
-    }
-
-    @Test
-    fun `requester constructor query directory`() {
-        val resources = this::class.java.getResource("/sql/query/Test")?.toURI()
-        val name: String = Requester(connection, queriesDirectory = resources)
-            .getQuery("DeleteTest")
-            .name
-
-        assertEquals("DeleteTest", name)
-    }
-
-    @Test
-    fun `function toString`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val name: String = Requester(connection, functionsDirectory = resources)
-            .getFunction("test_function")
-            .toString()
-
-        assertEquals("test_function", name)
-    }
-
-    @Test
-    fun `add function as string`() {
-        val sql = """
-            CREATE OR REPLACE FUNCTION test_function (name text default 'plop', IN hi text default 'hello', out result json)
-            LANGUAGE plpgsql
-            AS
-            $$
-            BEGIN
-                result = json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name);
-            END;
-            $$
-        """.trimIndent()
-        val name: String = Requester(connection)
-            .apply { addFunction(sql) }
-            .getFunction("test_function")
-            .name
-
-        assertEquals("test_function", name)
-    }
-
-    @Test
-    fun `add query from string`() {
-        val result: Int? = Requester(connection)
-            .apply { addQuery("simpleTest", "select 42;") }
-            .getQuery("simpleTest")
-            .exec()
-            .rows[0].getInt(0)
-
-        assertNotNull(result)
-        assertEquals(42, result)
-    }
+    class ObjTest(var name: String) : IdEntity(1)

    @Test
    fun `get query from file`() {
-        val resources = this::class.java.getResource("/sql/query")!!.toURI()
+        val resources = this::class.java.getResource("/sql/query").toURI()
        val objTest: ObjTest? = Requester(connection)
-            .apply { addQuery(resources) }
+            .addQuery(resources)
            .getQuery("selectOne")
            .selectOne()

-        assertNotNull(objTest)
-        assertEquals(objTest.id, UUID.fromString("829b1a29-5db8-47f9-9562-961c561ac528"))
-        assertEquals("test", objTest.name)
-    }
-
-    @Test
-    fun `get query from file with wrong name throw exception`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        assertThrows(NoQueryDefined::class.java) {
-            Requester(connection, queriesDirectory = resources)
-                .getQuery("wrongName")
-        }
-    }
-
-    @Test
-    fun `get queries from file`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val name: String = Requester(connection, queriesDirectory = resources)
-            .getQueries()[0].name
-
-        assertEquals(name, "DeleteTest")
-    }
-
-    @Test
-    fun `get function from file with wrong name throw exception`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        assertThrows(NoFunctionDefined::class.java) {
-            Requester(connection, functionsDirectory = resources)
-                .getFunction("wrongName")
-        }
+        assertEquals(objTest!!.id, 2)
+        assertEquals(objTest.name, "test")
    }

    @Test
    fun `get function from file`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val objTest: ObjTest? = Requester(connection, functionsDirectory = resources)
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
+        val objTest: ObjTest? = Requester(connection)
+            .addFunction(resources)
            .getFunction("test_function")
            .selectOne(listOf("test", "plip"))

-        assertNotNull(objTest)
-        assertEquals(objTest.id, UUID.fromString("457daad5-4f1b-4eb7-80ec-6882adb8cc7d"))
-        assertEquals("test", objTest.name)
+        assertEquals(objTest!!.id, 3)
+        assertEquals(objTest.name, "test")
    }

    @Test
    fun `call exec on query`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val result = Requester(connection, queriesDirectory = resources)
+        val resources = this::class.java.getResource("/sql/query").toURI()
+        val result = Requester(connection)
+            .addQuery(resources)
            .getQuery("selectOne")
            .exec()

        assertEquals(1, result.rowsAffected)
    }

-    @Test
-    fun `call exec on query with a list of arguments`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val result = Requester(connection, queriesDirectory = resources)
-            .getQuery("selectOneWithParameters")
-            .exec(listOf("myName"))
-
-        assertEquals("myName", result.rows[0].getString(0)?.deserialize<ObjTest>()?.name)
-    }
-
    @Test
    fun `call exec on function`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val result = Requester(connection, functionsDirectory = resources)
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
+        val result = Requester(connection)
+            .addFunction(resources)
            .getFunction("test_function")
            .exec(listOf("test", "plip"))

@@ -176,332 +57,112 @@ class RequesterTest : TestAbstract() {
    }

    @Test
-    fun `call exec on query with name`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val result = Requester(connection, queriesDirectory = resources)
+    fun `call sendQuery on query with name`() {
+        val resources = this::class.java.getResource("/sql/query").toURI()
+        val result = Requester(connection)
+            .addQuery(resources)
            .getQuery("DeleteTest")
-            .exec()
+            .sendQuery()

-        assertEquals(0, result.rowsAffected)
+        assertEquals(0, result)
    }

    @Test
-    fun `call sendQuery with same name of arguments`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleWithSameArgs")
-            .sendQuery("name" to "myName").run {
-                assertEquals("myName", rows[0].getString("firstName"))
-                assertEquals("myName", rows[0].getString("secondName"))
-            }
-    }
-
-    @Test
-    fun `call sendQuery with same name of arguments as list`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleWithSameArgs")
-            .sendQuery(listOf("myName", "myName2")).run {
-                assertEquals("myName", rows[0].getString("firstName"))
-                assertEquals("myName2", rows[0].getString("secondName"))
-            }
-    }
-
-    @Test
-    fun `call sendQuery with arguments on not same orders`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleDifferentArgs")
-            .sendQuery("first" to "firstName", "second" to "secondName").run {
-                assertEquals("firstName", rows[0].getString("firstName"))
-                assertEquals("secondName", rows[0].getString("secondName"))
-            }
-
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleDifferentArgs")
-            .sendQuery("second" to "secondName", "first" to "firstName").run {
-                assertEquals("firstName", rows[0].getString("firstName"))
-                assertEquals("secondName", rows[0].getString("secondName"))
-            }
-
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleDifferentArgs")
-            .sendQuery("second" to "secondName", "first" to "firstName").run {
-                assertEquals("firstName", rows[0].getString(0))
-                assertEquals("secondName", rows[0].getString(1))
-            }
-    }
-
-    @Test
-    fun `call sendQuery with wrong number of arguments`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-
-        assertThrows(QueryError::class.java) {
-            Requester(connection, queriesDirectory = resources)
-                .getQuery("selectMultipleDifferentArgs")
-                .sendQuery("first" to "firstName")
-        }.let {
-            assertEquals(
-                """
-                Parameter "second" missing
-
-                  > :first = firstName
-                  > SELECT :first::text as "firstName", :second::text as "secondName";
-                """.trimIndent(),
-                it.message
-            )
-        }
-    }
-
-    @Test
-    fun `call sendQuery with wrong number of arguments as list`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-
-        assertThrows(QueryError::class.java) {
-            Requester(connection, queriesDirectory = resources)
-                .getQuery("selectMultipleDifferentArgs")
-                .sendQuery(listOf("firstName"))
-        }.let {
-            assertEquals(
-                """
-                Parameter 1 missing
-                
-                  > firstName
-                  > SELECT ?::text as "firstName", ?::text as "secondName";
-                """.trimIndent(),
-                it.message
-            )
-        }
-    }
-
-    @Test
-    fun `call exec on function with pair as arguments`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val result = Requester(connection, functionsDirectory = resources)
+    fun `call sendQuery on function`() {
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
+        val result = Requester(connection)
+            .addFunction(resources)
            .getFunction("function_void")
-            .exec("name" to "test")
+            .sendQuery(listOf("test"))

-        assertEquals(1, result.rowsAffected)
+        assertEquals(0, result)
    }

    @Test
    fun `call selectOne on function`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
-        val obj: ObjTest? = Requester(connection, functionsDirectory = resources)
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
+        val obj: ObjTest = Requester(connection)
+            .addFunction(resources)
            .getFunction("test_function")
-            .selectOne(mapOf("name" to "myName"))
+            .selectOne(mapOf("name" to "myName"))!!

-        assertNotNull(obj)
        assertEquals("myName", obj.name)
    }

-    @Test
-    fun `call selectOne 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)
-
-        assertNotNull(obj)
-        assertEquals("changedName", obj.name)
-        assertEquals("original", obj2.name)
-    }
-
    @Test
    fun `call selectOne on function with object`() {
-        val resources = this::class.java.getResource("/sql/function/Test")?.toURI()
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
        val obj2 = ObjTest("original")
-        val obj: ObjTest? = Requester(connection, functionsDirectory = resources)
+        val obj: ObjTest = Requester(connection)
+            .addFunction(resources)
            .getFunction("test_function_object")
-            .update(obj2)
+            .selectOne("resource" to obj2)!!

-        assertNotNull(obj)
        assertEquals("changedName", obj.name)
-        assertEquals("original", obj2.name)
-    }
-
-    @Test
-    fun `call selectOne 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()
-
-        assertNotNull(obj)
-        assertEquals("plop", obj.name)
+        assertEquals("changedName", obj2.name)
    }

    @Test
    fun `call selectOne on query`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val obj: ObjTest? = Requester(connection, queriesDirectory = resources)
+        val resources = this::class.java.getResource("/sql/query").toURI()
+        val obj: ObjTest = Requester(connection)
+            .addQuery(resources)
            .getQuery("selectOneWithParameters")
-            .selectOne(mapOf("name" to "myName"))
+            .selectOne(mapOf("name" to "myName"))!!

-        assertNotNull(obj)
        assertEquals("myName", obj.name)
    }

    @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)
+    fun `call select (multiple) on function`() {
+        val resources = this::class.java.getResource("/sql/function/Test").toURI()
+        val obj: List<ObjTest>? = Requester(connection)
+            .addFunction(resources)
            .getFunction("test_function_multiple")
            .select(mapOf("name" to "myName"))

-        assertNotNull(obj[0])
-        assertEquals("myName", obj[0].name)
-        assertEquals("myName", obj[0].name)
-    }
-
-    @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)
-            .getFunction("test_function_multiple")
-            .select(listOf("myName"))
-
-        assertEquals("myName", obj[0].name)
-    }
-
-    @Test
-    fun `call select multiple (named arguments)`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultiple").apply {
-                select<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 ->
-                    assertNotNull(result)
-                    assertEquals("ff", result[0].name)
-                    assertEquals("ff-2", result[1].name)
-                }
-            }
-    }
-
-    @Test
-    fun `call select multiple (named arguments as pair)`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultiple").apply {
-                select<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 ->
-                    assertNotNull(result)
-                    assertEquals("ff", result[0].name)
-                    assertEquals("ff-2", result[1].name)
-                }
-            }
-    }
-
-    @Test
-    fun `call select multiple (ordered argument)`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        Requester(connection, queriesDirectory = resources)
-            .getQuery("selectMultipleOrderedArgs").apply {
-                select<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 ->
-                    assertNotNull(result)
-                    assertEquals("ff", result[0].name)
-                    assertEquals("aa-2", result[1].name)
-                }
-            }
+        assertEquals("myName", obj!![0].name)
    }

    @Test
    fun `call select paginated on query`() {
-        val resources = this::class.java.getResource("/sql/query")?.toURI()
-        val result: Paginated<ObjTest> = Requester(connection, queriesDirectory = resources)
+        val resources = this::class.java.getResource("/sql/query").toURI()
+        val result: Paginated<ObjTest> = Requester(connection)
+            .addQuery(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)
+        Assert.assertNotNull(result)
+        Assert.assertEquals("ff", result.result[0].name)
+        Assert.assertEquals("ff-2", result.result[1].name)
+        Assert.assertEquals(10, result.total)
+        Assert.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)
+        val resources = this::class.java.getResource("/sql/function").toURI()
+        val result: Paginated<ObjTest> = Requester(connection)
+            .addFunction(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)
-            }
+            .select(1, 2, mapOf("name" to "ff"))
+        Assert.assertNotNull(result)
+        Assert.assertEquals("ff", result.result[0].name)
+        Assert.assertEquals("ff-2", result.result[1].name)
+        Assert.assertEquals(10, result.total)
+        Assert.assertEquals(0, result.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")) {
-                    assertNotNull(it)
-                    assertEquals("myName", it.name)
-                    assertEquals("plop", rows[0].getString("other"))
-                }.run {
-                    assertEquals("selectOneWithParameters", name)
-                }
-            }.apply {
-                selectOne(typeReference = object : TypeReference<ObjTest>() {}, values = mapOf("name" to "myName")) {
-                    assertNotNull(it)
-                    assertEquals("myName", it.name)
-                    assertEquals("plop", rows[0].getString("other"))
-                }.run {
-                    assertEquals("selectOneWithParameters", name)
-                }
-            }
+        val resources = this::class.java.getResource("/sql/query").toURI()
+        val obj: ObjTest = Requester(connection)
+            .addQuery(resources)
+            .getQuery("selectOneWithParameters")
+            .selectOne(mapOf("name" to "myName")) {
+                assertEquals("myName", it!!.name)
+                Assert.assertEquals("plop", rows[0].getString("other"))
+            }!!
+
+        assertEquals("myName", obj.name)
    }
-}
+}
--- a/src/test/kotlin/fr/postgresjson/SerializerTest.kt
+++ b/src/test/kotlin/fr/postgresjson/SerializerTest.kt
@@ -1,7 +1,8 @@
 package fr.postgresjson

-import fr.postgresjson.entity.UuidEntity
+import fr.postgresjson.entity.mutable.IdEntity
 import fr.postgresjson.serializer.Serializer
+import fr.postgresjson.serializer.deserialize
 import fr.postgresjson.serializer.serialize
 import org.joda.time.DateTime
 import org.junit.jupiter.api.Assertions.assertEquals
@@ -9,22 +10,23 @@ import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-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 ObjTestDate(var val1: DateTime, id: UUID = UUID.fromString("829b1a29-5db8-47f9-9562-961c561ac528")) : UuidEntity(id)
+    private class ObjTest(var val1: String, var val2: Int) : IdEntity(1)
+    private class ObjTestDate(var val1: DateTime) : IdEntity(2)

    private val serializer = Serializer()

-    private val objSerialized: String = """{"val1":"plop","val2":123,"id":"829b1a29-5db8-47f9-9562-961c561ac528"}"""
-    private val objSerializedWithExtra: String = """{"val1":"plop","val2":123,"id":"829b1a29-5db8-47f9-9562-961c561ac528","toto":"tata"}"""
+    private val objSerialized: String = """{"val1":"plop","val2":123,"id":2}"""
+    private val objSerializedWithExtra: String = """{"val1":"plop","val2":123,"id":2,"toto":"tata"}"""
+    private val objSerializedUpdate = """{"val1":"update","val2":123}"""
    private lateinit var obj: ObjTest

    @BeforeEach
    fun before() {
-        obj = ObjTest("plop", 123, UUID.fromString("829b1a29-5db8-47f9-9562-961c561ac528"))
+        obj = ObjTest("plop", 123)
+        obj.id = 2
    }

    @Test
@@ -67,4 +69,20 @@ internal class SerializerTest {
        assertEquals(obj.val1, objDeserialized!!.val1)
        assertEquals(obj.val2, objDeserialized.val2)
    }
-}
+
+    @Test
+    fun deserializeUpdate() {
+        val objDeserialized: ObjTest = serializer.deserialize(objSerializedUpdate, obj)
+        assertTrue(obj === objDeserialized)
+        assertEquals("update", objDeserialized.val1)
+        assertEquals(123, objDeserialized.val2)
+    }
+
+    @Test
+    fun deserializeUpdate2() {
+        val objDeserialized = obj.deserialize(objSerializedUpdate)
+        assertTrue(obj === objDeserialized)
+        assertEquals("update", objDeserialized.val1)
+        assertEquals(123, objDeserialized.val2)
+    }
+}
--- a/src/test/kotlin/fr/postgresjson/TestAbstract.kt
+++ b/src/test/kotlin/fr/postgresjson/TestAbstract.kt
@@ -13,7 +13,7 @@ abstract class TestAbstract {

    @BeforeEach
    fun beforeAll() {
-        val initSQL = File(this::class.java.getResource("/fixtures/init.sql")!!.toURI())
+        val initSQL = File(this::class.java.getResource("/fixtures/init.sql").toURI())
        connection
            .connect()
            .sendQuery(initSQL.readText())
@@ -22,9 +22,9 @@ abstract class TestAbstract {

    @AfterEach
    fun afterAll() {
-        val downSQL = File(this::class.java.getResource("/fixtures/down.sql")!!.toURI())
-        connection
-            .apply { connect().sendQuery(downSQL.readText()).join() }
-            .disconnect()
+        val downSQL = File(this::class.java.getResource("/fixtures/down.sql").toURI())
+        connection.connect().apply {
+            sendQuery(downSQL.readText()).join()
+        }.disconnect()
    }
-}
+}
--- a/src/test/resources/fixtures/init.sql
+++ b/src/test/resources/fixtures/init.sql
@@ -8,7 +8,7 @@ create schema if not exists public;

 create table if not exists test
 (
-    id uuid not null
+    id serial not null
        constraint test_pk
            primary key,
    name text
@@ -16,24 +16,24 @@ create table if not exists test

 create table if not exists test2
 (
-    id uuid not null,
+    id serial not null,
    title text,
-    test_id uuid
+    test_id integer
        constraint test2_test_id_fk
            references test
 );

-INSERT INTO test (id, name) VALUES ('1e5f5d41-6d14-4007-897b-0ed2616bec96', 'plop') ON CONFLICT DO NOTHING;
-INSERT INTO test2 (id, title, test_id) VALUES ('1e5f5d41-6d14-4007-897b-0ed2616bec96', 'plop', '1e5f5d41-6d14-4007-897b-0ed2616bec96') ON CONFLICT DO NOTHING;
-INSERT INTO test2 (id, title, test_id) VALUES ('829b1a29-5db8-47f9-9562-961c561ac528', 'plip', '1e5f5d41-6d14-4007-897b-0ed2616bec96') ON CONFLICT DO NOTHING;
-INSERT INTO test2 (id, title, test_id) VALUES ('457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'ttt', null) ON CONFLICT DO NOTHING;
+INSERT INTO test (id, name) VALUES (1, 'plop') ON CONFLICT DO NOTHING;
+INSERT INTO test2 (id, title, test_id) VALUES (1, 'plop', 1) ON CONFLICT DO NOTHING;
+INSERT INTO test2 (id, title, test_id) VALUES (2, 'plip', 1) ON CONFLICT DO NOTHING;
+INSERT INTO test2 (id, title, test_id) VALUES (3, 'ttt', null) ON CONFLICT DO NOTHING;

 CREATE OR REPLACE FUNCTION test_function (name text default 'plop', IN hi text default 'hello', out result json)
    LANGUAGE plpgsql
 AS
 $$
 BEGIN
-    result = json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name);
+    result = json_build_object('id', 3, 'name', name);
 END;
 $$;

@@ -44,8 +44,8 @@ AS
 $$
 BEGIN
    result = json_build_array(
-            json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name),
-            json_build_object('id', '8d20abb0-7f77-4b6c-9991-44acd3c88faa', 'name', hi)
+            json_build_object('id', 3, 'name', name),
+            json_build_object('id', 4, 'name', hi)
        );
 END;
 $$;
@@ -56,8 +56,8 @@ 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')
+                   json_build_object('id', 3, 'name', name::text),
+                   json_build_object('id', 4, 'name', name::text || '-2')
               ),
           10
    INTO result, total
@@ -70,7 +70,7 @@ CREATE OR REPLACE FUNCTION test_function_object (inout resource json)
 AS
 $$
 BEGIN
-    resource = json_build_object('id', '1e5f5d41-6d14-4007-897b-0ed2616bec96', 'name', 'changedName');
+    resource = json_build_object('id', 1, 'name', 'changedName');
 END;
 $$;

--- a/src/test/resources/sql/function/Test/function_test.sql
+++ b/src/test/resources/sql/function/Test/function_test.sql
@@ -3,6 +3,6 @@ LANGUAGE plpgsql
 AS
 $$
 BEGIN
-    result = json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name);
+    result = json_build_object('id', 3, 'name', name);
 END;
 $$
--- a/src/test/resources/sql/function/Test/function_test_object.sql
+++ b/src/test/resources/sql/function/Test/function_test_object.sql
@@ -3,6 +3,6 @@ LANGUAGE plpgsql
 AS
 $$
 BEGIN
-    resource = json_build_object('id', '1e5f5d41-6d14-4007-897b-0ed2616bec96', 'name', 'changedName');
+    resource = json_build_object('id', 1, 'name', 'changedName');
 END;
 $$
--- a/src/test/resources/sql/function/Test/test_function_multiple.sql
+++ b/src/test/resources/sql/function/Test/test_function_multiple.sql
@@ -4,8 +4,8 @@ AS
 $$
 BEGIN
    result = json_build_array(
-        json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name),
-        json_build_object('id', '8d20abb0-7f77-4b6c-9991-44acd3c88faa', 'name', hi)
+        json_build_object('id', 3, 'name', name),
+        json_build_object('id', 4, 'name', hi)
    );
 END;
 $$
--- a/src/test/resources/sql/function/Test/test_function_paginated.sql
+++ b/src/test/resources/sql/function/Test/test_function_paginated.sql
@@ -4,8 +4,8 @@ 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')
+        json_build_object('id', 3, 'name', name::text),
+        json_build_object('id', 4, 'name', name::text || '-2')
    ),
    10
    INTO result, total
--- a/src/test/resources/sql/function/Test1/function_test_duplicate.sql
+++ b/src/test/resources/sql/function/Test1/function_test_duplicate.sql
@@ -3,6 +3,6 @@ CREATE OR REPLACE FUNCTION test_function_duplicate (name text default 'plop') re
 AS
 $$
 BEGIN
-    return json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', name);
+    return json_build_object('id', 3, 'name', name);
 END;
 $$
--- a/src/test/resources/sql/query/Test/selectMultiple.sql
+++ b/src/test/resources/sql/query/Test/selectMultiple.sql
@@ -1,4 +0,0 @@
-SELECT json_build_array(
-   json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', :name::text),
-   json_build_object('id', '6085c12e-e94d-4ae1-b7ad-23acc7a82a98', 'name', :name::text || '-2')
-)
--- a/src/test/resources/sql/query/Test/selectMultipleDifferentArgs.sql
+++ b/src/test/resources/sql/query/Test/selectMultipleDifferentArgs.sql
@@ -1 +0,0 @@
-SELECT :first::text as "firstName", :second::text as "secondName";
--- a/src/test/resources/sql/query/Test/selectMultipleOrderedArgs.sql
+++ b/src/test/resources/sql/query/Test/selectMultipleOrderedArgs.sql
@@ -1,4 +0,0 @@
-SELECT json_build_array(
-   json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', ?::text),
-   json_build_object('id', '6085c12e-e94d-4ae1-b7ad-23acc7a82a98', 'name', ?::text || '-2')
-)
--- a/src/test/resources/sql/query/Test/selectMultipleWithSameArgs.sql
+++ b/src/test/resources/sql/query/Test/selectMultipleWithSameArgs.sql
@@ -1 +0,0 @@
-SELECT :name::text as "firstName", :name::text as "secondName";
--- a/src/test/resources/sql/query/Test/selectOne.sql
+++ b/src/test/resources/sql/query/Test/selectOne.sql
@@ -1 +1 @@
-select json_build_object('id', '829b1a29-5db8-47f9-9562-961c561ac528', 'name', 'test');
+select json_build_object('id', 2, 'name', 'test');
--- a/src/test/resources/sql/query/Test/selectOneWithParameters.sql
+++ b/src/test/resources/sql/query/Test/selectOneWithParameters.sql
@@ -1 +1 @@
-select json_build_object('id', '829b1a29-5db8-47f9-9562-961c561ac528', 'name', :name::text), 'plop'::text as other;
+select json_build_object('id', 2, 'name', :name::text), 'plop'::text as other;
--- a/src/test/resources/sql/query/Test/selectPaginated.sql
+++ b/src/test/resources/sql/query/Test/selectPaginated.sql
@@ -1,5 +1,5 @@
 SELECT json_build_array(
-   json_build_object('id', '457daad5-4f1b-4eb7-80ec-6882adb8cc7d', 'name', :name::text),
-   json_build_object('id', '6085c12e-e94d-4ae1-b7ad-23acc7a82a98', 'name', :name::text || '-2')
+   json_build_object('id', 3, 'name', :name::text),
+   json_build_object('id', 4, 'name', :name::text || '-2')
 ), 10 as total
 LIMIT :limit OFFSET :offset
Author	SHA1	Message	Date
Fabrice Lecomte	8a452a6897	Add ShadowJar compatibility and Query file can be define name with comment Add Migration and Query definition class Add Docker DB for tests	2020-05-10 21:45:50 +02:00
Fabrice Lecomte	4c73ef1e0f	set JVM to 11 for jitpack	2020-03-25 16:35:18 +01:00
Fabrice Lecomte	4c03eb7c87	set JVM to 11	2020-03-25 16:25:55 +01:00
Fabrice Lecomte	07678afbe7	set JVM to 11	2020-03-25 16:18:17 +01:00
Fabrice Lecomte	d3bcfdd627	config package	2020-03-25 15:26:19 +01:00
Fabrice Lecomte	deea5153f2	add method function.perform	2020-03-25 00:30:54 +01:00
Fabrice Lecomte	05fb868574	Add serialise list	2020-03-15 20:18:55 +01:00
Fabrice Lecomte	bbeec7bb60	add methode$ "isLastPage" to pagination	2020-02-24 20:41:29 +01:00
Fabrice Lecomte	012beb6884	Improve SQL log message	2020-02-19 16:46:20 +01:00
Fabrice Lecomte	45707f9734	change Idea config	2020-02-19 12:46:04 +01:00
Fabrice Lecomte	4e89aa072d	RepositoryI::requester is now readonly	2020-02-11 20:39:43 +01:00
Fabrice Lecomte	b65e82a52f	Improve UuidEntityVersioning	2020-01-29 17:03:22 +01:00
Fabrice Lecomte	898951e91a	Add Immutable Entities	2020-01-23 00:40:47 +01:00
				`@@ -1 +0,0 @@`
				`SELECT :first::text as "firstName", :second::text as "secondName";`
				`@@ -1 +0,0 @@`
				`SELECT :name::text as "firstName", :name::text as "secondName";`