Connexion aux bases de données avec Exposed

Introduction

Exposed est un framework open source conçu pour s’intégrer à une base de données relationnelle. Entièrement écrit en Kotlin, il bénéficie du soutien de l’entreprise JetBrains à l’origine du langage Kotlin. Exposed est apparu au cours de l’année 2019 en tant qu’alternative plus légère aux frameworks de base de données utilisés dans l’écosystème Java, tels que Hibernate. Ce framework s’appuie sur la syntaxe du langage Kotlin pour simplifier et faciliter l’écriture des requêtes SQL.

Exposed se base sur la librairie JDBC. Cette dernière fournit une couche d’abstraction permettant la connexion aux différents systèmes de gestion de bases de données relationnelles. Chaque base de données relationnelle fournit des drivers implémentant la spécification JDBC, ce qui permet de découpler le code de l’application de la gestion de connexion vers une base données spécifique. Cependant, ce découplage se limite à la connexion et à l’exécution des requêtes. Les requêtes, quant à elles, restent propres à chaque système de base de données. En effet, même si tous ces systèmes utilisent le même langage « SQL », chacun...

Comparaison entre Exposed et Hibernate

Les deux frameworks offrent une méthode fiable pour découpler l’application de la base de données. En étant un langage de la JVM, Kotlin permet d’utiliser facilement tous les frameworks Java existants permettant la gestion de bases de données pour une application. Le choix du framework devrait donc être basé sur les avantages offerts par l’architecture sur laquelle il repose.

Installation et configuration

implementation("org.jetbrains.exposed:exposed-core:0.45.0") 
implementation("org.jetbrains.exposed:exposed-jdbc:0.45.0") 
implementation("org.jetbrains.exposed:exposed-dao:0.45.0") 

<dependency> 
    <groupId>org.jetbrains.exposed</groupId> 
    <artifactId>exposed-core</artifactId> 
    <version>0.45.0</version> 
</dependency> 
<dependency> 
    <groupId>org.jetbrains.exposed</groupId> 
    <artifactId>exposed-jdbc</artifactId> 
    <version>0.45.0</version> 
</dependency> 
<dependency> 
    <groupId>org.jetbrains.exposed</groupId> 
    <artifactId>exposed-dao</artifactId> 
    <version>0.45.0</version> 
</dependency> 

implementation("org.postgresql:postgresql:42.7.1") 

<dependency> 
    <groupId>org.postgresql</groupId> 
    <artifactId>postgresql</artifactId> 
    <version>42.7.1</version> 
</dependency> 

Database.connect("jdbc:postgresql://localhost:5432/
my_db", driver = "org.postgresql.Driver") 

Les bases du framework Exposed

data class Team(id: Int, name: String) 

import org.jetbrains.exposed.sql.Table 
 
object Teams : Table("teams") 

object Teams : Table("teams") { 
    val id = integer("id") 
        val name = varchar("name", 128) 
} 

val teamName = varchar("name", 128) 

 object Teams : Table("teams") { 
    val id = integer("id") 
    val name = varchar("name", 128) 
    override val primaryKey = PrimaryKey(id) ...

Gérer les jointures

Les jointures, désignées par la commande « JOIN » en langage SQL, représentent une notion fondamentale pour les bases de données relationnelles. Cette opération permet de fusionner des données réparties sur deux ou plusieurs tables en se basant sur les liens relationnels entre elles. Le résultat de cette fusion est une vue consolidée regroupant les données combinées des différentes tables. Le contenu de cette vue renvoyée dépend du type d’opération de jointure exécutée. Parmi ces différents types figurent la jointure interne, la jointure à droite, la jointure à gauche et la jointure complète.

Ces différents types de jointures offrent plusieurs options de combinaisons de données des différentes tables utilisées par l’application.

Teams.join( 
    otherTable = Players, 
    joinType = JoinType.INNER, 
    onColumn = Teams.id, 
    otherColumn = Players.teamId, 
) 

Teams : 
- Id : 1, name : France 
- Id : 2, name : Spain 
 
Players 
- id : 1, teamId : 1 
- id : 2, teamId : 1 
- id : 3, teamId : 4 

- players.id...

Utilisation des fonctions SQL

La plupart des systèmes de gestion de base de données offrent des fonctions SQL intégrées pour simplifier la manipulation des données, l’agrégation des résultats et l’exécution de calculs directement à partir d’une requête SQL. Le framework Exposed permet d’exécuter ces diverses fonctions en utilisant sa syntaxe DSL.

À titre d’exemple, pour récupérer le nombre de lignes d’une table, en SQL, il est possible d’utiliser la fonction COUNT. La syntaxe DSL d’Exposed permet d’exécuter cette fonction de la manière suivante :

Teams.id.count() 

Comme en SQL, cette fonction nécessite de spécifier la colonne à utiliser pour compter les enregistrements retournés par la requête. Dans l’exemple précédent, la colonne id sera utilisée pour calculer le nombre d’entités de la table « Teams ».

Par exemple, la fonction count peut être utilisée dans une requête de sélection comme suit :

Teams.select(Teams.id.count()) 

Toutefois, pour pouvoir lire le résultat de la requête, il est nécessaire de déclarer l’utilisation de la fonction dans une variable de la manière suivante :

val teamsCountById = Teams.id.count() 

Cette variable peut alors être utilisée dans la requête afin d’exécuter la fonction et récupérer son résultat :

Teams.select(teamsCountById).map { it[teamsCountById] } 

Le code précédent exécute une requête de sélection afin de compter le nombre de lignes dans la table « Teams » en utilisant...

Tester les requêtes

Les tests sont indispensables pour valider le bon fonctionnement du code de l’application. Cependant, il est souvent difficile d’écrire des tests pour les modules de l’application qui interagissent avec une base de données. Par conséquent, ces parties du code sont souvent peu ou mal testées. Pour remédier à cela, plusieurs librairies ont vu le jour. Parmi celles-ci figure la bibliothèque Java Testcontainers. Cette bibliothèque s’appuie sur Docker pour créer et gérer un conteneur contenant la base de données cible de l’application. Cette approche, différente de celle de la simulation des requêtes à l’aide d’une base de données en mémoire (H2 par exemple), permet de valider la connexion et les différentes requêtes en utilisant le même type de base de données que celui de l’environnement de production. Cela rend les tests plus fiables et cohérents avec les conditions réelles.

Pour intégrer Testcontainers à un projet, il suffit d’ajouter la dépendance de test suivante :

testImplementation("org.testcontainers:testcontainers:1.19.7") 

<dependency> 
    <groupId>org.testcontainers</groupId> 
    <artifactId>testcontainers</artifactId> 
    <version>1.19.7</version> 
    <scope>test</scope> 
</dependency> 

Comme cette bibliothèque se base sur Docker, elle nécessite que Docker soit installé sur la machine de développement ainsi que toutes les machines de la chaîne d’intégration continue (CI).

La bibliothèque Testcontainers repose...

Monitoring des requêtes

import org.jetbrains.exposed.sql.StdOutSqlLogger 
import org.jetbrains.exposed.sql.addLogger 
 
transaction { 
   addLogger(StdOutSqlLogger) 
} 

transaction {  
  addLogger(StdOutSqlLogger) 
  Teams.select(Teams.name).where { Teams.id eq 1}.toList() 
} 

SQL: SELECT teams.name from teams WHERE teams.id = 1 

class CustomSqlLogger : SqlLogger...