Skip to content

Commit f728a2b

Browse files
shouwnshouwn
committed
Merge branch 'main' into develop
2 parents 1cff1e5 + 4370785 commit f728a2b

File tree

2 files changed

+268
-0
lines changed
  • dsl/jpql/src
    • main/kotlin/com/linecorp/kotlinjdsl/dsl/jpql
    • test/kotlin/com/linecorp/kotlinjdsl/dsl/jpql/select

2 files changed

+268
-0
lines changed

‎dsl/jpql/src/main/kotlin/com/linecorp/kotlinjdsl/dsl/jpql/Jpql.kt

+104
Original file line numberDiff line numberDiff line change
@@ -3105,6 +3105,21 @@ open class Jpql : JpqlDsl {
31053105
return SortDsl(this.toExpression(), Sort.Order.DESC)
31063106
}
31073107

3108+
/**
3109+
* Creates a select clause in a select query.
3110+
*/
3111+
@SinceJdsl("3.5.5")
3112+
fun <T : Any> select(
3113+
type: KClass<T>,
3114+
expr: Expressionable<T>,
3115+
): SelectQueryFromStep<T> {
3116+
return SelectQueryFromStepDsl(
3117+
type,
3118+
distinct = false,
3119+
listOf(expr.toExpression()),
3120+
)
3121+
}
3122+
31083123
/**
31093124
* Creates a select clause in a select query.
31103125
*/
@@ -3119,6 +3134,22 @@ open class Jpql : JpqlDsl {
31193134
)
31203135
}
31213136

3137+
/**
3138+
* Creates a select clause in a select query.
3139+
*/
3140+
@SinceJdsl("3.5.5")
3141+
fun <T : Any> select(
3142+
type: KClass<T>,
3143+
expr: Expressionable<*>,
3144+
vararg exprs: Expressionable<*>,
3145+
): SelectQueryFromStep<T> {
3146+
return SelectQueryFromStepDsl(
3147+
type,
3148+
distinct = false,
3149+
listOf(expr.toExpression()) + exprs.map { it.toExpression() },
3150+
)
3151+
}
3152+
31223153
/**
31233154
* Creates a select clause in a select query.
31243155
*/
@@ -3134,6 +3165,21 @@ open class Jpql : JpqlDsl {
31343165
)
31353166
}
31363167

3168+
/**
3169+
* Creates a select clause in a select query.
3170+
*/
3171+
@SinceJdsl("3.5.5")
3172+
fun <T : Any> selectDistinct(
3173+
type: KClass<T>,
3174+
expr: Expressionable<T>,
3175+
): SelectQueryFromStep<T> {
3176+
return SelectQueryFromStepDsl(
3177+
type,
3178+
distinct = true,
3179+
listOf(expr.toExpression()),
3180+
)
3181+
}
3182+
31373183
/**
31383184
* Creates a select clause in a select query.
31393185
*/
@@ -3148,6 +3194,22 @@ open class Jpql : JpqlDsl {
31483194
)
31493195
}
31503196

3197+
/**
3198+
* Creates a select clause in a select query.
3199+
*/
3200+
@SinceJdsl("3.5.5")
3201+
fun <T : Any> selectDistinct(
3202+
type: KClass<T>,
3203+
expr: Expressionable<*>,
3204+
vararg exprs: Expressionable<*>,
3205+
): SelectQueryFromStep<T> {
3206+
return SelectQueryFromStepDsl(
3207+
type,
3208+
distinct = true,
3209+
listOf(expr.toExpression()) + exprs.map { it.toExpression() },
3210+
)
3211+
}
3212+
31513213
/**
31523214
* Creates a select clause in a select query.
31533215
*/
@@ -3163,6 +3225,27 @@ open class Jpql : JpqlDsl {
31633225
)
31643226
}
31653227

3228+
/**
3229+
* Creates a select clause with the DTO projection in a select query.
3230+
*/
3231+
@SinceJdsl("3.5.5")
3232+
fun <T : Any> selectNew(
3233+
type: KClass<T>,
3234+
expr: Expressionable<*>,
3235+
vararg exprs: Expressionable<*>,
3236+
): SelectQueryFromStep<T> {
3237+
return SelectQueryFromStepDsl(
3238+
returnType = type,
3239+
distinct = false,
3240+
select = listOf(
3241+
Expressions.new(
3242+
type,
3243+
listOf(expr.toExpression()) + exprs.map { it.toExpression() },
3244+
),
3245+
),
3246+
)
3247+
}
3248+
31663249
/**
31673250
* Creates a select clause with the DTO projection in a select query.
31683251
*/
@@ -3183,6 +3266,27 @@ open class Jpql : JpqlDsl {
31833266
)
31843267
}
31853268

3269+
/**
3270+
* Creates a select clause with the DTO projection in a select query.
3271+
*/
3272+
@SinceJdsl("3.5.5")
3273+
fun <T : Any> selectDistinctNew(
3274+
type: KClass<T>,
3275+
expr: Expressionable<*>,
3276+
vararg exprs: Expressionable<*>,
3277+
): SelectQueryFromStep<T> {
3278+
return SelectQueryFromStepDsl(
3279+
returnType = type,
3280+
distinct = true,
3281+
select = listOf(
3282+
Expressions.new(
3283+
type,
3284+
listOf(expr.toExpression()) + exprs.map { it.toExpression() },
3285+
),
3286+
),
3287+
)
3288+
}
3289+
31863290
/**
31873291
* Creates a select clause with the DTO projection in a select query.
31883292
*/

‎dsl/jpql/src/test/kotlin/com/linecorp/kotlinjdsl/dsl/jpql/select/SelectDslTest.kt

+164
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,31 @@ class SelectDslTest : WithAssertions {
2020
private class Dto
2121
private class View
2222

23+
@Test
24+
fun `select() with a KClass and an expression`() {
25+
// when
26+
val select = queryPart {
27+
select(
28+
BigDecimal::class,
29+
expression1,
30+
).from(
31+
entity1,
32+
)
33+
}.toQuery()
34+
35+
val actual: SelectQuery<BigDecimal> = select // for type check
36+
37+
// then
38+
val expected = SelectQueries.selectQuery(
39+
returnType = BigDecimal::class,
40+
distinct = false,
41+
select = listOf(expression1),
42+
from = listOf(entity1),
43+
)
44+
45+
assertThat(actual).isEqualTo(expected)
46+
}
47+
2348
@Test
2449
fun `select() with an expression`() {
2550
// when
@@ -44,6 +69,32 @@ class SelectDslTest : WithAssertions {
4469
assertThat(actual).isEqualTo(expected)
4570
}
4671

72+
@Test
73+
fun `select() with a KClass and expressions`() {
74+
// when
75+
val select = queryPart {
76+
select(
77+
View::class,
78+
expression1,
79+
expression2,
80+
).from(
81+
entity1,
82+
)
83+
}.toQuery()
84+
85+
val actual: SelectQuery<View> = select // for type check
86+
87+
// then
88+
val expected = SelectQueries.selectQuery(
89+
returnType = View::class,
90+
distinct = false,
91+
select = listOf(expression1, expression2),
92+
from = listOf(entity1),
93+
)
94+
95+
assertThat(actual).isEqualTo(expected)
96+
}
97+
4798
@Test
4899
fun `select() with a generic type and expressions`() {
49100
// when
@@ -69,6 +120,31 @@ class SelectDslTest : WithAssertions {
69120
assertThat(actual).isEqualTo(expected)
70121
}
71122

123+
@Test
124+
fun `selectDistinct() with a KClass and an expression`() {
125+
// when
126+
val select = queryPart {
127+
selectDistinct(
128+
BigDecimal::class,
129+
expression1,
130+
).from(
131+
entity1,
132+
)
133+
}.toQuery()
134+
135+
val actual: SelectQuery<BigDecimal> = select // for type check
136+
137+
// then
138+
val expected = SelectQueries.selectQuery(
139+
returnType = BigDecimal::class,
140+
distinct = true,
141+
select = listOf(expression1),
142+
from = listOf(entity1),
143+
)
144+
145+
assertThat(actual).isEqualTo(expected)
146+
}
147+
72148
@Test
73149
fun `selectDistinct() with an expression`() {
74150
// when
@@ -93,6 +169,32 @@ class SelectDslTest : WithAssertions {
93169
assertThat(actual).isEqualTo(expected)
94170
}
95171

172+
@Test
173+
fun `selectDistinct() with a KClass and expressions`() {
174+
// when
175+
val select = queryPart {
176+
selectDistinct(
177+
View::class,
178+
expression1,
179+
expression2,
180+
).from(
181+
entity1,
182+
)
183+
}.toQuery()
184+
185+
val actual: SelectQuery<View> = select // for type check
186+
187+
// then
188+
val expected = SelectQueries.selectQuery(
189+
returnType = View::class,
190+
distinct = true,
191+
select = listOf(expression1, expression2),
192+
from = listOf(entity1),
193+
)
194+
195+
assertThat(actual).isEqualTo(expected)
196+
}
197+
96198
@Test
97199
fun `selectDistinct() with a generic type and expressions`() {
98200
// when
@@ -118,6 +220,37 @@ class SelectDslTest : WithAssertions {
118220
assertThat(actual).isEqualTo(expected)
119221
}
120222

223+
@Test
224+
fun `selectNew() with a KClass and expressions`() {
225+
// when
226+
val select = queryPart {
227+
selectNew(
228+
Dto::class,
229+
expression1,
230+
expression2,
231+
).from(
232+
entity1,
233+
)
234+
}.toQuery()
235+
236+
val actual: SelectQuery<Dto> = select // for type check
237+
238+
// then
239+
val expected = SelectQueries.selectQuery(
240+
returnType = Dto::class,
241+
distinct = false,
242+
select = listOf(
243+
Expressions.new(
244+
type = Dto::class,
245+
args = listOf(expression1, expression2),
246+
),
247+
),
248+
from = listOf(entity1),
249+
)
250+
251+
assertThat(actual).isEqualTo(expected)
252+
}
253+
121254
@Test
122255
fun `selectNew() with a generic type and expressions`() {
123256
// when
@@ -148,6 +281,37 @@ class SelectDslTest : WithAssertions {
148281
assertThat(actual).isEqualTo(expected)
149282
}
150283

284+
@Test
285+
fun `selectDistinctNew() with a KClass and expressions`() {
286+
// when
287+
val select = queryPart {
288+
selectDistinctNew(
289+
Dto::class,
290+
expression1,
291+
expression2,
292+
).from(
293+
entity1,
294+
)
295+
}.toQuery()
296+
297+
val actual: SelectQuery<Dto> = select // for type check
298+
299+
// then
300+
val expected = SelectQueries.selectQuery(
301+
returnType = Dto::class,
302+
distinct = true,
303+
select = listOf(
304+
Expressions.new(
305+
type = Dto::class,
306+
args = listOf(expression1, expression2),
307+
),
308+
),
309+
from = listOf(entity1),
310+
)
311+
312+
assertThat(actual).isEqualTo(expected)
313+
}
314+
151315
@Test
152316
fun `selectDistinctNew() with a generic type and expressions`() {
153317
// when

0 commit comments

Comments
 (0)