Trabajo con bases de datos en Kotlin: PostgreSQL y MongoDB

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Introducción: ¿Por qué Kotlin para trabajar con bases de datos?

Kotlin es un lenguaje moderno de tipado estático que es totalmente compatible con Java y se utiliza activamente para crear aplicaciones backend. Gracias a su sintaxis concisa, seguridad contra nulos y herramientas potentes, Kotlin es ideal para trabajar con bases de datos relacionales (PostgreSQL) y orientadas a documentos (MongoDB). En este artículo, analizaremos ejemplos prácticos de conexión, realización de operaciones CRUD y optimización de consultas.

Veremos dos bibliotecas populares: Exposed (para PostgreSQL) y KMongo (para MongoDB). Aprenderá a configurar el entorno, escribir consultas eficientes y evitar errores comunes.

1. Trabajando con PostgreSQL a través de Exposed

Exposed es una biblioteca ORM para Kotlin que proporciona dos API: DSL (Domain-Specific Language) para escribir consultas en estilo SQL y DAO (Data Access Object) para un enfoque orientado a objetos. Veamos ambas opciones.

1.1. Conexión y configuración

Agregue dependencias a build.gradle.kts:

dependencies {    implementation("org.jetbrains.exposed:exposed-core:0.41.1")    implementation("org.jetbrains.exposed:exposed-dao:0.41.1")    implementation("org.jetbrains.exposed:exposed-jdbc:0.41.1")    implementation("org.postgresql:postgresql:42.5.0")}

Conectando a la base de datos:

import org.jetbrains.exposed.sql.Databaseimport org.jetbrains.exposed.sql.transactions.transaction

fun main() {    Database.connect(        url = "jdbc:postgresql://localhost:5432/mydb",        driver = "org.postgresql.Driver",        user = "user",        password = "password"    )    println("Conexión a PostgreSQL establecida")}

1.2. Creación de una tabla y operaciones CRUD (DSL)

Definamos la tabla Users:

import org.jetbrains.exposed.sql.Tableimport org.jetbrains.exposed.sql.insertimport org.jetbrains.exposed.sql.selectAllimport org.jetbrains.exposed.sql.update

object Users : Table() {    val id = integer("id").autoIncrement()    val name = varchar("name", 50)    val email = varchar("email", 100).uniqueIndex()    override val primaryKey = PrimaryKey(id)}

Realicemos operaciones CRUD:

transaction {    // Creando una tabla    SchemaUtils.create(Users)

    // INSERT    Users.insert {        it[name] = "Alexey"        it[email] = "alex@example.com"    }

    // SELECT    val users = Users.selectAll().map {        "${it[Users.id]}: ${it[Users.name]} (${it[Users.email]})"    }    println(users)

    // UPDATE    Users.update({ Users.id eq 1 }) {        it[name] = "Alexey Ivanov"    }

    // DELETE (usando deleteWhere)    Users.deleteWhere { Users.id eq 2 }}

1.3. Enfoque DAO

Creemos una entidad y una clase DAO:

import org.jetbrains.exposed.dao.IntEntityimport org.jetbrains.exposed.dao.IntEntityClassimport org.jetbrains.exposed.dao.id.EntityIDimport org.jetbrains.exposed.dao.id.IntIdTable

object UsersDAO : IntIdTable() {    val name = varchar("name", 50)    val email = varchar("email", 100)}

class User(id: EntityID<Int>) : IntEntity(id) {    companion object : IntEntityClass<User>(UsersDAO)    var name by UsersDAO.name    var email by UsersDAO.email}

// Usotransaction {    val newUser = User.new {        name = "Maria"        email = "maria@example.com"    }    println("Usuario creado con ID: ${newUser.id.value}")}

2. Trabajando con MongoDB a través de KMongo

KMongo es un controlador orientado a corrutinas para MongoDB, construido sobre el controlador oficial de Java. Admite serialización a través de kotlinx.serialization y Jackson.