github/jooq
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[jOOQ/jOOQ#6256] Added extension methods to Field<Boolean>

Browse Source
This commit is contained in:
Lukas Eder 2020-05-08 11:04:54 +02:00
parent 22a66f4aeb
commit 206441d235
2 changed files with 128 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

241
jOOQ-kotlin/src/main/kotlin/org/jooq/kotlin/Extensions.kt
View File

@ -1,206 +1,197 @@
package org.jooq.kotlin
import org.jooq.*
import org.jooq.conf.Settings
import org.jooq.impl.DSL
import org.jooq.impl.DSL.field
import java.util.*
@Support
inline fun <reified T: Any, R: Record> Result<R>.into(): MutableList<T> {
return this.into(T::class.java)
}
import org.jooq.impl.DSL.*
// ----------------------------------------------------------------------------
// Class reification extensions
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Field extensions
// Extensions to make Field<Boolean> a Condition
// ----------------------------------------------------------------------------
@Support
inline fun <reified T: Any> Select<Record1<T>>.`as`(alias: String): Field<T> {
return field(this).`as`(alias);
}
inline fun Field<Boolean>.and(other: Condition): Condition = condition(this).and(other)
@Support
inline fun <reified T: Any> Select<Record1<T>>.`as`(alias: Name): Field<T> {
return field(this).`as`(alias);
}
inline fun Field<Boolean>.and(other: Field<Boolean>): Condition = condition(this).and(other)
@Support
inline fun <reified T: Any> Select<Record1<T>>.`as`(alias: Field<*>): Field<T> {
return field(this).`as`(alias);
}
@PlainSQL
inline fun Field<Boolean>.and(sql: SQL): Condition = condition(this).and(sql)
@Support
inline fun <reified T: Any> Select<Record1<T>>.eq(value: T): Condition {
return field(this).eq(value);
}
@PlainSQL
inline fun Field<Boolean>.and(sql: String): Condition = condition(this).and(sql)
@Support
inline fun <reified T: Any> Select<Record1<T>>.eq(value: Field<T>): Condition {
return field(this).eq(value);
}
@PlainSQL
inline fun Field<Boolean>.and(sql: String, vararg bindings: Any): Condition = condition(this).and(sql, bindings)
@Support
inline fun <reified T: Any> Select<Record1<T>>.equal(value: T): Condition {
return field(this).equal(value);
}
@PlainSQL
inline fun Field<Boolean>.and(sql: String, vararg parts: QueryPart): Condition = condition(this).and(sql, parts)
@Support
inline fun <reified T: Any> Select<Record1<T>>.equal(value: Field<T>): Condition {
return field(this).equal(value);
}
inline fun Field<Boolean>.andNot(other: Condition): Condition = condition(this).andNot(other)
@Support
inline fun <reified T: Any> Select<Record1<T>>.ne(value: T): Condition {
return field(this).ne(value);
}
inline fun Field<Boolean>.andNot(other: Field<Boolean>): Condition = condition(this).andNot(other)
@Support
inline fun <reified T: Any> Select<Record1<T>>.ne(value: Field<T>): Condition {
return field(this).ne(value);
}
inline fun Field<Boolean>.andExists(select: Select<*>): Condition = condition(this).andExists(select)
@Support
inline fun <reified T: Any> Select<Record1<T>>.notEqual(value: T): Condition {
return field(this).notEqual(value);
}
inline fun Field<Boolean>.andNotExists(select: Select<*>): Condition = condition(this).andNotExists(select)
@Support
inline fun <reified T: Any> Select<Record1<T>>.notEqual(value: Field<T>): Condition {
return field(this).notEqual(value);
}
inline fun Field<Boolean>.or(other: Condition): Condition = condition(this).or(other)
@Support
inline fun <reified T: Any> Select<Record1<T>>.gt(value: T): Condition {
return field(this).gt(value);
}
inline fun Field<Boolean>.or(other: Field<Boolean>): Condition = condition(this).or(other)
@Support
inline fun <reified T: Any> Select<Record1<T>>.gt(value: Field<T>): Condition {
return field(this).gt(value);
}
@PlainSQL
inline fun Field<Boolean>.or(sql: SQL): Condition = condition(this).or(sql)
@Support
inline fun <reified T: Any> Select<Record1<T>>.greaterThan(value: T): Condition {
return field(this).greaterThan(value);
}
@PlainSQL
inline fun Field<Boolean>.or(sql: String): Condition = condition(this).or(sql)
@Support
inline fun <reified T: Any> Select<Record1<T>>.greaterThan(value: Field<T>): Condition {
return field(this).greaterThan(value);
}
@PlainSQL
inline fun Field<Boolean>.or(sql: String, vararg bindings: Any): Condition = condition(this).or(sql)
@Support
inline fun <reified T: Any> Select<Record1<T>>.ge(value: T): Condition {
return field(this).ge(value);
}
@PlainSQL
inline fun Field<Boolean>.or(sql: String, vararg parts: QueryPart): Condition = condition(this).or(sql, parts)
@Support
inline fun <reified T: Any> Select<Record1<T>>.ge(value: Field<T>): Condition {
return field(this).ge(value);
}
inline fun Field<Boolean>.orNot(other: Condition): Condition = condition(this).orNot(other)
@Support
inline fun <reified T: Any> Select<Record1<T>>.greaterOrEqual(value: T): Condition {
return field(this).greaterOrEqual(value);
}
inline fun Field<Boolean>.orNot(other: Field<Boolean>): Condition = condition(this).orNot(other)
@Support
inline fun <reified T: Any> Select<Record1<T>>.greaterOrEqual(value: Field<T>): Condition {
return field(this).greaterOrEqual(value);
}
inline fun Field<Boolean>.orExists(select: Select<*>): Condition = condition(this).orExists(select)
@Support
inline fun <reified T: Any> Select<Record1<T>>.lt(value: T): Condition {
return field(this).lt(value);
}
inline fun Field<Boolean>.orNotExists(select: Select<*>): Condition = condition(this).orNotExists(select)
@Support
inline fun <reified T: Any> Select<Record1<T>>.lt(value: Field<T>): Condition {
return field(this).lt(value);
}
inline fun Field<Boolean>.not(): Condition = condition(this).not()
// ----------------------------------------------------------------------------
// Extensions to make Select<Record1<T>> a scalar subquery of type Field<T>
// ----------------------------------------------------------------------------
@Support
inline fun <reified T: Any> Select<Record1<T>>.lessThan(value: T): Condition {
return field(this).lessThan(value);
}
inline fun <reified T: Any> Select<Record1<T>>.`as`(alias: String): Field<T> = field(this).`as`(alias)
@Support
inline fun <reified T: Any> Select<Record1<T>>.lessThan(value: Field<T>): Condition {
return field(this).lessThan(value);
}
inline fun <reified T: Any> Select<Record1<T>>.`as`(alias: Name): Field<T> = field(this).`as`(alias)
@Support
inline fun <reified T: Any> Select<Record1<T>>.le(value: T): Condition {
return field(this).le(value);
}
inline fun <reified T: Any> Select<Record1<T>>.`as`(alias: Field<*>): Field<T> = field(this).`as`(alias)
@Support
inline fun <reified T: Any> Select<Record1<T>>.le(value: Field<T>): Condition {
return field(this).le(value);
}
inline fun <reified T: Any> Select<Record1<T>>.eq(value: T): Condition = field(this).eq(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.lessOrEqual(value: T): Condition {
return field(this).lessOrEqual(value);
}
inline fun <reified T: Any> Select<Record1<T>>.eq(value: Field<T>): Condition = field(this).eq(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.lessOrEqual(value: Field<T>): Condition {
return field(this).lessOrEqual(value);
}
inline fun <reified T: Any> Select<Record1<T>>.equal(value: T): Condition = field(this).equal(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.asc(): SortField<T> {
return field(this).asc();
}
inline fun <reified T: Any> Select<Record1<T>>.equal(value: Field<T>): Condition = field(this).equal(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.desc(): SortField<T> {
return field(this).desc();
}
inline fun <reified T: Any> Select<Record1<T>>.ne(value: T): Condition = field(this).ne(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.`in`(values: Collection<*>): Condition {
return field(this).`in`(values)
}
inline fun <reified T: Any> Select<Record1<T>>.ne(value: Field<T>): Condition = field(this).ne(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.`in`(values: Result<out Record1<T>>): Condition {
return field(this).`in`(values)
}
inline fun <reified T: Any> Select<Record1<T>>.notEqual(value: T): Condition = field(this).notEqual(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.`in`(vararg values: T): Condition {
return field(this).`in`(values.asList())
}
inline fun <reified T: Any> Select<Record1<T>>.notEqual(value: Field<T>): Condition = field(this).notEqual(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.`in`(vararg values: Field<*>): Condition {
return field(this).`in`(values.asList())
}
inline fun <reified T: Any> Select<Record1<T>>.gt(value: T): Condition = field(this).gt(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.notIn(values: Collection<*>): Condition {
return field(this).notIn(values)
}
inline fun <reified T: Any> Select<Record1<T>>.gt(value: Field<T>): Condition = field(this).gt(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.notIn(values: Result<out Record1<T>>): Condition {
return field(this).notIn(values)
}
inline fun <reified T: Any> Select<Record1<T>>.greaterThan(value: T): Condition = field(this).greaterThan(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.notIn(vararg values: T): Condition {
return field(this).notIn(values.asList())
}
inline fun <reified T: Any> Select<Record1<T>>.greaterThan(value: Field<T>): Condition = field(this).greaterThan(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.notIn(vararg values: Field<*>): Condition {
return field(this).notIn(values.asList())
}
inline fun <reified T: Any> Select<Record1<T>>.ge(value: T): Condition = field(this).ge(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.ge(value: Field<T>): Condition = field(this).ge(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.greaterOrEqual(value: T): Condition = field(this).greaterOrEqual(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.greaterOrEqual(value: Field<T>): Condition =
field(this).greaterOrEqual(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.lt(value: T): Condition = field(this).lt(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.lt(value: Field<T>): Condition = field(this).lt(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.lessThan(value: T): Condition = field(this).lessThan(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.lessThan(value: Field<T>): Condition = field(this).lessThan(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.le(value: T): Condition = field(this).le(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.le(value: Field<T>): Condition = field(this).le(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.lessOrEqual(value: T): Condition = field(this).lessOrEqual(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.lessOrEqual(value: Field<T>): Condition = field(this).lessOrEqual(value)
@Support
inline fun <reified T: Any> Select<Record1<T>>.asc(): SortField<T> = field(this).asc()
@Support
inline fun <reified T: Any> Select<Record1<T>>.desc(): SortField<T> = field(this).desc()
@Support
inline fun <reified T: Any> Select<Record1<T>>.`in`(values: Collection<*>): Condition = field(this).`in`(values)
@Support
inline fun <reified T: Any> Select<Record1<T>>.`in`(values: Result<out Record1<T>>): Condition = field(this).`in`(values)
@Support
inline fun <reified T: Any> Select<Record1<T>>.`in`(vararg values: T): Condition = field(this).`in`(values.asList())
@Support
inline fun <reified T: Any> Select<Record1<T>>.`in`(vararg values: Field<*>): Condition = field(this).`in`(values.asList())
@Support
inline fun <reified T: Any> Select<Record1<T>>.notIn(values: Collection<*>): Condition = field(this).notIn(values)
@Support
inline fun <reified T: Any> Select<Record1<T>>.notIn(values: Result<out Record1<T>>): Condition = field(this).notIn(values)
@Support
inline fun <reified T: Any> Select<Record1<T>>.notIn(vararg values: T): Condition = field(this).notIn(values.asList())
@Support
inline fun <reified T: Any> Select<Record1<T>>.notIn(vararg values: Field<*>): Condition = field(this).notIn(values.asList())

12
jOOQ-kotlin/src/test/kotlin/org/jooq/kotlin/ExtensionsTest.kt
View File

@ -3,6 +3,7 @@ package org.jooq.kotlin
import org.jooq.SQLDialect.H2
import org.jooq.impl.DSL
import org.jooq.impl.DSL.*
import org.jooq.impl.SQLDataType.BOOLEAN
import org.jooq.impl.SQLDataType.INTEGER
import org.junit.Assert.assertEquals
import org.junit.FixMethodOrder
@ -14,8 +15,19 @@ class ExtensionsTest {
val i = field(unquotedName("i"), INTEGER)
val j = field(unquotedName("j"), INTEGER)
val b1 = field(unquotedName("b1"), BOOLEAN)
val b2 = field(unquotedName("b2"), BOOLEAN)
val dsl = DSL.using(H2)
@Test
fun testBooleanFields() {
assertEquals(condition(b1).and(b2), b1.and(b2))
assertEquals(condition(b1).andNot(b2), b1.andNot(b2))
assertEquals(condition(b1).or(b2), b1.or(b2))
assertEquals(condition(b1).orNot(b2), b1.orNot(b2))
assertEquals(condition(b1).not(), b1.not())
}
@Test
fun testScalarSubqueries() {
assertEquals(field(select(i)).`as`("i"), select(i).`as`("i"))