Kotlin Academy · Lekcja

Definiowanie tabel za pomocą DSL Table

Definiuj typowane schematy tabel z kolumnami, kluczami głównymi i obcymi.

Definiowanie tabel za pomocą DSL Table to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Obiekty tabel Exposed

W Exposed tabele baz danych reprezentują singletony Kotlin object, które rozszerzają Table (DSL zapytań) lub IntIdTable/LongIdTable/UUIDTable (warstwa DAO). Definicje kolumn są właściwościami Kotlina.

Podstawowa definicja tabeli

Rozszerz Table i zdefiniuj kolumny za pomocą wbudowanych funkcji tworzących kolumny:

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

Typy kolumn

Exposed udostępnia funkcje tworzące kolumny dla typowych typów SQL:

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)

Kolumny dopuszczające wartości null

Wywołaj .nullable() dla dowolnej kolumny, aby zezwolić na wartości NULL. Typ Kotlinu staje się typem dopuszczającym wartość null (String? zamiast 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)
}

Wartości domyślne

Użyj .default(value), aby określić wartość domyślną po stronie Kotlinu (stosowaną przed wstawieniem), lub .defaultExpression(expr), aby określić domyślną wartość SQL po stronie bazy danych:

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

Indeksy i ograniczenia unikatowości

Wywołaj .index() dla zwykłego indeksu lub .uniqueIndex() dla indeksu unikatowego bezpośrednio na kolumnie. W przypadku indeksów złożonych użyj funkcji index() na obiekcie 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)
}

Klucze obce

Użyj .references(), aby zadeklarować ograniczenie klucza obcego między kolumnami. Przekaż kolumnę, do której następuje odwołanie, oraz opcjonalnie działania onDelete i 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)
}

Warianty IdTable

W warstwie DAO używaj tabel z typowanymi identyfikatorami zamiast zwykłego Table:

IntIdTable("name") — automatycznie inkrementowany klucz główny typu Int o nazwie id
LongIdTable("name") — automatycznie inkrementowany klucz główny typu Long
UUIDTable("name") — klucz główny typu UUID

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

Złożone klucze główne

Zdefiniuj złożony klucz główny, przekazując wiele kolumn do 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)
}

Kolumny typu enum

Przechowuj wartości enuma Kotlinu jako ciągi znaków lub wartości porządkowe za pomocą enumerationByName() lub enumeration():

enum class Status { ACTIVE, INACTIVE, BANNED }

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

Stosowanie zmian schematu

Wywołaj SchemaUtils.createMissingTablesAndColumns(), aby dodać brakujące tabele i kolumny bez usuwania istniejących danych — jest to bezpieczna migracja w środowisku deweloperskim. W środowisku produkcyjnym używaj narzędzia do migracji, takiego jak Flyway lub Liquibase.

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

Szybkie sprawdzenie

Jak zadeklarować klucz obcy z Posts.authorId do Users.id w DSL tabel Exposed?

Podsumowanie: definiowanie tabel za pomocą DSL tabel

Najważniejsze informacje:

Tabele to obiekty object rozszerzające Table, LongIdTable itd.
Kolumny: varchar, integer, long, bool, datetime, uuid itd.
.nullable(), .default(), .uniqueIndex() i .references() modyfikują kolumny
Złożone klucze główne: PrimaryKey(col1, col2)
Zastosuj schemat za pomocą SchemaUtils.create() lub createMissingTablesAndColumns()

Często zadawane pytania

Czy lekcja „Definiowanie tabel za pomocą DSL Table” jest bezpłatna?

Tak — pełny tekst „Definiowanie tabel za pomocą DSL Table” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Definiowanie tabel za pomocą DSL Table”?

Definiuj typowane schematy tabel z kolumnami, kluczami głównymi i obcymi. Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Definiowanie tabel za pomocą DSL Table”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Konfiguracja Exposed: połączenie z bazą danych i DSL transakcji
Definiowanie tabel za pomocą DSL Table
CRUD z DSL zapytań: insert, select, update, delete
Exposed DAO: klasy encji i relacje

← Powrót do Kotlin Academy