Get started with Exposed's DAO API

1. In a terminal window, navigate to the destination where you want to create your project and run the following commands to create a new folder and change directory into it:

   mkdir exposed-dao-kotlin-app cd exposed-dao-kotlin-app

2. Run the gradle init task to initialize a new Gradle project:

   gradle init

   When prompted, select the following options:

   • 1: Application project type.

   • 2: Kotlin implementation language.

   For the other questions, press enter to use the default values. The output will look like the following:

   Select type of build to generate: 1: Application 2: Library 3: Gradle plugin 4: Basic (build structure only) Enter selection (default: Application) [1..4] Select implementation language: 1: Java 2: Kotlin 3: Groovy 4: Scala 5: C++ 6: Swift Enter selection (default: Java) [1..6] 2 Enter target Java version (min: 7, default: 21): Project name (default: exposed-kotlin-app): Select application structure: 1: Single application project 2: Application and library project Enter selection (default: Single application project) [1..2] Select build script DSL: 1: Kotlin 2: Groovy Enter selection (default: Kotlin) [1..2] Select test framework: 1: kotlin.test 2: JUnit Jupiter Enter selection (default: kotlin.test) [1..2] Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] > Task :init To learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.8/samples/sample_building_kotlin_applications.html BUILD SUCCESSFUL in 28s 1 actionable task: 1 executed

3. Once the project has been initialized, open the project folder in your IDE. To open the project in IntelliJ IDEA, use the following command:

   idea .

Before you start using Exposed, you need to add dependencies to your project.

1. Navigate to the gradle/libs.versions.toml file and define the Exposed and H2 versions and artifacts:

   [versions] //... exposed = "1.0.0-rc-3" h2 = "2.2.224" [libraries] //... exposed-core = { module = "org.jetbrains.exposed:exposed-core", version.ref = "exposed" } exposed-dao = { module = "org.jetbrains.exposed:exposed-dao", version.ref = "exposed" } exposed-jdbc = { module = "org.jetbrains.exposed:exposed-jdbc", version.ref = "exposed" } h2 = { module = "com.h2database:h2", version.ref = "h2" }

   • The exposed-core module provides the foundational components and abstractions needed to work with databases in a type-safe manner and includes the DSL API.

   • The exposed-dao module allows you to work with the Data Access Object (DAO) API.

   • The exposed-jdbc module is an extension of the exposed-core module that adds support for Java Database Connectivity (JDBC).

2. Navigate to the app/build.gradle.kts file and add the Exposed and H2 database modules into the dependencies block:

   dependencies { //... implementation(libs.exposed.core) implementation(libs.exposed.dao) implementation(libs.exposed.jdbc) implementation(libs.h2) //... }

3. In intelliJ IDEA, click on the notification Gradle icon () on the right side of the editor to load Gradle changes.

1. Navigate to app/src/main/kotlin/org/example/ and open the App.kt file.

2. Replace the contents of the App.kt file with the following implementation:

   package org.example import org.jetbrains.exposed.v1.jdbc.Database fun main() { Database.connect("jdbc:h2:mem:test", driver = "org.h2.Driver") }

   The Database.connect() function creates an instance of a class that represents the database and takes two or more parameters. In this case, the connection URL and the driver.

   • jdbc:h2:mem:test is the database URL to connect to:

     • jdbc specifies that this is a JDBC connection.

     • h2 indicates that the database is an H2 database.

     • mem specifies that the database is in-memory, meaning the data will only exist in memory and will be lost when the application stops.

     • test is the name of the database.

   • org.h2.Driver specifies the H2 JDBC driver to be used for establishing the connection.

1. In the app/src/main/kotlin/org/example/ folder, create a new Task.kt file.

2. Open Task.kt and add the following table definition:

   package org.example import org.jetbrains.exposed.v1.core.dao.id.IntIdTable object Tasks : IntIdTable("tasks") { val title = varchar("name", 128) val description = varchar("description", 128) val isCompleted = bool("completed").default(false) }

   In the IntIdTable constructor, passing the name tasks configures a custom name for the table. If you don't provide a name, Exposed will derive it from the object name, which may lead to unexpected results depending on naming conventions.

   The Tasks object defines the following columns:

   • title and description are String columns, created using the varchar() function. Each column has a maximum length of 128 characters.

   • isCompleted is a Boolean column, defined using the bool() function. Using the default(false) call, you configure the default value to false.

   The IntIdTable class automatically adds an auto-incrementing integer id column as the primary key for the table. At this point, you have defined a table with columns, which essentially creates the blueprint for the tasks table.

1. In the same transaction() function, add the following code to your implementation:

   transaction { // ... // Update task1.title = "Try Exposed DAO" task1.isCompleted = true println("Updated task1: $task1") // Delete task2.delete() println("Remaining tasks: ${Task.all().toList()}") }

   You update the value of a property just as you would with any property in a Kotlin class:

   task1.title = "Try Exposed DAO" task1.isCompleted = true

   Similarly, to delete a task, you use the .delete() method on the entity:

   task2.delete()

2. In IntelliJ IDEA, click the rerun button () to restart the application.

   You should now see the following result:

   SQL: SELECT SETTING_VALUE FROM INFORMATION_SCHEMA.SETTINGS WHERE SETTING_NAME = 'MODE' SQL: CREATE TABLE IF NOT EXISTS TASKS (ID INT AUTO_INCREMENT PRIMARY KEY, "name" VARCHAR(128) NOT NULL, DESCRIPTION VARCHAR(128) NOT NULL, COMPLETED BOOLEAN DEFAULT FALSE NOT NULL) SQL: INSERT INTO TASKS ("name", DESCRIPTION, COMPLETED) VALUES ('Learn Exposed DAO', 'Follow the DAO tutorial', FALSE) SQL: INSERT INTO TASKS ("name", DESCRIPTION, COMPLETED) VALUES ('Read The Hobbit', 'Read chapter one', TRUE) Created new tasks with ids 1 and 2 SQL: SELECT TASKS.ID, TASKS."name", TASKS.DESCRIPTION, TASKS.COMPLETED FROM TASKS WHERE TASKS.COMPLETED = TRUE Completed tasks: 1 Updated task1: Task(id=1, title=Try Exposed DAO, completed=true) SQL: UPDATE TASKS SET COMPLETED=TRUE, "name"='Try Exposed DAO' WHERE ID = 1 SQL: DELETE FROM TASKS WHERE TASKS.ID = 2 SQL: SELECT TASKS.ID, TASKS."name", TASKS.DESCRIPTION, TASKS.COMPLETED FROM TASKS Remaining tasks: [Task(id=1, title=Try Exposed DAO, completed=true)]