Kotlin Academy · Lección

Definir tablas con el DSL Table

Defina esquemas de tablas tipados con columnas, claves primarias y claves foráneas.

Definir tablas con el DSL Table es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

Objetos Table de Exposed

En Exposed, las tablas de la base de datos se representan como objetos singleton object de Kotlin que extienden Table (Query DSL) o IntIdTable/LongIdTable/UUIDTable (capa DAO). Las definiciones de las columnas son propiedades de Kotlin.

Definición básica de una tabla

Extienda Table y defina las columnas mediante las funciones de fábrica de columnas integradas:

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

Tipos de columnas

Exposed proporciona funciones de fábrica para los tipos SQL habituales:

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)

Columnas anulables

Llame a .nullable() en cualquier columna para permitir valores NULL. El tipo de Kotlin pasa a admitir valores nulos (String? en lugar 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)
}

Valores predeterminados

Use .default(value) para un valor predeterminado del lado de Kotlin (que se aplica antes de la inserción) o .defaultExpression(expr) para un valor predeterminado SQL del lado de la base de datos:

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

Índices y restricciones de unicidad

Llame a .index() para crear un índice normal o a .uniqueIndex() para crear un índice único directamente en una columna. Para los índices compuestos, use la función index() en 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)
}

Claves foráneas

Use .references() para declarar una restricción de clave foránea entre columnas. Pase la columna referenciada y, opcionalmente, las acciones onDelete y 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 de IdTable

Para la capa DAO, use tablas de ID con tipo en lugar de una Table normal:

IntIdTable("name") — clave primaria autoincremental de Int llamada id
LongIdTable("name") — clave primaria autoincremental de Long
UUIDTable("name") — clave primaria UUID

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

Claves primarias compuestas

Defina una clave primaria compuesta pasando varias columnas 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)
}

Columnas de tipo enum

Almacene los valores de un enum de Kotlin como cadenas u ordinales mediante enumerationByName() o enumeration():

enum class Status { ACTIVE, INACTIVE, BANNED }

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

Aplicación de cambios en el esquema

Llame a SchemaUtils.createMissingTablesAndColumns() para añadir las tablas y columnas que falten sin eliminar los datos existentes: es una migración segura para el desarrollo. En producción, use una herramienta de migración como Flyway o Liquibase.

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

Comprobación rápida

¿Cómo se declara en el DSL Table de Exposed una clave foránea de Posts.authorId a Users.id?

Resumen: definición de tablas con el DSL Table

Puntos clave:

Las tablas son objects que extienden Table, LongIdTable, etc.
Columnas: varchar, integer, long, bool, datetime, uuid, etc.
.nullable(), .default(), .uniqueIndex() y .references() modifican las columnas
Claves primarias compuestas: PrimaryKey(col1, col2)
Aplique el esquema con SchemaUtils.create() o createMissingTablesAndColumns()

Preguntas frecuentes

¿La lección «Definir tablas con el DSL Table» es gratis?

Sí — el texto completo de «Definir tablas con el DSL Table» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Definir tablas con el DSL Table»?

Defina esquemas de tablas tipados con columnas, claves primarias y claves foráneas. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Definir tablas con el DSL Table»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Configuración de Exposed: conexión a la base de datos y DSL de transacciones
Definir tablas con el DSL Table
CRUD con el DSL de consultas: insert, select, update y delete
DAO de Exposed: clases Entity y relaciones

← Volver a Kotlin Academy