Kotlin Academy · Lezione

Definire le tabelle con la DSL Table

Definisca schemi di tabelle tipizzati con colonne, chiavi primarie e chiavi esterne.

Definire le tabelle con la DSL Table è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Oggetti tabella di Exposed

In Exposed, le tabelle del database sono rappresentate come object singleton di Kotlin che estendono Table (Query DSL) oppure IntIdTable/LongIdTable/UUIDTable (DAO layer). Le definizioni delle colonne sono proprietà Kotlin.

Una definizione di tabella di base

Estenda Table e definisca le colonne utilizzando le funzioni factory integrate:

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)
}

Tipi di colonna

Exposed fornisce funzioni factory per i tipi SQL più comuni:

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)

Colonne nullable

Chiami .nullable() su qualsiasi colonna per consentire valori NULL. Il tipo Kotlin diventa nullable (String? anziché 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)
}

Valori predefiniti

Utilizzi .default(value) per un valore predefinito lato Kotlin (applicato prima dell'inserimento) oppure .defaultExpression(expr) per un valore predefinito SQL lato database:

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)
}

Indici e vincoli di unicità

Chiami .index() per un indice normale o .uniqueIndex() per un indice univoco direttamente su una colonna. Per gli indici composti, utilizzi la funzione index() sulla 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)
}

Chiavi esterne

Utilizzi .references() per dichiarare un vincolo di chiave esterna tra colonne. Passi la colonna referenziata e, facoltativamente, le azioni onDelete e 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)
}

Varianti di IdTable

Per il DAO layer, utilizzi tabelle con ID tipizzato invece di una semplice Table:

IntIdTable("name") — chiave primaria Int autoincrementante denominata id
LongIdTable("name") — chiave primaria Long autoincrementante
UUIDTable("name") — chiave primaria UUID

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

Chiavi primarie composte

Definisca una chiave primaria composta passando più colonne a 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)
}

Colonne enum

Memorizzi i valori enum di Kotlin come stringhe o ordinali utilizzando enumerationByName() o enumeration():

enum class Status { ACTIVE, INACTIVE, BANNED }

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

Applicazione delle modifiche allo schema

Chiami SchemaUtils.createMissingTablesAndColumns() per aggiungere le tabelle e le colonne mancanti senza eliminare i dati esistenti: una migrazione sicura per lo sviluppo. In produzione, utilizzi uno strumento per le migrazioni come Flyway o Liquibase.

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

Verifica rapida

Come si dichiara in Exposed's Table DSL una chiave esterna da Posts.authorId a Users.id?

Riepilogo: definizione delle tabelle con la Table DSL

Punti chiave:

Le tabelle sono object che estendono Table, LongIdTable ecc.
Colonne: varchar, integer, long, bool, datetime, uuid ecc.
.nullable(), .default(), .uniqueIndex() e .references() modificano le colonne
Chiavi primarie composte: PrimaryKey(col1, col2)
Applichi lo schema con SchemaUtils.create() o createMissingTablesAndColumns()

Domande Frequenti

La lezione «Definire le tabelle con la DSL Table» è gratuita?

Sì — il testo completo di «Definire le tabelle con la DSL Table» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Definire le tabelle con la DSL Table»?

Definisca schemi di tabelle tipizzati con colonne, chiavi primarie e chiavi esterne. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Definire le tabelle con la DSL Table»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Configurazione di Exposed: connessione al database e DSL delle transazioni
Definire le tabelle con la DSL Table
CRUD con la DSL Query: insert, select, update, delete
DAO di Exposed: classi Entity e relazioni

← Torna a Kotlin Academy