JPQL with Kotlin JDSL

Requirements

At least Java 8 and Kotlin 1.7 are required to build and run an application with Kotlin JDSL.

Configure the repositories

Before adding Kotlin JDSL dependencies, you need to configure the repositories for this project:

Release

Releases of Kotlin JDSL are available in the Maven central repository. You can declare this repository in your build script as follows:

Gradle (Kotlin)

repositories {
    mavenCentral()
}

Gradle (Groovy)

repositories {
    mavenCentral()
}

Maven

You don't need to add the Maven central repository in the pom.xml file since your project inherits the central repository from Super POM.

Snapshot

Declare the OSS snapshot repository to get access to snapshots of Kotlin JDSL:

Gradle (Kotlin)

repositories {
    maven(url = "https://oss.sonatype.org/content/repositories/snapshots")
}

Gradle (Groovy)

repositories {
    maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
}

Maven

<repositories>
    <repository>
        <id>oss.sonatype.org-snapshot</id>
        <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
    </repository>
</repositories>

Add Kotlin JDSL dependencies

Core dependencies

The following dependencies are the minimum requirement for all Kotlin JDSL applications:

• jpql-dsl: Contain a DSL to build a JPQL query

• jpql-render: Render the JPQL query created with the DSL as String

Gradle (Kotlin)

dependencies {
    implementation("com.linecorp.kotlin-jdsl:jpql-dsl:3.5.4")
    implementation("com.linecorp.kotlin-jdsl:jpql-render:3.5.4")
}

Gradle (Groovy)

dependencies {
    implementation 'com.linecorp.kotlin-jdsl:jpql-dsl:3.5.4'
    implementation 'com.linecorp.kotlin-jdsl:jpql-render:3.5.4'
}

Maven

<dependencies>
    <dependency>
        <groupId>com.linecorp.kotlin-jdsl</groupId>
        <artifactId>jpql-dsl</artifactId>
        <version>3.5.4</version>
    </dependency>
    <dependency>
        <groupId>com.linecorp.kotlin-jdsl</groupId>
        <artifactId>jpql-render</artifactId>
        <version>3.5.4</version>
    </dependency>
</dependencies>

Support dependencies

Add the Support dependencies to execute the query created with the DSL. For each JPA provider, Kotlin JDSL provides the following dependencies:

• hibernate-support: Assist to execute the query with Hibernate

• eclipselink-support: Assist to execute the query with EclipseLink

• spring-batch-support: Assist to execute the query with Spring Batch

• spring-data-jpa-support: Assist to execute the query with Spring Data JPA

• hibernate-reactive-support: Assist to execute the query with Hibernate Reactive

Javax

For the javax, Kotlin JDSL also provides the following dependencies:

• hibernate-javax-support: Assist to execute the query with Hibernate

• eclipselink-javax-support: Assist to execute the query with EclipseLink

• spring-batch-javax-support: Assist to execute the query with Spring Batch.

• spring-data-jpa-javax-support: Assist to execute the query with Spring Data JPA.

• hibernate-reactive-javax-support: Assist to execute the query with Hibernate Reactive

Build a query

You can call select() in jpql() to build a select statement:

val query = jpql {
    select(
        path(Author::authorId),
    ).from(
        entity(Author::class)
    )
}

Similarly, Kotlin JDSL provides functions for all the other statements: update statement, and delete statement. You can also see more examples on GitHub.

In addition, you can also create your own custom DSL

Execute the query

After building the query, you can use RenderContext to execute the query. For example, you can use JpqlRenderContext to execute the query:

val context = JpqlRenderContext()

val renderer = JpqlRenderer()

val rendered = renderer.render(query, context)

val jpaQuery: Query = entityManager.createQuery(rendered.query).apply {
    rendered.params.forEach { (name, value) ->
        setParameter(name, value)
    }
}

val result = jpaQuery.resultList

RenderContext has elements for rendering the query as String. Kotlin JDSL provides JpqlRenderContext as the default RenderContext for the JPQL.

JpqlRenderer renders the query as String using the RenderContext. This returns JpqlRendered, which has the query rendered as String and the parameters contained in the query. This has no state, so you can reuse the object of this and access it from multiple threads.

Creating RenderContext is expensive, so the Kotlin JDSL recommends creating it once and reusing it afterward. Since RenderContext is immutable, you can access RenderContext from multiple threads.

Kotlin JDSL Support provides extension functions for EntityManager to simplify the above process. Using them, you can execute queries as simple as:

val context = JpqlRenderContext()

val jpaQuery: Query = entityManager.createQuery(query, context)

val result = jpaQuery.resultList