This document summarizes 7 things you may not know about Exposed, a SQL query builder and ORM for Kotlin. It covers topics like logging queries, date support, many-to-many relationships, coroutine support, representing NULL values, mapping between SQL DSL and DAO entities, and executing arbitrary SQL statements. It also provides information on where to find help or contribute to the Exposed project.

1. 7±2 things you didn’t
know about Exposed
Alexey Soshin, November 2022

2. vs

3. Selecting using criteria with an annotation

4. Selecting using criteria with an annotation
Deleting using conventions

5. UsersTable
.select { UsersTable.firstName eq firstName }
.toList()
Selecting using criteria: SQL DSL
val count: Int = UsersTable
.deleteWhere { UsersTable.lastName eq lastName }
Deleting: SQL DSL

6. val users = User.find {
UsersTable.firstName eq firstName
}.toList()
Selecting using criteria: DAO API
users.forEach {
it.delete()
}
Deleting: DAO API

7. Logging
transaction {
addLogger(StdOutSqlLogger)
UsersTable
.select { UsersTable.firstName eq firstName
}
.toList()
}

8. Logging
SQL: SELECT users.id, users.first_name,
users.last_name FROM users WHERE users.first_name =
'Alexey'
transaction {
addLogger(StdOutSqlLogger)
UsersTable
.select { UsersTable.firstName eq firstName
}
.toList()
}

9. Logging
val sql = UsersTable
.select { UsersTable.firstName eq firstName }
.prepareSQL(this)
println(sql)
SELECT users.id, users.first_name, users.last_name
FROM users WHERE users.first_name = ?

10. Date support
object UsersTable : IntIdTable() {
val firstName = varchar("first_name", 20)
val lastName = varchar("last_name", 20)
val createdAt = datetime("created_at")
}

11. Date support
// JDK 7, legacy
"org.jetbrains.exposed:exposed-jodatime"
// JDK 8+
"org.jetbrains.exposed:exposed-java-time"
// Kotlin
"org.jetbrains.exposed:exposed-kotlin-datetime"

12. Many–to-many relationship

13. Many–to-many relationship
object Members : UUIDTable() {
val user = reference("user_id", Users, onDelete =
ReferenceOption.CASCADE)
val group = reference("group_id", Groups, onDelete =
ReferenceOption.CASCADE)
val createdAt =
datetime("created_at").defaultExpression(CurrentDateTime)
}

14. Many–to-many relationship
class Group(id: EntityID<UUID>) : UUIDEntity(id) {
companion object : UUIDEntityClass<Group>(Groups)
var name by Groups.name
var description by Groups.description
var owner by User referencedOn Groups.owner
val members by User.via(Members.group, Members.user)
}

15. Many–to-many relationship
class User(id: EntityID<UUID>) : UUIDEntity(id) {
companion object : UUIDEntityClass<User>(Users)
var username by Users.username
val groups by Group.via(Members.user, Members.group)
}

16. Coroutines support
suspend fun doSomeIO() {
delay(10L)
}
transaction {
doSomeIO()
}

17. Coroutines support
newSuspendedTransaction {
doSomeIO()
}
👍
newSuspendedTransaction {
// Nesting suspended transactions
suspendedTransaction {
doSomeIO()
}
doSomeIO() // Failure here will rollback everything
}

18. Coroutines support
🤔
newSuspendedTransaction {
// Nesting suspended transactions
newSuspendedTransaction {
doSomeIO()
}
doSomeIO() // Failure here won’t rollback everything!
}

19. Null expression
SELECT COUNT(CASE
WHEN messages.seen = 'NO' THEN NULL
ELSE 1 END)
FROM messages

20. Null expression
SELECT COUNT(CASE
WHEN messages.seen = 'NO' THEN NULL
ELSE 1 END)
FROM messages
Messages.slice(
Count(
case()
.When(seen eq "NO", "NULL"/null)
.Else(intLiteral(1))
)
).selectAll().toList()

21. Null expression
SELECT COUNT(CASE
WHEN messages.seen = 'NO' THEN NULL
ELSE 1 END)
FROM messages
Messages.slice(
Count(
case()
.When(seen eq "NO", Op.nullOp<Int>())
.Else(intLiteral(1))
)
).selectAll().toList()

22. Null expression
SELECT COUNT(CASE
WHEN messages.seen = 'YES' THEN 1
ELSE NULL END)
FROM messages
Messages.slice(
Count(
case()
.When(seen eq "YES", intLiteral(1))
.Else(Op.nullOp())
)
).selectAll().toList()

23. From SQL DSL to DAO Entities
val query: Query = Groups
.innerJoin(Users)
.innerJoin(Members)
.slice(Groups.columns)
.selectAll()
.withDistinct()
🤔

24. From SQL DSL to DAO Entities
val groups: SizedIterable<Group> =
Group.wrapRows(query)
val query: Query = Groups
.innerJoin(Users)
.innerJoin(Members)
.slice(Groups.columns)
.selectAll()
.withDistinct()

25. Breaking the rules
exec("select * from users") { rs ->
while (rs.next()) {
// Not zero based!
println(rs.getString(1))
}
}

26. Summary
1. Log a single query
2. Choose what date library to work with
3. Flexible support for many-to-many relationship
4. Coroutine support
5. Expression that represents SQL NULL
6. Easy mapping from SQL DSL to DAO Entities
7. Arbitrary statements

27. Questions and contributions
Questions:
stackoverflow.com/questions/tagged/kotlin-exposed
Bugs:
github.com/JetBrains/Exposed/issues
PRs are welcome!
github.com/JetBrains/Exposed/pulls

28. Video course on Exposed in making
Out in January 2023

29. Let’s stay in touch!
www.linkedin.com/in/alexeysoshin
alexey-soshin.medium.com
twitter.com/alexey_soshin
Coupon: KOTLINDEVDAY2022

30. Glory to Ukraine!
🇺🇦