set JVM to 11

config package
add method function.perform
2020-03-25 16:18:17 +01:00 · 2020-03-25 15:26:19 +01:00 · 2020-03-25 00:30:54 +01:00 · 2020-03-15 20:18:55 +01:00 · 2020-02-24 20:41:29 +01:00 · 2020-02-19 16:46:20 +01:00
79 changed files with 1008 additions and 3232 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,8 +1,7 @@
 <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" />
+    <toRun name="Lint" type="GradleRunConfiguration" />
    <method v="2" />
  </configuration>
 </component>
--- 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
@@ -1,13 +1,7 @@
 <component name="ProjectRunConfigurationManager">
  <configuration default="false" name="tests" type="JUnit" factoryName="JUnit" singleton="false">
-    <module name="postgres-json.test" />
+    <module name="postgresjson.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" />
@@ -19,7 +13,7 @@
      </ENTRIES>
    </extension>
    <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
-    <option name="ALTERNATIVE_JRE_PATH" value="corretto-11" />
+    <option name="ALTERNATIVE_JRE_PATH" value="$USER_HOME$/.jdks/adopt-openjdk-11.0.5" />
    <option name="MAIN_CLASS_NAME" value="" />
    <option name="METHOD_NAME" value="" />
    <option name="TEST_OBJECT" value="directory" />
--- 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,25 +1,22 @@
 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> {
@@ -28,53 +25,19 @@ tasks.withType<KotlinCompile> {
    }
 }

-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 +45,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 {
@@ -109,13 +64,3 @@ publishing {
        }
    }
 }
-
-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,15 +0,0 @@
-# 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'
-services:
-  db:
-    container_name: postgres_json
-    build:
-      context: docker/postgresql
-    restart: always
-    ports:
-      - "5555:5432"
-    environment:
-      POSTGRES_DB: json_test
-      POSTGRES_USER: test
-      POSTGRES_PASSWORD: test
--- a/docker/postgresql/Dockerfile
+++ b/docker/postgresql/Dockerfile
@@ -1,9 +0,0 @@
-FROM postgres:13
-
-COPY postgresql.conf /tmp/postgresql.conf
-COPY extension.sh    /docker-entrypoint-initdb.d/000-extension.sh
-COPY setup.sh        /docker-entrypoint-initdb.d/100-setup.sh
-
-ENTRYPOINT ["docker-entrypoint.sh"]
-EXPOSE 5432
-CMD ["postgres"]
--- a/docker/postgresql/extension.sh
+++ b/docker/postgresql/extension.sh
@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-psql -v ON_ERROR_STOP=1 --username "test" --dbname "json_test" <<-EOSQL
-create extension if not exists plpgsql;
-create extension if not exists "uuid-ossp";
-EOSQL
--- a/docker/postgresql/postgresql.conf
+++ b/docker/postgresql/postgresql.conf
@@ -1,666 +0,0 @@
-# -----------------------------
-# PostgreSQL configuration file
-# -----------------------------
-#
-# This file consists of lines of the form:
-#
-#   name = value
-#
-# (The "=" is optional.)  Whitespace may be used.  Comments are introduced with
-# "#" anywhere on a line.  The complete list of parameter names and allowed
-# values can be found in the PostgreSQL documentation.
-#
-# The commented-out settings shown in this file represent the default values.
-# Re-commenting a setting is NOT sufficient to revert it to the default value;
-# you need to reload the server.
-#
-# This file is read on server startup and when the server receives a SIGHUP
-# signal.  If you edit the file on a running system, you have to SIGHUP the
-# server for the changes to take effect, run "pg_ctl reload", or execute
-# "SELECT pg_reload_conf()".  Some parameters, which are marked below,
-# require a server shutdown and restart to take effect.
-#
-# Any parameter can also be given as a command-line option to the server, e.g.,
-# "postgres -c log_connections=on".  Some parameters can be changed at run time
-# with the "SET" SQL command.
-#
-# Memory units:  kB = kilobytes        Time units:  ms  = milliseconds
-#                MB = megabytes                     s   = seconds
-#                GB = gigabytes                     min = minutes
-#                TB = terabytes                     h   = hours
-#                                                   d   = days
-
-
-#------------------------------------------------------------------------------
-# FILE LOCATIONS
-#------------------------------------------------------------------------------
-
-# The default values of these variables are driven from the -D command-line
-# option or PGDATA environment variable, represented here as ConfigDir.
-
-#data_directory = 'ConfigDir'           # use data in another directory
-                                        # (change requires restart)
-#hba_file = 'ConfigDir/pg_hba.conf'     # host-based authentication file
-                                        # (change requires restart)
-#ident_file = 'ConfigDir/pg_ident.conf' # ident configuration file
-                                        # (change requires restart)
-
-# If external_pid_file is not explicitly set, no extra PID file is written.
-#external_pid_file = ''                 # write an extra PID file
-                                        # (change requires restart)
-
-
-#------------------------------------------------------------------------------
-# CONNECTIONS AND AUTHENTICATION
-#------------------------------------------------------------------------------
-
-# - Connection Settings -
-
-listen_addresses = '*'
-                                        # comma-separated list of addresses;
-                                        # defaults to 'localhost'; use '*' for all
-                                        # (change requires restart)
-#port = 5432                            # (change requires restart)
-#max_connections = 100                  # (change requires restart)
-#superuser_reserved_connections = 3     # (change requires restart)
-#unix_socket_directories = '/tmp'       # comma-separated list of directories
-                                        # (change requires restart)
-#unix_socket_group = ''                 # (change requires restart)
-#unix_socket_permissions = 0777         # begin with 0 to use octal notation
-                                        # (change requires restart)
-#bonjour = off                          # advertise server via Bonjour
-                                        # (change requires restart)
-#bonjour_name = ''                      # defaults to the computer name
-                                        # (change requires restart)
-
-# - Security and Authentication -
-
-#authentication_timeout = 1min          # 1s-600s
-#ssl = off
-#ssl_ciphers = 'HIGH:MEDIUM:+3DES:!aNULL' # allowed SSL ciphers
-#ssl_prefer_server_ciphers = on
-#ssl_ecdh_curve = 'prime256v1'
-#ssl_dh_params_file = ''
-#ssl_cert_file = 'server.crt'
-#ssl_key_file = 'server.key'
-#ssl_ca_file = ''
-#ssl_crl_file = ''
-#password_encryption = md5              # md5 or scram-sha-256
-#db_user_namespace = off
-#row_security = on
-
-# GSSAPI using Kerberos
-#krb_server_keyfile = ''
-#krb_caseins_users = off
-
-# - TCP Keepalives -
-# see "man 7 tcp" for details
-
-#tcp_keepalives_idle = 0                # TCP_KEEPIDLE, in seconds;
-                                        # 0 selects the system default
-#tcp_keepalives_interval = 0            # TCP_KEEPINTVL, in seconds;
-                                        # 0 selects the system default
-#tcp_keepalives_count = 0               # TCP_KEEPCNT;
-                                        # 0 selects the system default
-
-
-#------------------------------------------------------------------------------
-# RESOURCE USAGE (except WAL)
-#------------------------------------------------------------------------------
-
-# - Memory -
-
-shared_buffers = 1GB                    # min 128kB
-                                        # (change requires restart)
-#huge_pages = try                       # on, off, or try
-                                        # (change requires restart)
-#temp_buffers = 8MB                     # min 800kB
-#max_prepared_transactions = 0          # zero disables the feature
-                                        # (change requires restart)
-# Caution: it is not advisable to set max_prepared_transactions nonzero unless
-# you actively intend to use prepared transactions.
-work_mem = 256MB                        # min 64kB
-#maintenance_work_mem = 64MB            # min 1MB
-#replacement_sort_tuples = 150000       # limits use of replacement selection sort
-#autovacuum_work_mem = -1               # min 1MB, or -1 to use maintenance_work_mem
-#max_stack_depth = 2MB                  # min 100kB
-#dynamic_shared_memory_type = posix     # the default is the first option
-                                        # supported by the operating system:
-                                        #   posix
-                                        #   sysv
-                                        #   windows
-                                        #   mmap
-                                        # use none to disable dynamic shared memory
-                                        # (change requires restart)
-
-# - Disk -
-
-#temp_file_limit = -1                   # limits per-process temp file space
-                                        # in kB, or -1 for no limit
-
-# - Kernel Resource Usage -
-
-#max_files_per_process = 1000           # min 25
-                                        # (change requires restart)
-shared_preload_libraries = 'pg_stat_statements'
-pg_stat_statements.max = 10000
-pg_stat_statements.track = all
-
-# - Cost-Based Vacuum Delay -
-
-#vacuum_cost_delay = 0                  # 0-100 milliseconds
-#vacuum_cost_page_hit = 1               # 0-10000 credits
-#vacuum_cost_page_miss = 10             # 0-10000 credits
-#vacuum_cost_page_dirty = 20            # 0-10000 credits
-#vacuum_cost_limit = 200                # 1-10000 credits
-
-# - Background Writer -
-
-#bgwriter_delay = 200ms                 # 10-10000ms between rounds
-#bgwriter_lru_maxpages = 100            # 0-1000 max buffers written/round
-#bgwriter_lru_multiplier = 2.0          # 0-10.0 multiplier on buffers scanned/round
-#bgwriter_flush_after = 0               # measured in pages, 0 disables
-
-# - Asynchronous Behavior -
-
-effective_io_concurrency = 100          # 1-1000; 0 disables prefetching
-#max_worker_processes = 8               # (change requires restart)
-max_parallel_workers_per_gather = 4     # taken from max_parallel_workers
-#max_parallel_workers = 8               # maximum number of max_worker_processes that
-                                        # can be used in parallel queries
-#old_snapshot_threshold = -1            # 1min-60d; -1 disables; 0 is immediate
-                                        # (change requires restart)
-#backend_flush_after = 0                # measured in pages, 0 disables
-
-
-#------------------------------------------------------------------------------
-# WRITE AHEAD LOG
-#------------------------------------------------------------------------------
-
-# - Settings -
-
-#wal_level = replica                    # minimal, replica, or logical
-                                        # (change requires restart)
-#fsync = on                             # flush data to disk for crash safety
-                                        # (turning this off can cause
-                                        # unrecoverable data corruption)
-#synchronous_commit = on                # synchronization level;
-                                        # off, local, remote_write, remote_apply, or on
-#wal_sync_method = fsync                # the default is the first option
-                                        # supported by the operating system:
-                                        #   open_datasync
-                                        #   fdatasync (default on Linux)
-                                        #   fsync
-                                        #   fsync_writethrough
-                                        #   open_sync
-#full_page_writes = on                  # recover from partial page writes
-#wal_compression = off                  # enable compression of full-page writes
-#wal_log_hints = off                    # also do full page writes of non-critical updates
-                                        # (change requires restart)
-#wal_buffers = -1                       # min 32kB, -1 sets based on shared_buffers
-                                        # (change requires restart)
-#wal_writer_delay = 200ms               # 1-10000 milliseconds
-#wal_writer_flush_after = 1MB           # measured in pages, 0 disables
-
-#commit_delay = 0                       # range 0-100000, in microseconds
-#commit_siblings = 5                    # range 1-1000
-
-# - Checkpoints -
-
-#checkpoint_timeout = 5min              # range 30s-1d
-#max_wal_size = 1GB
-#min_wal_size = 80MB
-#checkpoint_completion_target = 0.5     # checkpoint target duration, 0.0 - 1.0
-#checkpoint_flush_after = 0             # measured in pages, 0 disables
-#checkpoint_warning = 30s               # 0 disables
-
-# - Archiving -
-
-#archive_mode = off             # enables archiving; off, on, or always
-                                # (change requires restart)
-#archive_command = ''           # command to use to archive a logfile segment
-                                # placeholders: %p = path of file to archive
-                                #               %f = file name only
-                                # e.g. 'test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f'
-#archive_timeout = 0            # force a logfile segment switch after this
-                                # number of seconds; 0 disables
-
-
-#------------------------------------------------------------------------------
-# REPLICATION
-#------------------------------------------------------------------------------
-
-# - Sending Server(s) -
-
-# Set these on the master and on any standby that will send replication data.
-
-#max_wal_senders = 10           # max number of walsender processes
-                                # (change requires restart)
-#wal_keep_segments = 0          # in logfile segments, 16MB each; 0 disables
-#wal_sender_timeout = 60s       # in milliseconds; 0 disables
-
-#max_replication_slots = 10     # max number of replication slots
-                                # (change requires restart)
-#track_commit_timestamp = off   # collect timestamp of transaction commit
-                                # (change requires restart)
-
-# - Master Server -
-
-# These settings are ignored on a standby server.
-
-#synchronous_standby_names = '' # standby servers that provide sync rep
-                                # method to choose sync standbys, number of sync standbys,
-                                # and comma-separated list of application_name
-                                # from standby(s); '*' = all
-#vacuum_defer_cleanup_age = 0   # number of xacts by which cleanup is delayed
-
-# - Standby Servers -
-
-# These settings are ignored on a master server.
-
-#hot_standby = on                       # "off" disallows queries during recovery
-                                        # (change requires restart)
-#max_standby_archive_delay = 30s        # max delay before canceling queries
-                                        # when reading WAL from archive;
-                                        # -1 allows indefinite delay
-#max_standby_streaming_delay = 30s      # max delay before canceling queries
-                                        # when reading streaming WAL;
-                                        # -1 allows indefinite delay
-#wal_receiver_status_interval = 10s     # send replies at least this often
-                                        # 0 disables
-#hot_standby_feedback = off             # send info from standby to prevent
-                                        # query conflicts
-#wal_receiver_timeout = 60s             # time that receiver waits for
-                                        # communication from master
-                                        # in milliseconds; 0 disables
-#wal_retrieve_retry_interval = 5s       # time to wait before retrying to
-                                        # retrieve WAL after a failed attempt
-
-# - Subscribers -
-
-# These settings are ignored on a publisher.
-
-#max_logical_replication_workers = 4    # taken from max_worker_processes
-                                        # (change requires restart)
-#max_sync_workers_per_subscription = 2  # taken from max_logical_replication_workers
-
-
-#------------------------------------------------------------------------------
-# QUERY TUNING
-#------------------------------------------------------------------------------
-
-# - Planner Method Configuration -
-
-#enable_bitmapscan = on
-#enable_hashagg = on
-#enable_hashjoin = on
-#enable_indexscan = on
-#enable_indexonlyscan = on
-#enable_material = on
-#enable_mergejoin = on
-#enable_nestloop = on
-#enable_seqscan = on
-#enable_sort = on
-#enable_tidscan = on
-
-# - Planner Cost Constants -
-
-#seq_page_cost = 1.0                    # measured on an arbitrary scale
-#random_page_cost = 4.0                 # same scale as above
-#cpu_tuple_cost = 0.01                  # same scale as above
-#cpu_index_tuple_cost = 0.005           # same scale as above
-#cpu_operator_cost = 0.0025             # same scale as above
-#parallel_tuple_cost = 0.1              # same scale as above
-#parallel_setup_cost = 1000.0   # same scale as above
-#min_parallel_table_scan_size = 8MB
-#min_parallel_index_scan_size = 512kB
-#effective_cache_size = 4GB
-
-# - Genetic Query Optimizer -
-
-#geqo = on
-#geqo_threshold = 12
-#geqo_effort = 5                        # range 1-10
-#geqo_pool_size = 0                     # selects default based on effort
-#geqo_generations = 0                   # selects default based on effort
-#geqo_selection_bias = 2.0              # range 1.5-2.0
-#geqo_seed = 0.0                        # range 0.0-1.0
-
-# - Other Planner Options -
-
-#default_statistics_target = 100        # range 1-10000
-#constraint_exclusion = partition       # on, off, or partition
-#cursor_tuple_fraction = 0.1            # range 0.0-1.0
-#from_collapse_limit = 8
-#join_collapse_limit = 8                # 1 disables collapsing of explicit
-                                        # JOIN clauses
-#force_parallel_mode = off
-
-
-#------------------------------------------------------------------------------
-# ERROR REPORTING AND LOGGING
-#------------------------------------------------------------------------------
-
-# - Where to Log -
-
-#log_destination = 'stderr'             # Valid values are combinations of
-                                        # stderr, csvlog, syslog, and eventlog,
-                                        # depending on platform.  csvlog
-                                        # requires logging_collector to be on.
-
-# This is used when logging to stderr:
-logging_collector = on
-                                        # Enable capturing of stderr and csvlog
-                                        # into log files. Required to be on for
-                                        # csvlogs.
-                                        # (change requires restart)
-
-# These are only used if logging_collector is on:
-log_directory = '/var/log/postgresql'
-                                        # directory where log files are written,
-                                        # can be absolute or relative to PGDATA
-log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'
-                                        # log file name pattern,
-                                        # can include strftime() escapes
-#log_file_mode = 0600                   # creation mode for log files,
-                                        # begin with 0 to use octal notation
-log_file_mode = 0660
-#log_truncate_on_rotation = off         # If on, an existing log file with the
-                                        # same name as the new log file will be
-                                        # truncated rather than appended to.
-                                        # But such truncation only occurs on
-                                        # time-driven rotation, not on restarts
-                                        # or size-driven rotation.  Default is
-                                        # off, meaning append to existing files
-                                        # in all cases.
-log_rotation_age = 1d
-                                        # Automatic rotation of logfiles will
-                                        # happen after that time.  0 disables.
-log_rotation_size = 100MB
-                                        # Automatic rotation of logfiles will
-                                        # happen after that much log output.
-                                        # 0 disables.
-
-# These are relevant when logging to syslog:
-#syslog_facility = 'LOCAL0'
-#syslog_ident = 'postgres'
-#syslog_sequence_numbers = on
-#syslog_split_messages = on
-
-# This is only relevant when logging to eventlog (win32):
-# (change requires restart)
-#event_source = 'PostgreSQL'
-
-# - When to Log -
-
-#client_min_messages = notice           # values in order of decreasing detail:
-                                        #   debug5
-                                        #   debug4
-                                        #   debug3
-                                        #   debug2
-                                        #   debug1
-                                        #   log
-                                        #   notice
-                                        #   warning
-                                        #   error
-
-#log_min_messages = warning             # values in order of decreasing detail:
-                                        #   debug5
-                                        #   debug4
-                                        #   debug3
-                                        #   debug2
-                                        #   debug1
-                                        #   info
-                                        #   notice
-                                        #   warning
-                                        #   error
-                                        #   log
-                                        #   fatal
-                                        #   panic
-
-#log_min_error_statement = error        # values in order of decreasing detail:
-                                        #   debug5
-                                        #   debug4
-                                        #   debug3
-                                        #   debug2
-                                        #   debug1
-                                        #   info
-                                        #   notice
-                                        #   warning
-                                        #   error
-                                        #   log
-                                        #   fatal
-                                        #   panic (effectively off)
-
-#log_min_duration_statement = -1        # -1 is disabled, 0 logs all statements
-                                        # and their durations, > 0 logs only
-                                        # statements running at least this number
-                                        # of milliseconds
-
-
-# - What to Log -
-
-#debug_print_parse = off
-#debug_print_rewritten = off
-#debug_print_plan = off
-#debug_pretty_print = on
-#log_checkpoints = off
-#log_connections = off
-#log_disconnections = off
-#log_duration = off
-#log_error_verbosity = default          # terse, default, or verbose messages
-#log_hostname = off
-#log_line_prefix = '%m [%p] '           # special values:
-                                        #   %a = application name
-                                        #   %u = user name
-                                        #   %d = database name
-                                        #   %r = remote host and port
-                                        #   %h = remote host
-                                        #   %p = process ID
-                                        #   %t = timestamp without milliseconds
-                                        #   %m = timestamp with milliseconds
-                                        #   %n = timestamp with milliseconds (as a Unix epoch)
-                                        #   %i = command tag
-                                        #   %e = SQL state
-                                        #   %c = session ID
-                                        #   %l = session line number
-                                        #   %s = session start timestamp
-                                        #   %v = virtual transaction ID
-                                        #   %x = transaction ID (0 if none)
-                                        #   %q = stop here in non-session
-                                        #        processes
-                                        #   %% = '%'
-                                        # e.g. '<%u%%%d> '
-#log_lock_waits = off                   # log lock waits >= deadlock_timeout
-#log_statement = 'none'                 # none, ddl, mod, all
-#log_replication_commands = off
-#log_temp_files = -1                    # log temporary files equal or larger
-                                        # than the specified size in kilobytes;
-                                        # -1 disables, 0 logs all temp files
-#log_timezone = 'GMT'
-
-
-# - Process Title -
-
-#cluster_name = ''                      # added to process titles if nonempty
-                                        # (change requires restart)
-#update_process_title = on
-
-
-#------------------------------------------------------------------------------
-# RUNTIME STATISTICS
-#------------------------------------------------------------------------------
-
-# - Query/Index Statistics Collector -
-
-#track_activities = on
-#track_counts = on
-#track_io_timing = off
-#track_functions = none                 # none, pl, all
-#track_activity_query_size = 1024       # (change requires restart)
-#stats_temp_directory = 'pg_stat_tmp'
-
-
-# - Statistics Monitoring -
-
-#log_parser_stats = off
-#log_planner_stats = off
-#log_executor_stats = off
-#log_statement_stats = off
-
-
-#------------------------------------------------------------------------------
-# AUTOVACUUM PARAMETERS
-#------------------------------------------------------------------------------
-
-#autovacuum = on                        # Enable autovacuum subprocess?  'on'
-                                        # requires track_counts to also be on.
-#log_autovacuum_min_duration = -1       # -1 disables, 0 logs all actions and
-                                        # their durations, > 0 logs only
-                                        # actions running at least this number
-                                        # of milliseconds.
-#autovacuum_max_workers = 3             # max number of autovacuum subprocesses
-                                        # (change requires restart)
-#autovacuum_naptime = 1min              # time between autovacuum runs
-#autovacuum_vacuum_threshold = 50       # min number of row updates before
-                                        # vacuum
-#autovacuum_analyze_threshold = 50      # min number of row updates before
-                                        # analyze
-#autovacuum_vacuum_scale_factor = 0.2   # fraction of table size before vacuum
-#autovacuum_analyze_scale_factor = 0.1  # fraction of table size before analyze
-#autovacuum_freeze_max_age = 200000000  # maximum XID age before forced vacuum
-                                        # (change requires restart)
-#autovacuum_multixact_freeze_max_age = 400000000        # maximum multixact age
-                                        # before forced vacuum
-                                        # (change requires restart)
-#autovacuum_vacuum_cost_delay = 20ms    # default vacuum cost delay for
-                                        # autovacuum, in milliseconds;
-                                        # -1 means use vacuum_cost_delay
-#autovacuum_vacuum_cost_limit = -1      # default vacuum cost limit for
-                                        # autovacuum, -1 means use
-                                        # vacuum_cost_limit
-
-
-#------------------------------------------------------------------------------
-# CLIENT CONNECTION DEFAULTS
-#------------------------------------------------------------------------------
-
-# - Statement Behavior -
-
-#search_path = '"$user", public'        # schema names
-#default_tablespace = ''                # a tablespace name, '' uses the default
-#temp_tablespaces = ''                  # a list of tablespace names, '' uses
-                                        # only default tablespace
-#check_function_bodies = on
-#default_transaction_isolation = 'read committed'
-#default_transaction_read_only = off
-#default_transaction_deferrable = off
-#session_replication_role = 'origin'
-#statement_timeout = 0                  # in milliseconds, 0 is disabled
-#lock_timeout = 0                       # in milliseconds, 0 is disabled
-#idle_in_transaction_session_timeout = 0        # in milliseconds, 0 is disabled
-#vacuum_freeze_min_age = 50000000
-#vacuum_freeze_table_age = 150000000
-#vacuum_multixact_freeze_min_age = 5000000
-#vacuum_multixact_freeze_table_age = 150000000
-#bytea_output = 'hex'                   # hex, escape
-#xmlbinary = 'base64'
-#xmloption = 'content'
-#gin_fuzzy_search_limit = 0
-#gin_pending_list_limit = 4MB
-
-# - Locale and Formatting -
-
-#datestyle = 'iso, mdy'
-#intervalstyle = 'postgres'
-#timezone = 'GMT'
-#timezone_abbreviations = 'Default'     # Select the set of available time zone
-                                        # abbreviations.  Currently, there are
-                                        #   Default
-                                        #   Australia (historical usage)
-                                        #   India
-                                        # You can create your own file in
-                                        # share/timezonesets/.
-#extra_float_digits = 0                 # min -15, max 3
-#client_encoding = sql_ascii            # actually, defaults to database
-                                        # encoding
-
-# These settings are initialized by initdb, but they can be changed.
-#lc_messages = 'C'                      # locale for system error message
-                                        # strings
-#lc_monetary = 'C'                      # locale for monetary formatting
-#lc_numeric = 'C'                       # locale for number formatting
-#lc_time = 'C'                          # locale for time formatting
-
-# default configuration for text search
-#default_text_search_config = 'pg_catalog.simple'
-
-# - Other Defaults -
-
-#dynamic_library_path = '$libdir'
-#local_preload_libraries = ''
-#session_preload_libraries = ''
-
-
-#------------------------------------------------------------------------------
-# LOCK MANAGEMENT
-#------------------------------------------------------------------------------
-
-#deadlock_timeout = 1s
-#max_locks_per_transaction = 64         # min 10
-                                        # (change requires restart)
-#max_pred_locks_per_transaction = 64    # min 10
-                                        # (change requires restart)
-#max_pred_locks_per_relation = -2       # negative values mean
-                                        # (max_pred_locks_per_transaction
-                                        #  / -max_pred_locks_per_relation) - 1
-#max_pred_locks_per_page = 2            # min 0
-
-
-#------------------------------------------------------------------------------
-# VERSION/PLATFORM COMPATIBILITY
-#------------------------------------------------------------------------------
-
-# - Previous PostgreSQL Versions -
-
-#array_nulls = on
-#backslash_quote = safe_encoding        # on, off, or safe_encoding
-#default_with_oids = off
-#escape_string_warning = on
-#lo_compat_privileges = off
-#operator_precedence_warning = off
-#quote_all_identifiers = off
-#standard_conforming_strings = on
-#synchronize_seqscans = on
-
-# - Other Platforms and Clients -
-
-#transform_null_equals = off
-
-
-#------------------------------------------------------------------------------
-# ERROR HANDLING
-#------------------------------------------------------------------------------
-
-#exit_on_error = off                    # terminate session on any error?
-#restart_after_crash = on               # reinitialize after backend crash?
-
-
-#------------------------------------------------------------------------------
-# CONFIG FILE INCLUDES
-#------------------------------------------------------------------------------
-
-# These options allow settings to be loaded from files other than the
-# default postgresql.conf.
-
-#include_dir = 'conf.d'                 # include files ending in '.conf' from
-                                        # directory 'conf.d'
-#include_if_exists = 'exists.conf'      # include file only if it exists
-#include = 'special.conf'               # include file
-
-
-#------------------------------------------------------------------------------
-# CUSTOMIZED OPTIONS
-#------------------------------------------------------------------------------
-
-# Add settings for extensions here
--- a/docker/postgresql/setup.sh
+++ b/docker/postgresql/setup.sh
@@ -1,4 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-cat /tmp/postgresql.conf > /var/lib/postgresql/data/postgresql.conf
--- 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/jitpack.yml
+++ b/jitpack.yml
@@ -1,2 +0,0 @@
-jdk:
-  - openjdk11
--- 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(
+        if (!::connection.isInitialized || !connection.isConnected()) {
+            connection = PostgreSQLConnectionBuilder.createConnectionPool(
                "jdbc:postgresql://$host:$port/$database?user=$username&password=$password"
-                ).also {
-                    connection = it
-                }
-            } else {
-                connectionPool
-            }
+            )
        }
+        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 {
+            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 """$escapeTag$parameter$escapeTag"""
+            return block(newSql)
        }

-    /**
-     * 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,9 +14,9 @@ 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
--- 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> =
-        connection.select(sql, page, limit, typeReference, values, block)
-
-    /* Execute function without treatments */
-
-    override fun exec(values: List<Any?>): QueryResult = connection.exec(sql, values)
-
-    override fun exec(values: Map<String, Any?>): QueryResult = connection.exec(sql, values)
-
-    /**
-     * Warning: this method not use prepared statement
-     */
-    fun sendQuery(values: List<Any?>): QueryResult = 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())
+    ): 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> =
+        select(page, limit, object : TypeReference<List<R>>() {}, values, block)
+
+    /* Execute function without traitements */
+
+    override fun exec(values: List<Any?>): QueryResult {
+        return connection.exec(sql, values)
+    }
+
+    override fun exec(values: Map<String, Any?>): QueryResult {
+        return connection.exec(sql, values)
+    }
+
+    override fun sendQuery(values: List<Any?>): Int {
+        return connection.sendQuery(sql, values)
+    }
+
+    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
@@ -1,68 +1,105 @@
 package fr.postgresjson.connexion

-import fr.postgresjson.utils.searchSqlFiles
-import java.net.URI
+import java.io.File
 import fr.postgresjson.definition.Function as DefinitionFunction
-import fr.postgresjson.definition.Query as QueryDefinition

 class Requester(
    private val connection: Connection,
    private val queries: MutableMap<String, Query> = mutableMapOf(),
    private val functions: MutableMap<String, Function> = mutableMapOf()
 ) {
-    constructor(connection: Connection) : this(connection, mutableMapOf(), mutableMapOf())
+    fun addQuery(query: Query): Requester {
+        queries[query.name] = query
+        return this
+    }

+    fun addQuery(name: String, sql: String): Requester {
+        addQuery(Query(name, sql, connection))
+        return this
+    }
+
+    fun addQuery(queriesDirectory: File): Requester {
+        queriesDirectory.walk()
+            .filter { it.isFile && it.extension == "sql" }
+            .forEach {
+                val path = it.parentFile.nameWithoutExtension
+                addQuery("$path/${it.nameWithoutExtension}", it.readText())
+            }
+        return this
+    }
+
+    fun getQueries(): List<Query> {
+        return queries.map { it.value }
+    }
+
+    fun addFunction(definition: DefinitionFunction): Requester {
+        functions[definition.name] = Function(definition, connection)
+        return this
+    }
+
+    fun addFunction(sql: String): Requester {
+        DefinitionFunction(sql).let {
+            functions[it.name] = Function(it, connection)
+        }
+        return this
+    }
+
+    fun addFunction(functionsDirectory: File): Requester {
+        functionsDirectory.walk()
+            .filter { it.isFile && it.extension == "sql" }
+            .forEach {
+                addFunction(it.readText())
+            }
+        return this
+    }
+
+    fun getFunction(name: String): Function {
+        if (functions[name] === null) {
+            throw Exception("No function defined for $name")
+        }
+        return functions[name]!!
+    }
+
+    fun getQuery(path: String): Query {
+        if (queries[path] === null) {
+            throw Exception("No query defined in $path")
+        }
+        return queries[path]!!
+    }
+
+    class RequesterFactory(
+        private val connection: Connection,
+        private val queriesDirectory: File? = null,
+        private val functionsDirectory: File? = null
+    ) {
        constructor(
-        connection: Connection,
-        queriesDirectory: URI? = null,
-        functionsDirectory: URI? = null
+            host: String = "localhost",
+            port: Int = 5432,
+            database: String = "dc-project",
+            username: String = "dc-project",
+            password: String = "dc-project",
+            queriesDirectory: File? = null,
+            functionsDirectory: File? = null
        ) : this(
-        connection = connection,
-        queries = queriesDirectory?.toQuery(connection) ?: mutableMapOf(),
-        functions = functionsDirectory?.toFunction(connection) ?: mutableMapOf(),
+            Connection(host = host, port = port, database = database, username = username, password = password),
+            queriesDirectory,
+            functionsDirectory
        )

-    fun addQuery(query: Query) {
-        queries[query.name] = query
+        fun createRequester(): Requester {
+            return initRequester(Requester(connection))
        }

-    fun addQuery(query: QueryDefinition) = addQuery(query.toRunnable(connection))
-
-    fun addQuery(name: String, sql: String) {
-        addQuery(Query(name, sql, connection))
+        private fun initRequester(req: Requester): Requester {
+            if (queriesDirectory !== null) {
+                req.addQuery(queriesDirectory)
            }

-    fun addQuery(queriesDirectory: URI) {
-        queriesDirectory
-            .searchSqlFiles()
-            .filterIsInstance(QueryDefinition::class.java)
-            .forEach(this::addQuery)
+            if (functionsDirectory !== null) {
+                req.addFunction(functionsDirectory)
            }

-    fun getQueries(): List<Query> = queries.map { it.value }
-
-    fun addFunction(definition: DefinitionFunction) {
-        definition
-            .run { toRunnable(connection) }
-            .run { functions[name] = this }
+            return req
        }
-
-    fun addFunction(sql: String) {
-        DefinitionFunction(sql)
-            .run { toRunnable(connection) }
-            .run { functions[name] = this }
    }
-
-    fun addFunctions(functionsDirectory: URI) {
-        functionsDirectory.searchSqlFiles()
-            .filterIsInstance(DefinitionFunction::class.java)
-            .forEach(this::addFunction)
-    }
-
-    fun getFunction(name: String): Function = functions[name] ?: throw NoFunctionDefined(name)
-
-    fun getQuery(path: String): Query = queries[path] ?: throw NoQueryDefined(path)
-
-    class NoFunctionDefined(name: String) : Exception("No function defined for $name")
-    class NoQueryDefined(path: String) : Exception("No query defined in $path")
 }
--- a/src/main/kotlin/fr/postgresjson/definition/Function.kt
+++ b/src/main/kotlin/fr/postgresjson/definition/Function.kt
@@ -1,14 +1,14 @@
 package fr.postgresjson.definition

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

-class Function(
-    override val script: String,
-    override val source: Path? = null
+open class Function(
+    override val script: String
 ) : Resource, ParametersInterface {
    val returns: String
    override val name: String
    override val parameters: List<Parameter>
+    override var source: File? = null

    init {
        val functionRegex =
@@ -21,7 +21,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() ?: ""

@@ -46,17 +46,21 @@ class Function(
        }
    }

-    class FunctionNotFound(cause: Throwable? = null) : Resource.ParseException("Function not found in script", cause)
+    abstract class ParseException(message: String, cause: Throwable? = null) : Exception(message, cause)
+    class FunctionNotFound(cause: Throwable? = null) : ParseException("Function not found in script", cause)

    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
@@ -1,33 +0,0 @@
-package fr.postgresjson.definition
-
-import java.nio.file.Path
-
-class Migration(
-    override val script: String,
-    override var source: Path
-) : Resource {
-    override val name: String
-    val direction: Direction
-
-    init {
-        this.direction = source.fileName.toString()
-            .let {
-                when {
-                    it.endsWith(".down.sql") -> Direction.DOWN
-                    it.endsWith(".up.sql") -> Direction.UP
-                    else -> throw MigrationNotFound()
-                }
-            }
-        this.name = source.fileName.toString()
-            .substringAfterLast("/")
-            .let {
-                when (direction) {
-                    Direction.DOWN -> it.substringBefore(".down.sql")
-                    Direction.UP -> it.substringBefore(".up.sql")
-                }
-            }
-    }
-
-    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
    )

--- a/src/main/kotlin/fr/postgresjson/definition/Query.kt
+++ b/src/main/kotlin/fr/postgresjson/definition/Query.kt
@@ -1,24 +0,0 @@
-package fr.postgresjson.definition
-
-import java.nio.file.Path
-
-class Query(
-    override val script: String,
-    override var source: Path
-) : Resource {
-    override val name: String = getNameFromComment(script) ?: getNameFromFile(source)
-
-    /** Try to get name from comment in file */
-    private fun getNameFromComment(script: String): String? =
-        """-- *name ?: ?(?<name>[^ \n]+)"""
-            .toRegex(setOf(RegexOption.IGNORE_CASE, RegexOption.MULTILINE))
-            .find(script)?.let {
-                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
@@ -1,36 +1,13 @@
 package fr.postgresjson.definition

 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: File?
+}

-    open class ParseException(message: String, cause: Throwable? = null) : Exception(message, cause)
-
-    companion object {
-        fun build(file: File): Resource =
-            build(file.readText(), Path.of(file.toURI()))
-
-        fun build(url: URL): Resource =
-            build(url.readText(), Path.of(url.toURI()))
-
-        fun build(resource: String, path: Path): Resource =
-            try {
-                Migration(resource, path)
-            } catch (e: ParseException) {
-                try {
-                    Function(resource, path)
-                } catch (e: ParseException) {
-                    try {
-                        Query(resource, path)
-                    } catch (e: ParseException) {
-                        throw ParseException("No SQL resource found")
-                    }
-                }
-            }
-    }
+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,
@@ -116,11 +86,3 @@ abstract class EntityImp<T, UserT : EntityI>(
    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)
--- 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,7 +36,6 @@ data class Function(
    )

    override fun up(): Status {
-        return try {
        try {
            connection.sendQuery(up.script)
        } catch (e: CompletionException) {
@@ -48,48 +46,51 @@ data class Function(
            }
        }

-            this::class.java.classLoader
-                .getResource("sql/migration/insertFunction.sql")!!.readText()
-                .let { connection.selectOne<MigrationEntity>(it, listOf(up.name, up.getDefinition(), up.script, down.script)) }
-                ?.let { function ->
+        this::class.java.classLoader.getResource("sql/migration/insertFunction.sql")!!.readText().let {
+            connection.selectOne<MigrationEntity>(it, listOf(up.name, up.getDefinition(), up.script, down.script))?.let { function ->
                executedAt = function.executedAt
                doExecute = Action.OK
            }
-
-            Status.OK
-        } catch (e: Throwable) {
-            Status.UP_FAIL
        }
+        return Status.OK
    }

    override fun down(): Status {
-        return try {
        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 // TODO
    }

-        return Status.OK
+    override fun status(): Status {
+        connection.inTransaction {
+            up()
+            down()
+            it.sendQuery("ROLLBACK")
+        }.join()
+
+        return Status.OK // TODO
    }

-    fun copy(): Function = this
-        .copy(up = up, down = down, connection = connection, executedAt = executedAt)
-        .also { it.doExecute = this.doExecute }
-
-    infix fun `is different from`(other: DefinitionFunction): Boolean = other.script != this.up.script
+    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,17 +2,16 @@ 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.Function.FunctionNotFound
+import fr.postgresjson.entity.mutable.Entity
 import fr.postgresjson.migration.Migration.Action
 import fr.postgresjson.migration.Migration.Status
 import fr.postgresjson.utils.LoggerDelegate
-import fr.postgresjson.utils.searchSqlFiles
 import org.slf4j.Logger
+import java.io.File
 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,35 +27,35 @@ 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 queries: MutableMap<String, Query> = mutableMapOf(),
    private val functions: MutableMap<String, Function> = mutableMapOf()
 ) {
-    private var directories: List<URI> = emptyList()
+    private var directories: List<File> = 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(directory: File, connection: Connection) : this(listOf(directory), connection)

-    constructor(directories: List<URI>, connection: Connection) : this(connection) {
+    constructor(directories: List<File>, connection: Connection) : this(connection) {
        initDB()
        this.directories = directories
        reset()
    }

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

        getMigrationFromDB()
        getMigrationFromDirectory(directories)

-        migrationsScripts.forEach { (_, query) ->
+        queries.forEach { (_, query) ->
            if (query.doExecute === null) {
                query.doExecute = Action.DOWN
            }
@@ -76,16 +75,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)
+                    queries[query.filename] = Query(query.filename, query.up, query.down, connection, query.executedAt)
                }
        }
    }
@@ -93,7 +92,7 @@ class Migrations private constructor(
    /**
     * Get all migration from multiples Directories
     */
-    private fun getMigrationFromDirectory(directory: List<URI>) {
+    private fun getMigrationFromDirectory(directory: List<File>) {
        directory.forEach {
            getMigrationFromDirectory(it)
        }
@@ -102,26 +101,29 @@ class Migrations private constructor(
    /**
     * Get all migration from Directory
     */
-    private fun getMigrationFromDirectory(directory: URI) {
-        val downs: MutableMap<String, DefinitionMigration> = mutableMapOf()
-
-        directory.searchSqlFiles().apply {
-            /* Set Down Migration */
-            forEach { migration ->
-                if (migration is DefinitionMigration && migration.direction == DefinitionMigration.Direction.DOWN) {
-                    downs += migration.name to migration
+    private fun getMigrationFromDirectory(directory: File) {
+        directory.walk().filter {
+            it.isFile
+        }.forEach { file ->
+            if (file.name.endsWith(".up.sql")) {
+                file.path.substring(0, file.path.length - 7).let {
+                    try {
+                        val down = File("$it.down.sql").readText()
+                        val up = file.readText()
+                        val name = file.name.substring(0, file.name.length - 7)
+                        addQuery(name, up, down)
+                    } catch (e: FileNotFoundException) {
+                        throw DownMigrationNotDefined("$it.down.sql", e)
                    }
                }
-
-            /* Set up migrations and functions */
-            forEach { migration ->
-                if (migration is DefinitionMigration && migration.direction == DefinitionMigration.Direction.UP) {
-                    val down = downs[migration.name] ?: throw DownMigrationNotDefined(migration.name + ".down.sql")
-                    downs -= migration.name
-
-                    addMigrationScript(migration, down)
-                } else if (migration is DefinitionFunction) {
-                    addFunction(migration)
+            } else if (file.name.endsWith(".down.sql")) {
+                // Nothing
+            } else {
+                val fileContent = file.readText()
+                try {
+                    addFunction(fileContent)
+                } catch (e: FunctionNotFound) {
+                    // Nothing
                }
            }
        }
@@ -129,8 +131,8 @@ 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)
+    internal class DownMigrationNotDefined(path: String, cause: FileNotFoundException) :
+        Throwable("The file $path whas not found", cause)

    fun addFunction(newDefinition: DefinitionFunction, callback: (Function) -> Unit = {}): Migrations {
        val currentFunction = functions[newDefinition.name]
@@ -153,31 +155,28 @@ 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 addMigrationScript(name: String, up: String, down: String, callback: (MigrationScript) -> Unit = {}): Migrations {
-        if (migrationsScripts[name] === null) {
-            migrationsScripts[name] = MigrationScript(name, up, down, connection).apply {
+    fun addQuery(name: String, up: String, down: String, callback: (Query) -> Unit = {}): Migrations {
+        if (queries[name] === null) {
+            queries[name] = Query(name, up, down, connection).apply {
                doExecute = Action.UP
            }
        } else {
-            migrationsScripts[name]!!.apply {
+            queries[name]!!.apply {
                doExecute = Action.OK
            }
        }

-        callback(migrationsScripts[name]!!)
+        callback(queries[name]!!)

        return this
    }

    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
@@ -192,7 +191,7 @@ class Migrations private constructor(

    internal fun up(): Map<String, Status> {
        val list: MutableMap<String, Status> = mutableMapOf()
-        migrationsScripts.forEach {
+        queries.forEach {
            it.value.let { query ->
                if (query.doExecute == Action.UP) {
                    query.up().let { status ->
@@ -217,7 +216,7 @@ class Migrations private constructor(

    internal fun down(force: Boolean = false): Map<String, Status> {
        val list: MutableMap<String, Status> = mutableMapOf()
-        migrationsScripts.forEach {
+        queries.forEach {
            it.value.let { query ->
                if (query.doExecute == Action.DOWN || force) {
                    query.down().let { status ->
@@ -297,8 +296,8 @@ class Migrations private constructor(
        return list.toMap()
    }

-    private fun copy(): Migrations {
-        val queriesCopy = migrationsScripts.map {
+    fun copy(): Migrations {
+        val queriesCopy = queries.map {
            it.key to it.value.copy()
        }.toMap().toMutableMap()

--- 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,13 +41,23 @@ data class MigrationScript(
        connection.inTransaction {
            up()
            down()
-            sendQuery("ROLLBACK")
+            it.sendQuery("ROLLBACK")
+        }.join()
+
+        return Migration.Status.OK // TODO
    }

-        return Migration.Status.OK
+    override fun status(): Migration.Status {
+        connection.inTransaction {
+            up()
+            down()
+            it.sendQuery("ROLLBACK")
+        }.join()
+
+        return Migration.Status.OK // TODO
    }

-    fun copy(): MigrationScript {
+    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> E.deserialize(json: String) = Serializer().deserialize(json, this)
 inline fun <reified E : Serializable> String.deserialize() = Serializer().deserialize<E>(this)
-
-inline fun <reified T : Serializable> T.toTypeReference(): TypeReference<T> = object : TypeReference<T>() {}
--- 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
@@ -1,51 +0,0 @@
-package fr.postgresjson.utils
-
-import fr.postgresjson.definition.Resource
-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
-import java.nio.file.Path
-import kotlin.streams.asSequence
-
-fun URL.searchSqlFiles() = this.toURI().searchSqlFiles()
-
-fun URI.searchSqlFiles() = sequence {
-    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
-            .walk(5)
-            .asSequence()
-            .filter { it.fileName.toString().endsWith(".sql") }
-            .map { it.toUri().toURL() }
-            .forEach {
-                logger.debug(it.toString())
-                yield(Resource.build(it))
-            }
-    } else {
-        uri
-            .walk(5)
-            .asSequence()
-            .map { it.toFile() }
-            .filter { it.isFile && it.extension == "sql" }
-            .forEach {
-                logger.debug(it.toString())
-                yield(Resource.build(it))
-            }
-    }
-}
-
-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()
--- 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,43 +1,31 @@
 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(
-            """
+        val objs: List<ObjTest2> = connection.select("""
        select
            json_agg(j)
            FROM (
@@ -51,129 +39,101 @@ class ConnectionTest : TestAbstract() {
        )
        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,30 +1,23 @@
 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>)
--- a/src/test/kotlin/fr/postgresjson/MigrationTest.kt
+++ b/src/test/kotlin/fr/postgresjson/MigrationTest.kt
@@ -1,24 +1,23 @@
 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
+import java.io.File

@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 = File(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 +28,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 = File(this::class.java.getResource("/sql/migration_without_down").toURI())
        invoking {
            Migrations(resources, connection)
        } shouldThrow Migrations.DownMigrationNotDefined::class
@@ -37,7 +36,7 @@ class MigrationTest : TestAbstract() {

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

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

    @Test
    fun `run dry migrations launch twice`() {
-        val resources = this::class.java.getResource("/sql/real_migrations")!!.toURI()
+        val resources = File(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 +68,7 @@ class MigrationTest : TestAbstract() {

    @Test
    fun `run migrations`() {
-        val resources = this::class.java.getResource("/sql/real_migrations")!!.toURI()
+        val resources = File(this::class.java.getResource("/sql/real_migrations").toURI())
        Migrations(resources, connection).apply {
            run().apply {
                size `should be equal to` 1
@@ -79,8 +78,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 = File(this::class.java.getResource("/sql/real_migrations").toURI())
+        val resourcesFunctions = File(this::class.java.getResource("/sql/function/Test").toURI())
        Migrations(listOf(resources, resourcesFunctions), connection).apply {
            up().apply {
                size `should be equal to` 6
@@ -95,34 +94,36 @@ class MigrationTest : TestAbstract() {

    @Test
    fun `run functions migrations`() {
-        val resources = this::class.java.getResource("/sql/function/Test")!!.toURI()
+        val resources = File(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 = File(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 = File(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,56 @@
 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
+import java.io.File

 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 = File(this::class.java.getResource("/sql/query").toURI())
        val objTest: ObjTest? = Requester(connection)
-            .apply { addQuery(resources) }
-            .getQuery("selectOne")
+            .addQuery(resources)
+            .getQuery("Test/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 = File(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)
-            .getQuery("selectOne")
+        val resources = File(this::class.java.getResource("/sql/query").toURI())
+        val result = Requester(connection)
+            .addQuery(resources)
+            .getQuery("Test/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 = File(this::class.java.getResource("/sql/function/Test").toURI())
+        val result = Requester(connection)
+            .addFunction(resources)
            .getFunction("test_function")
            .exec(listOf("test", "plip"))

@@ -176,332 +58,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)
-            .getQuery("DeleteTest")
-            .exec()
+    fun `call sendQuery on query`() {
+        val resources = File(this::class.java.getResource("/sql/query").toURI())
+        val result = Requester(connection)
+            .addQuery(resources)
+            .getQuery("Test/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 = File(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 = File(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 = File(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)
-            .getQuery("selectOneWithParameters")
-            .selectOne(mapOf("name" to "myName"))
+        val resources = File(this::class.java.getResource("/sql/query").toURI())
+        val obj: ObjTest = Requester(connection)
+            .addQuery(resources)
+            .getQuery("Test/selectOneWithParameters")
+            .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 = File(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)
-            .getQuery("selectPaginated")
+        val resources = File(this::class.java.getResource("/sql/query").toURI())
+        val result: Paginated<ObjTest> = Requester(connection)
+            .addQuery(resources)
+            .getQuery("Test/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 = File(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 = File(this::class.java.getResource("/sql/query").toURI())
+        val obj: ObjTest = Requester(connection)
+            .addQuery(resources)
+            .getQuery("Test/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
@@ -9,11 +9,11 @@ import java.io.File

@TestInstance(PER_CLASS)
 abstract class TestAbstract {
-    protected val connection = Connection(database = "json_test", username = "test", password = "test", port = 5555)
+    protected val connection = Connection(database = "test_json", username = "test", password = "test")

    @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/exec.sql
+++ b/src/test/resources/sql/query/Test/exec.sql
@@ -1,2 +1 @@
-- name: DeleteTest
 delete FROM test where 2038538 = 2;
--- 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	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";`