Kotlin Academy · Leçon

Définir des tables avec le DSL Table

Définissez des schémas de tables typés avec des colonnes, des clés primaires et des clés étrangères.

Définir des tables avec le DSL Table est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Objets de tables Exposed

Dans Exposed, les tables de la base de données sont représentées par des objects singleton Kotlin qui étendent Table (DSL de requêtes) ou IntIdTable/LongIdTable/UUIDTable (couche DAO). Les définitions de colonnes sont des propriétés Kotlin.

Définition d’une table simple

Étendez Table et définissez les colonnes à l’aide des fonctions intégrées de création de colonnes :

import org.jetbrains.exposed.sql.Table

object Users : Table("users") {
    val id    = long("id").autoIncrement()
    val name  = varchar("name", 100)
    val email = varchar("email", 255).uniqueIndex()
    val age   = integer("age").nullable()

    override val primaryKey = PrimaryKey(id)
}

Types de colonnes

Exposed fournit des fonctions de création pour les types SQL courants :

integer("col"), long("col"), short("col")
varchar("col", length), text("col")
bool("col"), double("col"), decimal("col", precision, scale)
datetime("col"), date("col"), timestamp("col")
blob("col"), uuid("col"), binary("col", length)

Colonnes acceptant la valeur nulle

Appelez .nullable() sur n’importe quelle colonne pour autoriser les valeurs NULL. Le type Kotlin devient nullable (String? au lieu de String) :

object Products : Table("products") {
    val id          = long("id").autoIncrement()
    val name        = varchar("name", 200)
    val description = text("description").nullable()
    override val primaryKey = PrimaryKey(id)
}

Valeurs par défaut

Utilisez .default(value) pour une valeur par défaut côté Kotlin (appliquée avant l’insertion) ou .defaultExpression(expr) pour une valeur par défaut SQL côté base de données :

object Orders : Table("orders") {
    val id        = long("id").autoIncrement()
    val status    = varchar("status", 20).default("PENDING")
    val createdAt = datetime("created_at")
        .defaultExpression(CurrentDateTime)
    override val primaryKey = PrimaryKey(id)
}

Index et contraintes d’unicité

Appelez .index() pour créer un index standard ou .uniqueIndex() pour créer un index unique directement sur une colonne. Pour les index composites, utilisez la fonction index() sur la table :

object Articles : Table("articles") {
    val id    = long("id").autoIncrement()
    val title = varchar("title", 300).index()
    val slug  = varchar("slug", 300).uniqueIndex()
    override val primaryKey = PrimaryKey(id)
}

Clés étrangères

Utilisez .references() pour déclarer une contrainte de clé étrangère entre des colonnes. Transmettez la colonne référencée et, éventuellement, les actions onDelete et onUpdate :

object Posts : Table("posts") {
    val id       = long("id").autoIncrement()
    val authorId = long("author_id").references(Users.id, onDelete = ReferenceOption.CASCADE)
    val title    = varchar("title", 300)
    override val primaryKey = PrimaryKey(id)
}

Variantes d’IdTable

Pour la couche DAO, utilisez des tables avec un identifiant typé plutôt qu’une simple Table :

IntIdTable("name") — clé primaire Int à auto-incrémentation nommée id
LongIdTable("name") — clé primaire Long à auto-incrémentation
UUIDTable("name") — clé primaire UUID

object Users : LongIdTable("users") {
    val name  = varchar("name", 100)
    val email = varchar("email", 255).uniqueIndex()
}

Clés primaires composites

Définissez une clé primaire composite en transmettant plusieurs colonnes à PrimaryKey() :

object UserRoles : Table("user_roles") {
    val userId = long("user_id").references(Users.id)
    val roleId = long("role_id").references(Roles.id)
    override val primaryKey = PrimaryKey(userId, roleId)
}

Colonnes d’énumération

Stockez les valeurs d’énumération Kotlin sous forme de chaînes ou de valeurs ordinales à l’aide de enumerationByName() ou enumeration() :

enum class Status { ACTIVE, INACTIVE, BANNED }

object Users : LongIdTable("users") {
    val name   = varchar("name", 100)
    val status = enumerationByName<Status>("status", 20)
}

Application des modifications du schéma

Appelez SchemaUtils.createMissingTablesAndColumns() pour ajouter les tables et colonnes manquantes sans supprimer les données existantes — une migration sûre pour le développement. En production, utilisez un outil de migration comme Flyway ou Liquibase.

transaction {
    SchemaUtils.createMissingTablesAndColumns(Users, Posts, Orders)
}

Vérification rapide

Comment déclarer une clé étrangère de Posts.authorId vers Users.id dans le DSL Table d’Exposed ?

Récapitulatif : définition des tables avec le DSL Table

Points essentiels :

Les tables sont des object qui étendent Table, LongIdTable, etc.
Colonnes : varchar, integer, long, bool, datetime, uuid, etc.
.nullable(), .default(), .uniqueIndex() et .references() modifient les colonnes
Clés primaires composites : PrimaryKey(col1, col2)
Appliquez le schéma avec SchemaUtils.create() ou createMissingTablesAndColumns()

Questions Fréquemment Posées

La leçon « Définir des tables avec le DSL Table » est-elle gratuite ?

Oui — le texte complet de « Définir des tables avec le DSL Table » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Définir des tables avec le DSL Table » ?

Définissez des schémas de tables typés avec des colonnes, des clés primaires et des clés étrangères. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Définir des tables avec le DSL Table » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Configuration d’Exposed : connexion à la base de données et DSL des transactions
Définir des tables avec le DSL Table
CRUD avec le DSL de requêtes : insert, select, update, delete
DAO Exposed : classes d’entités et relations

← Retour à Kotlin Academy