Skip to content

Latest commit

 

History

History
186 lines (130 loc) · 4.48 KB

kotlin-support.rst

File metadata and controls

186 lines (130 loc) · 4.48 KB

Kotlin support

Doma supports Kotlin 1.4.0 or later.

Here are some recommended methods, such as defining classes and building them with Kotlin.

  • Define as a plain class
  • Specify a Metamodel annotation to the metamodel element of @Entity
@Entity(metamodel = Metamodel())
class Person : AbstractPerson() {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    var id: Int = -1

    var name: Name? = null

    var age: Int? = -1

    var address: Address? = null

    @Column(name = "DEPARTMENT_ID")
    var departmentId: Int = -1

    @Version
    var version: Int = -1
}
  • Define as a data class
  • Define only one constructor
  • Define only one property whose name is value in the constructor
  • Use val for the property definition
@Domain(valueType = String::class)
data class Name(val value: String)
  • Define as a data class
  • Define only one constructor
  • Define properties only in the constructor
  • Use val for the property definitions
@Embeddable
data class Address(val city: String, val street: String)
  • Specify a SQL template to @org.seasar.doma.Sql
@Dao
interface PersonDao {
  @Sql("""
  select * from person where id = /*id*/0
  """)
  @Select
  fun selectById(id: Int): Person

  @Insert
  fun insert(person: Person): Int
}
val dao: PersonDao = ...
val person = Person(name = Name("John"), address = Address(city = "Tokyo", street = "Yaesu"))
val count = dao.insert(person)

Note

Prefer the Kotlin specific Criteria API to DAO interfaces.

Doma provides Kotlin specific Criteria API, KEntityql and KNativeSql DSLs. They are very similar with the Entityql and NativeSql DSLs, which are described in :doc:`criteria-api`. The biggest feature of the KEntityql and KNativeSql DSLs is simplicity.

For example, when you use KEntityql, you have to accept a lambda parameter in a WHERE expression as follows:

val entityql = Entityql(config)
val e = Employee_()

val list = entityql
    .from(e)
    .where { c ->
        c.eq(e.departmentId, 2)
        c.isNotNull(e.managerId)
        c.or {
            c.gt(e.salary, Salary("1000"))
            c.lt(e.salary, Salary("2000"))
        }
    }
    .fetch()

The lambda parameter c is a bit annoying. On the other hand, when you use KEntityql, the parameter is gone.

val entityql = KEntityql(config)
val e = Employee_()

val list = entityql
    .from(e)
    .where {
        eq(e.departmentId, 2)
        isNotNull(e.managerId)
        or {
            gt(e.salary, Salary("1000"))
            lt(e.salary, Salary("2000"))
        }
    }
    .fetch()

You can see a lot of sample code here.

The KEntityql and KNativeSql DSLs are included in doma-kotlin.jar. Note that you should depend on doma-kotlin instead of doma-core in your build script. You can write build.gradle.kts as follows:

dependencies {
    implementation("org.seasar.doma:doma-kotlin:2.58.0")
}

Use :doc:`codegen`. This plugin support Kotlin code generation.

Annotation processors are supported in Kotlin with the kapt compiler plugin.

Add the dependencies using the kapt and implementation configuration in your dependencies block. For example, you can write build.gradle.kts as follows:

dependencies {
    kapt("org.seasar.doma:doma-processor:2.58.0")
    implementation("org.seasar.doma:doma-kotlin:2.58.0")
}

To simplify your build script, we recommend you use the Doma Compile Plugin: