ORM for Kotlin: Exposed vs Ktor vs Ktorm — Comparison and Examples

ORM for Kotlin: Comparison and Examples

Kotlin is a modern language actively used for developing backend applications, Android apps, and even cross-platform projects. To work with databases, developers often choose ORM (Object-Relational Mapping) to avoid writing raw SQL queries and speed up development. In this article, we will look at three popular ORM tools for Kotlin: Exposed, Ktor (in conjunction with Exposed), and Ktorm. We will compare their syntax, performance, and ease of use with practical examples.

1. Exposed — Official ORM from JetBrains

Exposed is an ORM library developed by JetBrains specifically for Kotlin. It supports two approaches: DSL (Domain Specific Language) and DAO (Data Access Objects). Exposed integrates perfectly with the Ktor framework but can also be used standalone.

Key Features:

• Lightweight and intuitive DSL syntax.
• Support for transactions, migrations, and connections.
• Works with PostgreSQL, MySQL, H2, SQLite, and other databases.
• Active community and official documentation.

Code Example (DSL approach):

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

// Table definitionobject Users : Table() {    val id = integer("id").autoIncrement()    val name = varchar("name", 50)    val age = integer("age")

    override val primaryKey = PrimaryKey(id)}

// Query examplefun main() {    Database.connect("jdbc:h2:mem:test", driver = "org.h2.Driver")

    transaction {        SchemaUtils.create(Users)

        // Insert        Users.insert {            it[name] = "Alice"            it[age] = 30        }

        // Select        val result = Users.selectAll().where { Users.age greater 25 }        result.forEach {            println("${it[Users.name]}: ${it[Users.age]}")        }    }}

2. Ktor + Exposed — A Pair for Web Applications

Ktor is an asynchronous web framework for Kotlin. Although Ktor itself does not provide a built-in ORM, it works excellently in tandem with Exposed. This combination allows you to create REST APIs with minimal code.

Example of Ktor Integration with Exposed:

import io.ktor.server.application.*import io.ktor.server.routing.*import io.ktor.server.response.*import org.jetbrains.exposed.sql.*import org.jetbrains.exposed.sql.transactions.transaction

fun Application.module() {    Database.connect("jdbc:h2:mem:test", driver = "org.h2.Driver")

    routing {        get("/users") {            val users = transaction {                Users.selectAll().map {                    mapOf("name" to it[Users.name], "age" to it[Users.age])                }            }            call.respond(users)        }    }}

This approach is suitable for microservices and small projects where simplicity and development speed are important.

3. Ktorm — Lightweight and Performant ORM

Ktorm is another popular ORM for Kotlin, focused on performance and minimalism. It uses functional programming and supports both DSL and SQL-like syntax.

Key Features:

• High performance due to the absence of reflection.
• Support for extensions (e.g., for JSON fields).
• Simple configuration and minimal dependencies.
• Works with most popular DBMS.

Ktorm Code Example:

import me.liuwj.ktorm.database.Databaseimport me.liuwj.ktorm.dsl.*import me.liuwj.ktorm.entity.*

// Entity definitioninterface User : Entity {    compan