feat: add selectFrom spec

line · Oct 4, 2024 · 8f29c10 · 8f29c10
1 parent 565e71b
commit 8f29c10
Show file tree

Hide file tree

Showing 16 changed files with 361 additions and 0 deletions.
diff --git a/dsl/jpql/src/main/kotlin/com/linecorp/kotlinjdsl/dsl/jpql/Jpql.kt b/dsl/jpql/src/main/kotlin/com/linecorp/kotlinjdsl/dsl/jpql/Jpql.kt
@@ -19,6 +19,7 @@ import com.linecorp.kotlinjdsl.dsl.jpql.join.impl.AssociationJoinDsl
 import com.linecorp.kotlinjdsl.dsl.jpql.join.impl.FetchJoinDsl
 import com.linecorp.kotlinjdsl.dsl.jpql.join.impl.JoinDsl
 import com.linecorp.kotlinjdsl.dsl.jpql.select.SelectQueryFromStep
+import com.linecorp.kotlinjdsl.dsl.jpql.select.SelectQueryWhereStep
 import com.linecorp.kotlinjdsl.dsl.jpql.select.impl.SelectQueryFromStepDsl
 import com.linecorp.kotlinjdsl.dsl.jpql.sort.SortNullsStep
 import com.linecorp.kotlinjdsl.dsl.jpql.sort.impl.SortDsl
@@ -33,6 +34,7 @@ import com.linecorp.kotlinjdsl.querymodel.jpql.expression.Expression
 import com.linecorp.kotlinjdsl.querymodel.jpql.expression.Expressionable
 import com.linecorp.kotlinjdsl.querymodel.jpql.expression.Expressions
 import com.linecorp.kotlinjdsl.querymodel.jpql.expression.Subquery
+import com.linecorp.kotlinjdsl.querymodel.jpql.from.Fromable
 import com.linecorp.kotlinjdsl.querymodel.jpql.join.JoinType
 import com.linecorp.kotlinjdsl.querymodel.jpql.path.Path
 import com.linecorp.kotlinjdsl.querymodel.jpql.path.Pathable
@@ -3119,6 +3121,18 @@ open class Jpql : JpqlDsl {
         )
     }
 
+    /**
+     * Creates a select clause in a select from query.
+     */
+    @SinceJdsl("3.5.3")
+    inline fun <reified T : Any> selectFrom(
+        expr: Entityable<T>,
+        vararg froms: Fromable?,
+    ): SelectQueryWhereStep<T> {
+        return select(expr)
+            .from(expr, *froms)
+    }
+
     /**
      * Creates a select clause in a select query.
      */

diff --git a/dsl/jpql/src/test/kotlin/com/linecorp/kotlinjdsl/dsl/jpql/select/FromDslTest.kt b/dsl/jpql/src/test/kotlin/com/linecorp/kotlinjdsl/dsl/jpql/select/FromDslTest.kt
@@ -88,4 +88,59 @@ class FromDslTest : WithAssertions {
 
         assertThat(actual).isEqualTo(expected)
     }
+
+    @Test
+    fun `selectFrom() with entity`() {
+        // when
+        val selectFrom = queryPart {
+            selectFrom(
+                entity1,
+            )
+        }.toQuery()
+        val actual: SelectQuery<Book> = selectFrom
+
+        // then
+        val expected = SelectQueries.selectQuery(
+            returnType = Book::class,
+            distinct = false,
+            select = listOf(entity1),
+            from = listOf(
+                entity1,
+            ),
+        )
+
+        assertThat(actual).isEqualTo(expected)
+    }
+
+    @Test
+    fun `selectFrom() with froms`() {
+        // when
+        val selectFrom = queryPart {
+            selectFrom(
+                entity1,
+                null,
+                entity2,
+                null,
+                join1,
+                null,
+                join2,
+            )
+        }.toQuery()
+        val actual: SelectQuery<Book> = selectFrom
+
+        // then
+        val expected = SelectQueries.selectQuery(
+            returnType = Book::class,
+            distinct = false,
+            select = listOf(entity1),
+            from = listOf(
+                entity1,
+                entity2,
+                join1,
+                join2,
+            ),
+        )
+
+        assertThat(actual).isEqualTo(expected)
+    }
 }
diff --git a/...src/test/kotlin/com/linecorp/kotlinjdsl/example/eclipselink/javax/select/SelectExample.kt b/...src/test/kotlin/com/linecorp/kotlinjdsl/example/eclipselink/javax/select/SelectExample.kt
@@ -70,6 +70,26 @@ class SelectExample : WithAssertions {
         assertThat(actual).isEqualTo(listOf(4L))
     }
 
+    @Test
+    fun `authors who haven't written a book with selectFrom`() {
+        // when
+        val query = jpql {
+            selectFrom(
+                entity(Author::class),
+                leftJoin(BookAuthor::class).on(path(Author::authorId).equal(path(BookAuthor::authorId))),
+            ).where(
+                path(BookAuthor::authorId).isNull(),
+            ).orderBy(
+                path(Author::authorId).asc(),
+            )
+        }
+
+        val actual = entityManager.createQuery(query, context).resultList
+
+        // then
+        assertThat(actual.map { it.authorId }).isEqualTo(listOf(4L))
+    }
+
     @Test
     fun `the book with the most authors`() {
         // when

diff --git a/...elink/src/test/kotlin/com/linecorp/kotlinjdsl/example/eclipselink/select/SelectExample.kt b/...elink/src/test/kotlin/com/linecorp/kotlinjdsl/example/eclipselink/select/SelectExample.kt
@@ -70,6 +70,26 @@ class SelectExample : WithAssertions {
         assertThat(actual).isEqualTo(listOf(4L))
     }
 
+    @Test
+    fun `authors who haven't written a book with selectFrom`() {
+        // when
+        val query = jpql {
+            selectFrom(
+                entity(Author::class),
+                leftJoin(BookAuthor::class).on(path(Author::authorId).equal(path(BookAuthor::authorId))),
+            ).where(
+                path(BookAuthor::authorId).isNull(),
+            ).orderBy(
+                path(Author::authorId).asc(),
+            )
+        }
+
+        val actual = entityManager.createQuery(query, context).resultList
+
+        // then
+        assertThat(actual.map { it.authorId }).isEqualTo(listOf(4L))
+    }
+
     @Test
     fun `the book with the most authors`() {
         // when

diff --git a/.../test/kotlin/com/linecorp/kotlinjdsl/example/jpql/hibernate/javax/select/SelectExample.kt b/.../test/kotlin/com/linecorp/kotlinjdsl/example/jpql/hibernate/javax/select/SelectExample.kt
@@ -71,6 +71,26 @@ class SelectExample : WithAssertions {
         assertThat(actual).isEqualTo(listOf(4L))
     }
 
+    @Test
+    fun `authors who haven't written a book with selectFrom`() {
+        // when
+        val query = jpql {
+            selectFrom(
+                entity(Author::class),
+                leftJoin(BookAuthor::class).on(path(Author::authorId).equal(path(BookAuthor::authorId))),
+            ).where(
+                path(BookAuthor::authorId).isNull(),
+            ).orderBy(
+                path(Author::authorId).asc(),
+            )
+        }
+
+        val actual = entityManager.createQuery(query, context).resultList
+
+        // then
+        assertThat(actual.map { it.authorId }).isEqualTo(listOf(4L))
+    }
+
     @Test
     fun books() {
         // when

diff --git a/...orp/kotlinjdsl/example/hibernate/reactive/javax/jpql/select/SelectMutinySessionExample.kt b/...orp/kotlinjdsl/example/hibernate/reactive/javax/jpql/select/SelectMutinySessionExample.kt
@@ -68,6 +68,28 @@ class SelectMutinySessionExample : WithAssertions {
         assertThat(actual).isEqualTo(listOf(4L))
     }
 
+    @Test
+    fun `authors who haven't written a book with selectFrom`() {
+        // when
+        val query = jpql {
+            selectFrom(
+                entity(Author::class),
+                leftJoin(BookAuthor::class).on(path(Author::authorId).equal(path(BookAuthor::authorId))),
+            ).where(
+                path(BookAuthor::authorId).isNull(),
+            ).orderBy(
+                path(Author::authorId).asc(),
+            )
+        }
+
+        val actual = sessionFactory.withSession {
+            it.createQuery(query, context).resultList
+        }.await().indefinitely()
+
+        // then
+        assertThat(actual.map { it.authorId }).isEqualTo(listOf(4L))
+    }
+
     @Test
     fun `the book with the most authors`() {
         // when

diff --git a/...njdsl/example/hibernate/reactive/javax/jpql/select/SelectMutinyStatelessSessionExample.kt b/...njdsl/example/hibernate/reactive/javax/jpql/select/SelectMutinyStatelessSessionExample.kt
@@ -68,6 +68,28 @@ class SelectMutinyStatelessSessionExample : WithAssertions {
         assertThat(actual).isEqualTo(listOf(4L))
     }
 
+    @Test
+    fun `authors who haven't written a book with selectFrom`() {
+        // when
+        val query = jpql {
+            selectFrom(
+                entity(Author::class),
+                leftJoin(BookAuthor::class).on(path(Author::authorId).equal(path(BookAuthor::authorId))),
+            ).where(
+                path(BookAuthor::authorId).isNull(),
+            ).orderBy(
+                path(Author::authorId).asc(),
+            )
+        }
+
+        val actual = sessionFactory.withStatelessSession {
+            it.createQuery(query, context).resultList
+        }.await().indefinitely()
+
+        // then
+        assertThat(actual.map { it.authorId }).isEqualTo(listOf(4L))
+    }
+
     @Test
     fun `the book with the most authors`() {
         // when

diff --git a/...corp/kotlinjdsl/example/hibernate/reactive/javax/jpql/select/SelectStageSessionExample.kt b/...corp/kotlinjdsl/example/hibernate/reactive/javax/jpql/select/SelectStageSessionExample.kt
@@ -68,6 +68,28 @@ class SelectStageSessionExample : WithAssertions {
         assertThat(actual).isEqualTo(listOf(4L))
     }
 
+    @Test
+    fun `authors who haven't written a book with selectFrom`() {
+        // when
+        val query = jpql {
+            selectFrom(
+                entity(Author::class),
+                leftJoin(BookAuthor::class).on(path(Author::authorId).equal(path(BookAuthor::authorId))),
+            ).where(
+                path(BookAuthor::authorId).isNull(),
+            ).orderBy(
+                path(Author::authorId).asc(),
+            )
+        }
+
+        val actual = sessionFactory.withSession {
+            it.createQuery(query, context).resultList
+        }.toCompletableFuture().get()
+
+        // then
+        assertThat(actual.map { it.authorId }).isEqualTo(listOf(4L))
+    }
+
     @Test
     fun `the book with the most authors`() {
         // when

diff --git a/...injdsl/example/hibernate/reactive/javax/jpql/select/SelectStageStatelessSessionExample.kt b/...injdsl/example/hibernate/reactive/javax/jpql/select/SelectStageStatelessSessionExample.kt
@@ -68,6 +68,28 @@ class SelectStageStatelessSessionExample : WithAssertions {
         assertThat(actual).isEqualTo(listOf(4L))
     }
 
+    @Test
+    fun `authors who haven't written a book with selectFrom`() {
+        // when
+        val query = jpql {
+            selectFrom(
+                entity(Author::class),
+                leftJoin(BookAuthor::class).on(path(Author::authorId).equal(path(BookAuthor::authorId))),
+            ).where(
+                path(BookAuthor::authorId).isNull(),
+            ).orderBy(
+                path(Author::authorId).asc(),
+            )
+        }
+
+        val actual = sessionFactory.withStatelessSession {
+            it.createQuery(query, context).resultList
+        }.toCompletableFuture().get()
+
+        // then
+        assertThat(actual.map { it.authorId }).isEqualTo(listOf(4L))
+    }
+
     @Test
     fun `the book with the most authors`() {
         // when

diff --git a/...p/kotlinjdsl/example/hibernate/reactive/jakarta/jpql/select/SelectMutinySessionExample.kt b/...p/kotlinjdsl/example/hibernate/reactive/jakarta/jpql/select/SelectMutinySessionExample.kt
@@ -68,6 +68,28 @@ class SelectMutinySessionExample : WithAssertions {
         assertThat(actual).isEqualTo(listOf(4L))
     }
 
+    @Test
+    fun `authors who haven't written a book with selectFrom`() {
+        // when
+        val query = jpql {
+            selectFrom(
+                entity(Author::class),
+                leftJoin(BookAuthor::class).on(path(Author::authorId).equal(path(BookAuthor::authorId))),
+            ).where(
+                path(BookAuthor::authorId).isNull(),
+            ).orderBy(
+                path(Author::authorId).asc(),
+            )
+        }
+
+        val actual = sessionFactory.withSession {
+            it.createQuery(query, context).resultList
+        }.await().indefinitely()
+
+        // then
+        assertThat(actual.map { it.authorId }).isEqualTo(listOf(4L))
+    }
+
     @Test
     fun `the book with the most authors`() {
         // when

diff --git a/...dsl/example/hibernate/reactive/jakarta/jpql/select/SelectMutinyStatelessSessionExample.kt b/...dsl/example/hibernate/reactive/jakarta/jpql/select/SelectMutinyStatelessSessionExample.kt
@@ -68,6 +68,28 @@ class SelectMutinyStatelessSessionExample : WithAssertions {
         assertThat(actual).isEqualTo(listOf(4L))
     }
 
+    @Test
+    fun `authors who haven't written a book with selectFrom`() {
+        // when
+        val query = jpql {
+            selectFrom(
+                entity(Author::class),
+                leftJoin(BookAuthor::class).on(path(Author::authorId).equal(path(BookAuthor::authorId))),
+            ).where(
+                path(BookAuthor::authorId).isNull(),
+            ).orderBy(
+                path(Author::authorId).asc(),
+            )
+        }
+
+        val actual = sessionFactory.withStatelessSession {
+            it.createQuery(query, context).resultList
+        }.await().indefinitely()
+
+        // then
+        assertThat(actual.map { it.authorId }).isEqualTo(listOf(4L))
+    }
+
     @Test
     fun `the book with the most authors`() {
         // when

diff --git a/...rp/kotlinjdsl/example/hibernate/reactive/jakarta/jpql/select/SelectStageSessionExample.kt b/...rp/kotlinjdsl/example/hibernate/reactive/jakarta/jpql/select/SelectStageSessionExample.kt
@@ -68,6 +68,28 @@ class SelectStageSessionExample : WithAssertions {
         assertThat(actual).isEqualTo(listOf(4L))
     }
 
+    @Test
+    fun `authors who haven't written a book with selectFrom`() {
+        // when
+        val query = jpql {
+            selectFrom(
+                entity(Author::class),
+                leftJoin(BookAuthor::class).on(path(Author::authorId).equal(path(BookAuthor::authorId))),
+            ).where(
+                path(BookAuthor::authorId).isNull(),
+            ).orderBy(
+                path(Author::authorId).asc(),
+            )
+        }
+
+        val actual = sessionFactory.withSession {
+            it.createQuery(query, context).resultList
+        }.toCompletableFuture().get()
+
+        // then
+        assertThat(actual.map { it.authorId }).isEqualTo(listOf(4L))
+    }
+
     @Test
     fun `the book with the most authors`() {
         // when