Kotlin Academy · Lektion

Tabellen mit der Table-DSL definieren

Definieren Sie typisierte Tabellenschemas mit Spalten, Primärschlüsseln und Fremdschlüsseln.

Tabellen mit der Table-DSL definieren ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Exposed-Tabellenobjekte

In Exposed werden Datenbanktabellen als Kotlin-Singletons mit object dargestellt, die von Table (Query DSL) oder IntIdTable/LongIdTable/UUIDTable (DAO-Schicht) erben. Spaltendefinitionen sind Kotlin-Eigenschaften.

Eine einfache Tabellendefinition

Erweitern Sie Table und definieren Sie Spalten mit den integrierten Spaltenfabrikfunktionen:

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

Spaltentypen

Exposed stellt Factory-Funktionen für gängige SQL-Typen bereit:

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)

Nullable-Spalten

Rufen Sie für jede Spalte .nullable() auf, um NULL-Werte zuzulassen. Der Kotlin-Typ wird nullfähig (String? statt 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)
}

Standardwerte

Verwenden Sie .default(value) für einen Kotlin-seitigen Standardwert (der vor dem Einfügen angewendet wird) oder .defaultExpression(expr) für einen SQL-Standardwert auf Datenbankseite:

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

Indizes und Eindeutigkeitsbedingungen

Rufen Sie direkt für eine Spalte .index() für einen normalen Index oder .uniqueIndex() für einen eindeutigen Index auf. Verwenden Sie für zusammengesetzte Indizes die Funktion index() für die Tabelle:

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

Fremdschlüssel

Verwenden Sie .references(), um eine Fremdschlüsselbedingung zwischen Spalten zu deklarieren. Übergeben Sie die referenzierte Spalte sowie optional die Aktionen onDelete und 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)
}

Varianten von IdTable

Verwenden Sie für die DAO-Schicht typisierte ID-Tabellen statt einer einfachen Table:

IntIdTable("name") – automatisch inkrementierender Primärschlüssel vom Typ Int mit dem Namen id
LongIdTable("name") – automatisch inkrementierender Primärschlüssel vom Typ Long
UUIDTable("name") – UUID-Primärschlüssel

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

Zusammengesetzte Primärschlüssel

Definieren Sie einen zusammengesetzten Primärschlüssel, indem Sie mehrere Spalten an PrimaryKey() übergeben:

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

Enum-Spalten

Speichern Sie Kotlin-Enum-Werte als Zeichenketten oder Ordinalwerte mit enumerationByName() oder enumeration():

enum class Status { ACTIVE, INACTIVE, BANNED }

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

Schemaänderungen anwenden

Rufen Sie SchemaUtils.createMissingTablesAndColumns() auf, um fehlende Tabellen und Spalten hinzuzufügen, ohne vorhandene Daten zu löschen – eine sichere Migration für die Entwicklung. Verwenden Sie in der Produktion ein Migrationswerkzeug wie Flyway oder Liquibase.

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

Kurzer Check

Wie deklarieren Sie im Table DSL von Exposed einen Fremdschlüssel von Posts.authorId zu Users.id?

Zusammenfassung: Tabellen mit dem Table DSL definieren

Wichtigste Erkenntnisse:

Tabellen sind objects, die Table, LongIdTable usw. erweitern
Spalten: varchar, integer, long, bool, datetime, uuid usw.
.nullable(), .default(), .uniqueIndex() und .references() ändern Spalteneigenschaften
Zusammengesetzte Primärschlüssel: PrimaryKey(col1, col2)
Wenden Sie das Schema mit SchemaUtils.create() oder createMissingTablesAndColumns() an

Häufig gestellte Fragen

Ist die Lektion „Tabellen mit der Table-DSL definieren“ kostenlos?

Ja — der vollständige Text von „Tabellen mit der Table-DSL definieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Tabellen mit der Table-DSL definieren“?

Definieren Sie typisierte Tabellenschemas mit Spalten, Primärschlüsseln und Fremdschlüsseln. Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Tabellen mit der Table-DSL definieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Exposed einrichten: Datenbankverbindung und Transaction-DSL
Tabellen mit der Table-DSL definieren
CRUD mit der Query-DSL: insert, select, update, delete
Exposed DAO: Entity-Klassen und Beziehungen

← Zurück zu Kotlin Academy