DATACASS-484 - Add Kotlin extensions for Template API.
We now provide Kotlin extensions for imperative, asynchronous, and reactive Template API interfaces.
CqlOperations and CassandraOperations expose Kotlin-friendly methods accepting KClasses and leveraging reified generics. We also provide Kotlin-friendly method renames for methods such as in that do not require quoting in Kotlin code.
operations.query(Person::class).inTable("my_table").asType<User>().all()
operations.select<Person>(query(where("firstname").isEqualTo("Walter") and where("lastname").isEqualTo("White")))
This commit is contained in:
Mark Paluch
18
pom.xml
18
pom.xml
@@ -231,13 +231,13 @@
|
||||
<threadCount>10</threadCount>
|
||||
<useFile>false</useFile>
|
||||
<includes>
|
||||
<include>**/test/unit/**/*.java</include>
|
||||
<include>**/*UnitTests.java</include>
|
||||
<include>**/test/unit/**/*</include>
|
||||
<include>**/*UnitTests</include>
|
||||
</includes>
|
||||
<excludes>
|
||||
<exclude>**/test/integration/**/*.java</exclude>
|
||||
<exclude>**/**IntegrationTests.java</exclude>
|
||||
<exclude>**/test/performance/**/*.java</exclude>
|
||||
<exclude>**/**IntegrationTests</exclude>
|
||||
<exclude>**/test/performance/**/*</exclude>
|
||||
</excludes>
|
||||
<systemPropertyVariables>
|
||||
<java.util.logging.config.file>src/test/resources/logging.properties</java.util.logging.config.file>
|
||||
@@ -253,13 +253,13 @@
|
||||
<reuseForks>true</reuseForks>
|
||||
<useFile>false</useFile>
|
||||
<includes>
|
||||
<include>**/test/integration/**/*.java</include>
|
||||
<include>**/*IntegrationTests.java</include>
|
||||
<include>**/test/integration/**/*</include>
|
||||
<include>**/*IntegrationTests</include>
|
||||
</includes>
|
||||
<excludes>
|
||||
<exclude>**/test/unit/**/*.java</exclude>
|
||||
<exclude>**/*UnitTests.java</exclude>
|
||||
<exclude>**/test/performance/**/*.java</exclude>
|
||||
<exclude>**/test/unit/**/*</exclude>
|
||||
<exclude>**/*UnitTests</exclude>
|
||||
<exclude>**/test/performance/**/*</exclude>
|
||||
</excludes>
|
||||
<systemPropertyVariables>
|
||||
<java.util.logging.config.file>src/test/resources/logging.properties</java.util.logging.config.file>
|
||||
|
||||
@@ -182,6 +182,45 @@
|
||||
<artifactId>multithreadedtc</artifactId>
|
||||
</dependency>
|
||||
|
||||
<!-- Kotlin extension -->
|
||||
<dependency>
|
||||
<groupId>org.jetbrains.kotlin</groupId>
|
||||
<artifactId>kotlin-stdlib</artifactId>
|
||||
<version>${kotlin}</version>
|
||||
<optional>true</optional>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.jetbrains.kotlin</groupId>
|
||||
<artifactId>kotlin-reflect</artifactId>
|
||||
<version>${kotlin}</version>
|
||||
<optional>true</optional>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.jetbrains.kotlin</groupId>
|
||||
<artifactId>kotlin-test-junit</artifactId>
|
||||
<version>${kotlin}</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>com.nhaarman</groupId>
|
||||
<artifactId>mockito-kotlin</artifactId>
|
||||
<version>1.5.0</version>
|
||||
<scope>test</scope>
|
||||
<exclusions>
|
||||
<exclusion>
|
||||
<groupId>org.jetbrains.kotlin</groupId>
|
||||
<artifactId>kotlin-stdlib</artifactId>
|
||||
</exclusion>
|
||||
<exclusion>
|
||||
<groupId>org.jetbrains.kotlin</groupId>
|
||||
<artifactId>kotlin-reflect</artifactId>
|
||||
</exclusion>
|
||||
<exclusion>
|
||||
<groupId>org.mockito</groupId>
|
||||
<artifactId>mockito-core</artifactId>
|
||||
</exclusion>
|
||||
</exclusions>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
</project>
|
||||
|
||||
@@ -0,0 +1,287 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.datastax.driver.core.Statement
|
||||
import org.springframework.data.cassandra.core.query.Query
|
||||
import org.springframework.data.cassandra.core.query.Update
|
||||
import org.springframework.data.domain.Slice
|
||||
import org.springframework.util.concurrent.ListenableFuture
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [AsyncCassandraOperations].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with static CQL
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.select(cql: String, entityClass: KClass<T>): ListenableFuture<List<T>> =
|
||||
select(cql, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.select(cql: String): ListenableFuture<List<T>> =
|
||||
select(cql, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] providing a Consumer-like function.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.select(cql: String, entityClass: KClass<T>, consumer: (T) -> Unit): ListenableFuture<Void> =
|
||||
select(cql, consumer, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] providing a Consumer-like function leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.select(cql: String, crossinline consumer: (T) -> Unit): ListenableFuture<Void> =
|
||||
select(cql, { consumer(it) }, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.selectOne] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.selectOne(cql: String, entityClass: KClass<T>): ListenableFuture<T?> =
|
||||
selectOne(cql, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.selectOne] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.selectOne(cql: String): ListenableFuture<T?> =
|
||||
selectOne(cql, T::class.java)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with com.datastax.driver.core.Statement
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.select(statement: Statement, entityClass: KClass<T>): ListenableFuture<List<T>> =
|
||||
select(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.select(statement: Statement): ListenableFuture<List<T>> =
|
||||
select(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] providing a Consumer-like function.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.select(statement: Statement, entityClass: KClass<T>, consumer: (T) -> Unit): ListenableFuture<Void> =
|
||||
select(statement, consumer, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] providing a Consumer-like function leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.select(statement: Statement, crossinline consumer: (T) -> Unit): ListenableFuture<Void> =
|
||||
select(statement, { consumer(it) }, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.slice] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.slice(statement: Statement, entityClass: KClass<T>): ListenableFuture<Slice<T>> =
|
||||
slice(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.slice] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.slice(statement: Statement): ListenableFuture<Slice<T>> =
|
||||
slice(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.selectOne] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.selectOne(statement: Statement, entityClass: KClass<T>): ListenableFuture<T?> =
|
||||
selectOne(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.selectOne] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.selectOne(statement: Statement): ListenableFuture<T?> =
|
||||
selectOne(statement, T::class.java)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with org.springframework.data.cassandra.core.query.Query
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.select(query: Query, entityClass: KClass<T>): ListenableFuture<List<T>> =
|
||||
select(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.select(query: Query): ListenableFuture<List<T>> =
|
||||
select(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] providing a Consumer-like function.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.select(query: Query, entityClass: KClass<T>, consumer: (T) -> Unit): ListenableFuture<Void> =
|
||||
select(query, consumer, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.select] providing a Consumer-like function leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.select(query: Query, crossinline consumer: (T) -> Unit): ListenableFuture<Void> =
|
||||
select(query, { consumer(it) }, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.slice] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.slice(query: Query, entityClass: KClass<T>): ListenableFuture<Slice<T>> =
|
||||
slice(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.slice] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.slice(query: Query): ListenableFuture<Slice<T>> =
|
||||
slice(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.selectOne] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.selectOne(query: Query, entityClass: KClass<T>): ListenableFuture<T?> =
|
||||
selectOne(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.selectOne] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.selectOne(query: Query): ListenableFuture<T?> =
|
||||
selectOne(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.update] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.update(query: Query, update: Update, entityClass: KClass<T>): ListenableFuture<Boolean> =
|
||||
update(query, update, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.update] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.update(query: Query, update: Update): ListenableFuture<Boolean> =
|
||||
update(query, update, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.delete] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.delete(query: Query, entityClass: KClass<T>): ListenableFuture<Boolean> =
|
||||
delete(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.delete] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.delete(query: Query): ListenableFuture<Boolean> =
|
||||
delete(query, T::class.java)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with entities
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.count] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.count(entityClass: KClass<T>): ListenableFuture<Long> =
|
||||
count(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.count] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.count(): ListenableFuture<Long> =
|
||||
count(T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.count] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.count(query: Query, entityClass: KClass<T>): ListenableFuture<Long> =
|
||||
count(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.count] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.count(query: Query): ListenableFuture<Long> =
|
||||
count(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.exists] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.exists(id: Any, entityClass: KClass<T>): ListenableFuture<Boolean> =
|
||||
exists(id, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.exists] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.exists(id: Any): ListenableFuture<Boolean> =
|
||||
exists(id, T::class)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.count] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.exists(query: Query, entityClass: KClass<T>): ListenableFuture<Boolean> =
|
||||
exists(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.count] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.exists(query: Query): ListenableFuture<Boolean> =
|
||||
exists(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.selectOneById] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.selectOneById(id: Any, entityClass: KClass<T>): ListenableFuture<T?> =
|
||||
selectOneById(id, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.selectOneById] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.selectOneById(id: Any): ListenableFuture<T?> =
|
||||
selectOneById(id, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.deleteById] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.deleteById(id: Any, entityClass: KClass<T>): ListenableFuture<Boolean> =
|
||||
deleteById(id, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.deleteById] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.deleteById(id: Any): ListenableFuture<Boolean> =
|
||||
deleteById(id, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.truncate] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCassandraOperations.truncate(entityClass: KClass<T>): ListenableFuture<Void> =
|
||||
truncate(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCassandraOperations.truncate] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCassandraOperations.truncate(): ListenableFuture<Void> =
|
||||
truncate(T::class.java)
|
||||
@@ -0,0 +1,300 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.datastax.driver.core.Statement
|
||||
import org.springframework.data.cassandra.core.cql.CqlIdentifier
|
||||
import org.springframework.data.cassandra.core.query.Query
|
||||
import org.springframework.data.cassandra.core.query.Update
|
||||
import org.springframework.data.domain.Slice
|
||||
import java.util.stream.Stream
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [CassandraOperations].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.getTableName] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.getTableName(entityClass: KClass<T>): CqlIdentifier =
|
||||
getTableName(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.getTableName] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.getTableName(): CqlIdentifier =
|
||||
getTableName(T::class.java)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with static CQL
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.select] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.select(cql: String, entityClass: KClass<T>): List<T> =
|
||||
select(cql, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.select] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.select(cql: String): List<T> =
|
||||
select(cql, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.stream] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.stream(cql: String, entityClass: KClass<T>): Stream<T> =
|
||||
stream(cql, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.stream] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.stream(cql: String): Stream<T> =
|
||||
stream(cql, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.selectOne] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.selectOne(cql: String, entityClass: KClass<T>): T? =
|
||||
selectOne(cql, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.selectOne] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.selectOne(cql: String): T? =
|
||||
selectOne(cql, T::class.java)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with com.datastax.driver.core.Statement
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.select] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.select(statement: Statement, entityClass: KClass<T>): List<T> =
|
||||
select(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.select] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.select(statement: Statement): List<T> =
|
||||
select(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.slice] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.slice(statement: Statement, entityClass: KClass<T>): Slice<T> =
|
||||
slice(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.slice] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.slice(statement: Statement): Slice<T> =
|
||||
slice(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.stream] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.stream(statement: Statement, entityClass: KClass<T>): Stream<T> =
|
||||
stream(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.stream] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.stream(statement: Statement): Stream<T> =
|
||||
stream(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.selectOne] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.selectOne(statement: Statement, entityClass: KClass<T>): T? =
|
||||
selectOne(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.selectOne] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.selectOne(statement: Statement): T? =
|
||||
selectOne(statement, T::class.java)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with org.springframework.data.cassandra.core.query.Query
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.select] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.select(query: Query, entityClass: KClass<T>): List<T> =
|
||||
select(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.select] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.select(query: Query): List<T> =
|
||||
select(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.slice] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.slice(query: Query, entityClass: KClass<T>): Slice<T> =
|
||||
slice(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.slice] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.slice(query: Query): Slice<T> =
|
||||
slice(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.stream] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.stream(query: Query, entityClass: KClass<T>): Stream<T> =
|
||||
stream(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.stream] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.stream(query: Query): Stream<T> =
|
||||
stream(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.selectOne] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.selectOne(query: Query, entityClass: KClass<T>): T? =
|
||||
selectOne(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.selectOne] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.selectOne(query: Query): T? =
|
||||
selectOne(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.update] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.update(query: Query, update: Update, entityClass: KClass<T>): Boolean =
|
||||
update(query, update, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.update] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.update(query: Query, update: Update): Boolean =
|
||||
update(query, update, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.delete] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.delete(query: Query, entityClass: KClass<T>): Boolean =
|
||||
delete(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.delete] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> CassandraOperations.delete(query: Query): Boolean =
|
||||
delete(query, T::class.java)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with entities
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.count] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.count(entityClass: KClass<T>): Long =
|
||||
count(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.count] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.count(): Long =
|
||||
count(T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.count] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.count(query: Query, entityClass: KClass<T>): Long =
|
||||
count(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.count] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.count(query: Query): Long =
|
||||
count(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.exists] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.exists(id: Any, entityClass: KClass<T>): Boolean =
|
||||
exists(id, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.exists] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.exists(id: Any): Boolean =
|
||||
exists(id, T::class)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.count] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.exists(query: Query, entityClass: KClass<T>): Boolean =
|
||||
exists(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.count] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.exists(query: Query): Boolean =
|
||||
exists(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.selectOneById] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.selectOneById(id: Any, entityClass: KClass<T>): T? =
|
||||
selectOneById(id, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.selectOneById] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.selectOneById(id: Any): T? =
|
||||
selectOneById(id, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.deleteById] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.deleteById(id: Any, entityClass: KClass<T>): Boolean =
|
||||
deleteById(id, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.deleteById] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.deleteById(id: Any): Boolean =
|
||||
deleteById(id, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.truncate] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CassandraOperations.truncate(entityClass: KClass<T>): Unit =
|
||||
truncate(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CassandraOperations.truncate] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CassandraOperations.truncate(): Unit =
|
||||
truncate(T::class.java)
|
||||
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [ExecutableDeleteOperation].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [ExecutableRemoveOperation.delete] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ExecutableDeleteOperation.delete(entityClass: KClass<T>): ExecutableDeleteOperation.ExecutableDelete =
|
||||
delete(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ExecutableRemoveOperation.delete] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ExecutableDeleteOperation.delete(): ExecutableDeleteOperation.ExecutableDelete =
|
||||
delete(T::class.java)
|
||||
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [ExecutableInsertOperation].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [ExecutableInsertOperation.insert] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ExecutableInsertOperation.insert(entityClass: KClass<T>): ExecutableInsertOperation.ExecutableInsert<T> =
|
||||
insert(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ExecutableInsertOperation.insert] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ExecutableInsertOperation.insert(): ExecutableInsertOperation.ExecutableInsert<T> =
|
||||
insert(T::class.java)
|
||||
@@ -0,0 +1,49 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [ExecutableSelectOperation].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [ExecutableSelectOperation.query] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ExecutableSelectOperation.query(entityClass: KClass<T>): ExecutableSelectOperation.ExecutableSelect<T> =
|
||||
query(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ExecutableSelectOperation.query] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ExecutableSelectOperation.query(): ExecutableSelectOperation.ExecutableSelect<T> =
|
||||
query(T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ExecutableSelectOperation.SelectWithProjection. as] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ExecutableSelectOperation.SelectWithProjection<*>.asType(resultType: KClass<T>): ExecutableSelectOperation.SelectWithQuery<T> =
|
||||
`as`(resultType.java)
|
||||
|
||||
/**
|
||||
* Extension for [ExecutableSelectOperation.FindWithProjection. as] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ExecutableSelectOperation.SelectWithProjection<*>.asType(): ExecutableSelectOperation.SelectWithQuery<T> =
|
||||
`as`(T::class.java)
|
||||
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [ExecutableUpdateOperation].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [ExecutableUpdateOperation.update] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ExecutableUpdateOperation.update(entityClass: KClass<T>): ExecutableUpdateOperation.ExecutableUpdate =
|
||||
update(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ExecutableUpdateOperation.update] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ExecutableUpdateOperation.update(): ExecutableUpdateOperation.ExecutableUpdate =
|
||||
update(T::class.java)
|
||||
@@ -0,0 +1,227 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.datastax.driver.core.Statement
|
||||
import org.springframework.data.cassandra.core.query.Query
|
||||
import org.springframework.data.cassandra.core.query.Update
|
||||
import reactor.core.publisher.Flux
|
||||
import reactor.core.publisher.Mono
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [ReactiveCassandraOperations].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with static CQL
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.select] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.select(cql: String, entityClass: KClass<T>): Flux<T> =
|
||||
select(cql, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.select] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.select(cql: String): Flux<T> =
|
||||
select(cql, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.selectOne] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.selectOne(cql: String, entityClass: KClass<T>): Mono<T> =
|
||||
selectOne(cql, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.selectOne] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.selectOne(cql: String): Mono<T> =
|
||||
selectOne(cql, T::class.java)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with com.datastax.driver.core.Statement
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.select] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.select(statement: Statement, entityClass: KClass<T>): Flux<T> =
|
||||
select(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.select] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.select(statement: Statement): Flux<T> =
|
||||
select(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.selectOne] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.selectOne(statement: Statement, entityClass: KClass<T>): Mono<T> =
|
||||
selectOne(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.selectOne] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.selectOne(statement: Statement): Mono<T> =
|
||||
selectOne(statement, T::class.java)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with org.springframework.data.cassandra.core.query.Query
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.select] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.select(query: Query, entityClass: KClass<T>): Flux<T> =
|
||||
select(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.select] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.select(query: Query): Flux<T> =
|
||||
select(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.selectOne] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.selectOne(query: Query, entityClass: KClass<T>): Mono<T> =
|
||||
selectOne(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.selectOne] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.selectOne(query: Query): Mono<T> =
|
||||
selectOne(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.update] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.update(query: Query, update: Update, entityClass: KClass<T>): Mono<Boolean> =
|
||||
update(query, update, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.update] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.update(query: Query, update: Update): Mono<Boolean> =
|
||||
update(query, update, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.delete] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.delete(query: Query, entityClass: KClass<T>): Mono<Boolean> =
|
||||
delete(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.delete] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.delete(query: Query): Mono<Boolean> =
|
||||
delete(query, T::class.java)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with entities
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.count] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.count(entityClass: KClass<T>): Mono<Long> =
|
||||
count(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.count] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.count(): Mono<Long> =
|
||||
count(T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.count] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.count(query: Query, entityClass: KClass<T>): Mono<Long> =
|
||||
count(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.count] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.count(query: Query): Mono<Long> =
|
||||
count(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.exists] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.exists(id: Any, entityClass: KClass<T>): Mono<Boolean> =
|
||||
exists(id, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.exists] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.exists(id: Any): Mono<Boolean> =
|
||||
exists(id, T::class)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.count] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.exists(query: Query, entityClass: KClass<T>): Mono<Boolean> =
|
||||
exists(query, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.count] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.exists(query: Query): Mono<Boolean> =
|
||||
exists(query, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.selectOneById] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.selectOneById(id: Any, entityClass: KClass<T>): Mono<T> =
|
||||
selectOneById(id, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.selectOneById] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.selectOneById(id: Any): Mono<T> =
|
||||
selectOneById(id, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.deleteById] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.deleteById(id: Any, entityClass: KClass<T>): Mono<Boolean> =
|
||||
deleteById(id, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.deleteById] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.deleteById(id: Any): Mono<Boolean> =
|
||||
deleteById(id, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.truncate] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCassandraOperations.truncate(entityClass: KClass<T>): Mono<Void> =
|
||||
truncate(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCassandraOperations.truncate] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCassandraOperations.truncate(): Mono<Void> =
|
||||
truncate(T::class.java)
|
||||
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [ReactiveDeleteOperation].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveDeleteOperation.delete] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveDeleteOperation.delete(entityClass: KClass<T>): ReactiveDeleteOperation.ReactiveDelete =
|
||||
delete(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveDeleteOperation.delete] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveDeleteOperation.delete(): ReactiveDeleteOperation.ReactiveDelete =
|
||||
delete(T::class.java)
|
||||
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [ReactiveInsertOperation].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveInsertOperation.insert] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveInsertOperation.insert(entityClass: KClass<T>): ReactiveInsertOperation.ReactiveInsert<T> =
|
||||
insert(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveInsertOperation.insert] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveInsertOperation.insert(): ReactiveInsertOperation.ReactiveInsert<T> =
|
||||
insert(T::class.java)
|
||||
@@ -0,0 +1,49 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [ReactiveSelectOperation].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveSelectOperation.query] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveSelectOperation.query(entityClass: KClass<T>): ReactiveSelectOperation.ReactiveSelect<T> =
|
||||
query(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveSelectOperation.query] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveSelectOperation.query(): ReactiveSelectOperation.ReactiveSelect<T> =
|
||||
query(T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveSelectOperation.SelectWithProjection. as] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveSelectOperation.SelectWithProjection<*>.asType(resultType: KClass<T>): ReactiveSelectOperation.SelectWithQuery<T> =
|
||||
`as`(resultType.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveSelectOperation.FindWithProjection. as] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveSelectOperation.SelectWithProjection<*>.asType(): ReactiveSelectOperation.SelectWithQuery<T> =
|
||||
`as`(T::class.java)
|
||||
@@ -0,0 +1,37 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [ReactiveUpdateOperation].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveUpdateOperation.update] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveUpdateOperation.update(entityClass: KClass<T>): ReactiveUpdateOperation.ReactiveUpdate =
|
||||
update(entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveUpdateOperation.update] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveUpdateOperation.update(): ReactiveUpdateOperation.ReactiveUpdate =
|
||||
update(T::class.java)
|
||||
@@ -0,0 +1,112 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core.cql
|
||||
|
||||
import com.datastax.driver.core.ResultSet
|
||||
import com.datastax.driver.core.Row
|
||||
import com.datastax.driver.core.Statement
|
||||
import org.springframework.util.concurrent.ListenableFuture
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [AsyncCqlOperations].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.queryForObject] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCqlOperations.queryForObject(cql: String, entityClass: KClass<T>): ListenableFuture<T?> =
|
||||
queryForObject(cql, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCqlOperations.queryForObject(cql: String): ListenableFuture<T?> =
|
||||
queryForObject(cql, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.queryForObject] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCqlOperations.queryForObject(cql: String, entityClass: KClass<T>, vararg args: Any): ListenableFuture<T?> =
|
||||
queryForObject(cql, entityClass.java, args)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCqlOperations.queryForObject(cql: String, vararg args: Any): ListenableFuture<T?> =
|
||||
queryForObject(cql, T::class.java, args)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
fun <T : Any> AsyncCqlOperations.queryForObject(cql: String, vararg args: Any, function: (Row, Int) -> T): ListenableFuture<T?> =
|
||||
queryForObject(cql, function, args)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.queryForObject] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCqlOperations.queryForObject(statement: Statement, entityClass: KClass<T>): ListenableFuture<T?> =
|
||||
queryForObject(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCqlOperations.queryForObject(statement: Statement): ListenableFuture<T?> =
|
||||
queryForObject(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.queryForList] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> AsyncCqlOperations.queryForList(cql: String): ListenableFuture<List<T>> =
|
||||
queryForList(cql, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.queryForList] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> AsyncCqlOperations.queryForList(cql: String, vararg args: Any): ListenableFuture<List<T>> =
|
||||
queryForList(cql, T::class.java, args)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.queryForList] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> AsyncCqlOperations.queryForList(statement: Statement, entityClass: KClass<T>): ListenableFuture<List<T>> =
|
||||
queryForList(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.queryForList] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> AsyncCqlOperations.queryForList(statement: Statement): ListenableFuture<List<T>> =
|
||||
queryForList(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.query] providing a ResultSetExtractor-like function
|
||||
* variant: `query("...", arg1, argN){ rs -> }`.
|
||||
*/
|
||||
inline fun <reified T : Any> AsyncCqlOperations.query(cql: String, vararg args: Any, crossinline function: (ResultSet) -> T): ListenableFuture<T?> =
|
||||
query(cql, ResultSetExtractor { function(it) }, *args)
|
||||
|
||||
/**
|
||||
* Extension for [AsyncCqlOperations.query] providing a RowMapper-like function
|
||||
* variant: `query("...", arg1, argN){ row, i -> }`.
|
||||
*/
|
||||
fun <T : Any> AsyncCqlOperations.query(cql: String, vararg args: Any, function: (Row, Int) -> T): ListenableFuture<List<T>> =
|
||||
query(cql, RowMapper { row, i -> function(row, i) }, *args)
|
||||
@@ -0,0 +1,118 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core.cql
|
||||
|
||||
import com.datastax.driver.core.ResultSet
|
||||
import com.datastax.driver.core.Row
|
||||
import com.datastax.driver.core.Statement
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [CqlOperations].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.queryForObject] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CqlOperations.queryForObject(cql: String, entityClass: KClass<T>): T? =
|
||||
queryForObject(cql, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CqlOperations.queryForObject(cql: String): T? =
|
||||
queryForObject(cql, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.queryForObject] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CqlOperations.queryForObject(cql: String, entityClass: KClass<T>, vararg args: Any): T? =
|
||||
queryForObject(cql, entityClass.java, args)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CqlOperations.queryForObject(cql: String, vararg args: Any): T? =
|
||||
queryForObject(cql, T::class.java, args)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
fun <T : Any> CqlOperations.queryForObject(cql: String, vararg args: Any, function: (Row, Int) -> T): T? =
|
||||
queryForObject(cql, function, args)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.queryForObject] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CqlOperations.queryForObject(statement: Statement, entityClass: KClass<T>): T? =
|
||||
queryForObject(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> CqlOperations.queryForObject(statement: Statement): T? =
|
||||
queryForObject(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.queryForList] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> CqlOperations.queryForList(cql: String): List<T> =
|
||||
queryForList(cql, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.queryForList] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> CqlOperations.queryForList(cql: String, vararg args: Any): List<T> =
|
||||
queryForList(cql, T::class.java, args)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.queryForList] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> CqlOperations.queryForList(statement: Statement, entityClass: KClass<T>): List<T> =
|
||||
queryForList(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.queryForList] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> CqlOperations.queryForList(statement: Statement): List<T> =
|
||||
queryForList(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.query] providing a ResultSetExtractor-like function
|
||||
* variant: `query("...", arg1, argN){ rs -> }`.
|
||||
*/
|
||||
inline fun <reified T : Any> CqlOperations.query(cql: String, vararg args: Any, crossinline function: (ResultSet) -> T): T? =
|
||||
query(cql, ResultSetExtractor { function(it) }, *args)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.query] providing a RowCallbackHandler-like function
|
||||
* variant: `query("...", arg1, argN){ rs -> }`.
|
||||
*/
|
||||
fun CqlOperations.query(cql: String, vararg args: Any, function: (Row) -> Unit): Unit =
|
||||
query(cql, RowCallbackHandler { function(it) }, *args)
|
||||
|
||||
/**
|
||||
* Extension for [CqlOperations.query] providing a RowMapper-like function
|
||||
* variant: `query("...", arg1, argN){ row, i -> }`.
|
||||
*/
|
||||
fun <T : Any> CqlOperations.query(cql: String, vararg args: Any, function: (Row, Int) -> T): List<T> =
|
||||
query(cql, RowMapper { row, i -> function(row, i) }, *args)
|
||||
@@ -0,0 +1,114 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core.cql
|
||||
|
||||
import com.datastax.driver.core.Row
|
||||
import com.datastax.driver.core.Statement
|
||||
import org.reactivestreams.Publisher
|
||||
import org.springframework.data.cassandra.ReactiveResultSet
|
||||
import reactor.core.publisher.Flux
|
||||
import reactor.core.publisher.Mono
|
||||
import kotlin.reflect.KClass
|
||||
|
||||
/**
|
||||
* Extensions for [ReactiveCqlOperations].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.queryForObject] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCqlOperations.queryForObject(cql: String, entityClass: KClass<T>): Mono<T> =
|
||||
queryForObject(cql, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCqlOperations.queryForObject(cql: String): Mono<T> =
|
||||
queryForObject(cql, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.queryForObject] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCqlOperations.queryForObject(cql: String, entityClass: KClass<T>, vararg args: Any): Mono<T> =
|
||||
queryForObject(cql, entityClass.java, args)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCqlOperations.queryForObject(cql: String, vararg args: Any): Mono<T> =
|
||||
queryForObject(cql, T::class.java, args)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
fun <T : Any> ReactiveCqlOperations.queryForObject(cql: String, vararg args: Any, function: (Row, Int) -> T): Mono<T> =
|
||||
queryForObject(cql, function, args)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.queryForObject] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCqlOperations.queryForObject(statement: Statement, entityClass: KClass<T>): Mono<T> =
|
||||
queryForObject(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.queryForObject] leveraging reified type parameters.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCqlOperations.queryForObject(statement: Statement): Mono<T> =
|
||||
queryForObject(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.queryForFlux] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> ReactiveCqlOperations.queryForFlux(cql: String): Flux<T> =
|
||||
queryForFlux(cql, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.queryForFlux] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> ReactiveCqlOperations.queryForFlux(cql: String, vararg args: Any): Flux<T> =
|
||||
queryForFlux(cql, T::class.java, args)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.queryForFlux] providing a [KClass] based variant.
|
||||
*/
|
||||
fun <T : Any> ReactiveCqlOperations.queryForFlux(statement: Statement, entityClass: KClass<T>): Flux<T> =
|
||||
queryForFlux(statement, entityClass.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.queryForFlux] leveraging reified type parameters.
|
||||
*/
|
||||
@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
|
||||
inline fun <reified T : Any> ReactiveCqlOperations.queryForFlux(statement: Statement): Flux<T> =
|
||||
queryForFlux(statement, T::class.java)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.query] providing a ResultSetExtractor-like function
|
||||
* variant: `query("...", arg1, argN){ rs -> }`.
|
||||
*/
|
||||
inline fun <reified T : Any> ReactiveCqlOperations.query(cql: String, vararg args: Any, crossinline function: (ReactiveResultSet) -> Publisher<T>): Flux<T> =
|
||||
query(cql, ReactiveResultSetExtractor { function(it) }, *args)
|
||||
|
||||
/**
|
||||
* Extension for [ReactiveCqlOperations.query] providing a RowMapper-like function
|
||||
* variant: `query("...", arg1, argN){ row, i -> }`.
|
||||
*/
|
||||
fun <T : Any> ReactiveCqlOperations.query(cql: String, vararg args: Any, function: (Row, Int) -> T): Flux<T> =
|
||||
query(cql, RowMapper { row, i -> function(row, i) }, *args)
|
||||
@@ -0,0 +1,62 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core.query
|
||||
|
||||
/**
|
||||
* Extensions for [Criteria].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [Criteria. is] providing an `isEqualTo` alias since `in` is a reserved keyword in Kotlin.
|
||||
*/
|
||||
fun Criteria.isEqualTo(o: Any?): CriteriaDefinition = `is`(o)
|
||||
|
||||
/**
|
||||
* Extension for [Criteria. in] providing an `inValues` alias since `in` is a reserved keyword in Kotlin.
|
||||
*/
|
||||
fun <T : Any?> Criteria.inValues(c: Collection<T>): CriteriaDefinition = `in`(c)
|
||||
|
||||
/**
|
||||
* Extension for [Criteria. in] providing an `inValues` alias since `in` is a reserved keyword in Kotlin.
|
||||
*/
|
||||
fun Criteria.inValues(vararg o: Any?): CriteriaDefinition = `in`(*o)
|
||||
|
||||
/**
|
||||
* Extension for [CriteriaDefinition] to concatenate [CriteriaDefinition] using infix and.
|
||||
*/
|
||||
infix fun CriteriaDefinition.and(criteriaDefinition: CriteriaDefinition): CriteriaDefinitions {
|
||||
return CriteriaDefinitions(listOf(this, criteriaDefinition))
|
||||
}
|
||||
|
||||
/**
|
||||
* Extension for [where] providing a global where alias for an improved DSL.
|
||||
*/
|
||||
fun where(columnName: String): Criteria = Criteria.where(columnName)
|
||||
|
||||
/**
|
||||
* Extension for [CriteriaDefinitions] adding and infix operator to [CriteriaDefinitions].
|
||||
*/
|
||||
infix fun CriteriaDefinitions.and(criteriaDefinition: CriteriaDefinition): CriteriaDefinitions {
|
||||
return CriteriaDefinitions(this.criteriaDefinitions + listOf(criteriaDefinition))
|
||||
}
|
||||
|
||||
/**
|
||||
* Utility class to hold multiple [CriteriaDefinition].
|
||||
*/
|
||||
class CriteriaDefinitions(internal val criteriaDefinitions: List<CriteriaDefinition>)
|
||||
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core.query
|
||||
|
||||
/**
|
||||
* Extensions for [Query].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
* @since 2.1
|
||||
*/
|
||||
|
||||
/**
|
||||
* Extension for [Query.query] providing a global query alias for an improved DSL.
|
||||
*/
|
||||
fun query(criteria: Criteria): Query = Query.query(criteria)
|
||||
|
||||
/**
|
||||
* Extension for [Query.query] providing a global query alias for an improved DSL.
|
||||
*/
|
||||
fun query(criteriaDefinitions: CriteriaDefinitions): Query = Query.query(criteriaDefinitions.criteriaDefinitions)
|
||||
|
||||
@@ -0,0 +1,353 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.datastax.driver.core.SimpleStatement
|
||||
import com.nhaarman.mockito_kotlin.any
|
||||
import com.nhaarman.mockito_kotlin.eq
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.core.query.Query
|
||||
import org.springframework.data.cassandra.core.query.Update
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
import java.util.function.Consumer
|
||||
|
||||
/**
|
||||
* Unit tests for [AsyncCassandraOperationsExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class AsyncCassandraOperationsExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: AsyncCassandraOperations
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with static CQL
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(String, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.select("SELECT * FROM person", Person::class)
|
||||
verify(operations).select("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(String) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.select<Person>("SELECT * FROM person")
|
||||
verify(operations).select("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(String, KClass, Consumer) extension should call its Java counterpart`() {
|
||||
|
||||
operations.select("SELECT * FROM person", Person::class) { p -> p.toString() }
|
||||
verify(operations).select(eq("SELECT * FROM person"), any<Consumer<Person>>(), eq(Person::class.java))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(String, Consumer) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.select<Person>("SELECT * FROM person") { p -> p.toString() }
|
||||
verify(operations).select(eq("SELECT * FROM person"), any<Consumer<Person>>(), eq(Person::class.java))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(String, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOne("SELECT * FROM person", Person::class)
|
||||
verify(operations).selectOne("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(String) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOne<Person>("SELECT * FROM person")
|
||||
verify(operations).selectOne("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with com.datastax.driver.core.Statement
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.select(statement, Person::class)
|
||||
verify(operations).select(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Statement) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
operations.select<Person>(statement)
|
||||
verify(operations).select(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Statement, KClass, Consumer) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.select(statement, Person::class) { p -> p.toString() }
|
||||
verify(operations).select(eq(statement), any<Consumer<Person>>(), eq(Person::class.java))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Statement, Consumer) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.select<Person>(statement) { p -> p.toString() }
|
||||
verify(operations).select(eq(statement), any<Consumer<Person>>(), eq(Person::class.java))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `slice(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.slice(statement, Person::class)
|
||||
verify(operations).slice(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `slice(Statement) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.slice<Person>(statement)
|
||||
verify(operations).slice(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.selectOne(statement, Person::class)
|
||||
verify(operations).selectOne(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Statement) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.selectOne<Person>(statement)
|
||||
verify(operations).selectOne(statement, Person::class.java)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with org.springframework.data.cassandra.core.query.Query
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.select(Query.empty(), Person::class)
|
||||
verify(operations).select(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.select<Person>(Query.empty())
|
||||
verify(operations).select(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Query, KClass, Consumer) extension should call its Java counterpart`() {
|
||||
|
||||
operations.select(Query.empty(), Person::class) { p -> p.toString() }
|
||||
verify(operations).select(eq(Query.empty()), any<Consumer<Person>>(), eq(Person::class.java))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Query, Consumer) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.select<Person>(Query.empty()) { p -> p.toString() }
|
||||
verify(operations).select(eq(Query.empty()), any<Consumer<Person>>(), eq(Person::class.java))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `slice(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.slice(Query.empty(), Person::class)
|
||||
verify(operations).slice(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `slice(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.slice<Person>(Query.empty())
|
||||
verify(operations).slice(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOne(Query.empty(), Person::class)
|
||||
verify(operations).selectOne(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOne<Person>(Query.empty())
|
||||
verify(operations).selectOne(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `update(Query, Update, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.update(Query.empty(), Update.empty(), Person::class)
|
||||
verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `update(Query, Update) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.update<Person>(Query.empty(), Update.empty())
|
||||
verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `delete(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.delete(Query.empty(), Person::class)
|
||||
verify(operations).delete(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `delete(Query,) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.delete<Person>(Query.empty())
|
||||
verify(operations).delete(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with entities
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.count(Person::class)
|
||||
verify(operations).count(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.count<Person>()
|
||||
verify(operations).count(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.count(Query.empty(), Person::class)
|
||||
verify(operations).count(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.count<Person>(Query.empty())
|
||||
verify(operations).count(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Any, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists("id", Person::class)
|
||||
verify(operations).exists("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Any) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists<Person>("id")
|
||||
verify(operations).exists("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists(Query.empty(), Person::class)
|
||||
verify(operations).exists(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists<Person>(Query.empty())
|
||||
verify(operations).exists(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOneById(Any, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOneById("id", Person::class)
|
||||
verify(operations).selectOneById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOneById(Any) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOneById<Person>("id")
|
||||
verify(operations).selectOneById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `deleteById(Any, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.deleteById("id", Person::class)
|
||||
verify(operations).deleteById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `deleteById(Any) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.deleteById<Person>("id")
|
||||
verify(operations).deleteById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `truncate(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.truncate(Person::class)
|
||||
verify(operations).truncate(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `truncate() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.truncate<Person>()
|
||||
verify(operations).truncate(Person::class.java)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,392 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.datastax.driver.core.SimpleStatement
|
||||
import com.nhaarman.mockito_kotlin.doReturn
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import com.nhaarman.mockito_kotlin.whenever
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.core.cql.CqlIdentifier
|
||||
import org.springframework.data.cassandra.core.query.Query
|
||||
import org.springframework.data.cassandra.core.query.Update
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
import org.springframework.data.domain.SliceImpl
|
||||
|
||||
/**
|
||||
* Unit tests for [CassandraOperationsExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class CassandraOperationsExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: CassandraOperations
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `getTableName(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
doReturn(CqlIdentifier.of("person")).whenever(operations).getTableName(Person::class.java)
|
||||
|
||||
operations.getTableName(Person::class)
|
||||
verify(operations).getTableName(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `getTableName() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
doReturn(CqlIdentifier.of("person")).whenever(operations).getTableName(Person::class.java)
|
||||
|
||||
operations.getTableName<Person>()
|
||||
verify(operations).getTableName(Person::class.java)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with static CQL
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(String, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.select("SELECT * FROM person", Person::class)
|
||||
verify(operations).select("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(String) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.select<Person>("SELECT * FROM person")
|
||||
verify(operations).select("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `stream(String, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.stream("SELECT * FROM person", Person::class)
|
||||
verify(operations).stream("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `stream(String) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.stream<Person>("SELECT * FROM person")
|
||||
verify(operations).stream("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(String, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
doReturn(Person("Walter", "White")).whenever(operations).selectOne("SELECT * FROM person", Person::class.java)
|
||||
|
||||
operations.selectOne("SELECT * FROM person", Person::class)
|
||||
verify(operations).selectOne("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(String) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
doReturn(Person("Walter", "White")).whenever(operations).selectOne("SELECT * FROM person", Person::class.java)
|
||||
|
||||
operations.selectOne<Person>("SELECT * FROM person")
|
||||
verify(operations).selectOne("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with com.datastax.driver.core.Statement
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.select(statement, Person::class)
|
||||
verify(operations).select(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Statement) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
operations.select<Person>(statement)
|
||||
verify(operations).select(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `slice(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
doReturn(SliceImpl(listOf(Person("Walter", "White")))).whenever(operations).slice(statement, Person::class.java)
|
||||
|
||||
operations.slice(statement, Person::class)
|
||||
verify(operations).slice(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `slice(Statement) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
doReturn(SliceImpl(listOf(Person("Walter", "White")))).whenever(operations).slice(statement, Person::class.java)
|
||||
|
||||
operations.slice<Person>(statement)
|
||||
verify(operations).slice(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `stream(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.stream(statement, Person::class)
|
||||
verify(operations).stream(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `stream(Statement) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.stream<Person>(statement)
|
||||
verify(operations).stream(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
doReturn(Person("Walter", "White")).whenever(operations).selectOne(statement, Person::class.java)
|
||||
|
||||
operations.selectOne(statement, Person::class)
|
||||
verify(operations).selectOne(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Statement) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
doReturn(Person("Walter", "White")).whenever(operations).selectOne(statement, Person::class.java)
|
||||
|
||||
operations.selectOne<Person>(statement)
|
||||
verify(operations).selectOne(statement, Person::class.java)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with org.springframework.data.cassandra.core.query.Query
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.select(Query.empty(), Person::class)
|
||||
verify(operations).select(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.select<Person>(Query.empty())
|
||||
verify(operations).select(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `slice(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
doReturn(SliceImpl(listOf(Person("Walter", "White")))).whenever(operations).slice(Query.empty(), Person::class.java)
|
||||
|
||||
operations.slice(Query.empty(), Person::class)
|
||||
verify(operations).slice(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `slice(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
doReturn(SliceImpl(listOf(Person("Walter", "White")))).whenever(operations).slice(Query.empty(), Person::class.java)
|
||||
|
||||
operations.slice<Person>(Query.empty())
|
||||
verify(operations).slice(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `stream(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.stream(Query.empty(), Person::class)
|
||||
verify(operations).stream(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `stream(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.stream<Person>(Query.empty())
|
||||
verify(operations).stream(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
doReturn(Person("Walter", "White")).whenever(operations).selectOne(Query.empty(), Person::class.java)
|
||||
|
||||
operations.selectOne(Query.empty(), Person::class)
|
||||
verify(operations).selectOne(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
doReturn(Person("Walter", "White")).whenever(operations).selectOne(Query.empty(), Person::class.java)
|
||||
|
||||
operations.selectOne<Person>(Query.empty())
|
||||
verify(operations).selectOne(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `update(Query, Update, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.update(Query.empty(), Update.empty(), Person::class)
|
||||
verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `update(Query, Update) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.update<Person>(Query.empty(), Update.empty())
|
||||
verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `delete(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.delete(Query.empty(), Person::class)
|
||||
verify(operations).delete(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `delete(Query,) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.delete<Person>(Query.empty())
|
||||
verify(operations).delete(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with entities
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.count(Person::class)
|
||||
verify(operations).count(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.count<Person>()
|
||||
verify(operations).count(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.count(Query.empty(), Person::class)
|
||||
verify(operations).count(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.count<Person>(Query.empty())
|
||||
verify(operations).count(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Any, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists("id", Person::class)
|
||||
verify(operations).exists("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Any) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists<Person>("id")
|
||||
verify(operations).exists("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists(Query.empty(), Person::class)
|
||||
verify(operations).exists(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists<Person>(Query.empty())
|
||||
verify(operations).exists(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOneById(Any, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
doReturn(Person("Walter", "White")).whenever(operations).selectOneById("id", Person::class.java)
|
||||
|
||||
operations.selectOneById("id", Person::class)
|
||||
verify(operations).selectOneById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOneById(Any) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
doReturn(Person("Walter", "White")).whenever(operations).selectOneById("id", Person::class.java)
|
||||
|
||||
operations.selectOneById<Person>("id")
|
||||
verify(operations).selectOneById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `deleteById(Any, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.deleteById("id", Person::class)
|
||||
verify(operations).deleteById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `deleteById(Any) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.deleteById<Person>("id")
|
||||
verify(operations).deleteById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `truncate(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.truncate(Person::class)
|
||||
verify(operations).truncate(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `truncate() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.truncate<Person>()
|
||||
verify(operations).truncate(Person::class.java)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
|
||||
/**
|
||||
* Unit tests for [ExecutableDeleteOperationExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class ExecutableDeleteOperationExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: FluentCassandraOperations
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `delete(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.delete(Person::class);
|
||||
verify(operations).delete(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `delete() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.delete<Person>()
|
||||
verify(operations).delete(Person::class.java)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
|
||||
/**
|
||||
* Unit tests for [ExecutableInsertOperationExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class ExecutableInsertOperationExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: FluentCassandraOperations
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `insert(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.insert(Person::class);
|
||||
verify(operations).insert(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `insert() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.insert<Person>()
|
||||
verify(operations).insert(Person::class.java)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
import org.springframework.data.cassandra.domain.User
|
||||
|
||||
/**
|
||||
* Unit tests for [ExecutableSelectOperationExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class ExecutableSelectOperationExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: FluentCassandraOperations
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operationWithProjection: ExecutableSelectOperation.SelectWithProjection<User>
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `query(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.query(Person::class);
|
||||
verify(operations).query(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `query() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.query<Person>()
|
||||
verify(operations).query(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `asType(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operationWithProjection.asType(User::class);
|
||||
verify(operationWithProjection).`as`(User::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `asType() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operationWithProjection.asType<User>();
|
||||
verify(operationWithProjection).`as`(User::class.java)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
|
||||
/**
|
||||
* Unit tests for [ExecutableUpdateOperationExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class ExecutableUpdateOperationExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: FluentCassandraOperations
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `update(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.update(Person::class);
|
||||
verify(operations).update(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `update() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.update<Person>()
|
||||
verify(operations).update(Person::class.java)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,272 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.datastax.driver.core.SimpleStatement
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.core.query.Query
|
||||
import org.springframework.data.cassandra.core.query.Update
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
|
||||
/**
|
||||
* Unit tests for [ReactiveCassandraOperationsExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class ReactiveCassandraOperationsExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: ReactiveCassandraOperations
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with static CQL
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(String, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.select("SELECT * FROM person", Person::class)
|
||||
verify(operations).select("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(String) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.select<Person>("SELECT * FROM person")
|
||||
verify(operations).select("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(String, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOne("SELECT * FROM person", Person::class)
|
||||
verify(operations).selectOne("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(String) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOne<Person>("SELECT * FROM person")
|
||||
verify(operations).selectOne("SELECT * FROM person", Person::class.java)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with com.datastax.driver.core.Statement
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.select(statement, Person::class)
|
||||
verify(operations).select(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Statement) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
operations.select<Person>(statement)
|
||||
verify(operations).select(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.selectOne(statement, Person::class)
|
||||
verify(operations).selectOne(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Statement) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.selectOne<Person>(statement)
|
||||
verify(operations).selectOne(statement, Person::class.java)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with org.springframework.data.cassandra.core.query.Query
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.select(Query.empty(), Person::class)
|
||||
verify(operations).select(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `select(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.select<Person>(Query.empty())
|
||||
verify(operations).select(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOne(Query.empty(), Person::class)
|
||||
verify(operations).selectOne(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOne(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOne<Person>(Query.empty())
|
||||
verify(operations).selectOne(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `update(Query, Update, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.update(Query.empty(), Update.empty(), Person::class)
|
||||
verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `update(Query, Update) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.update<Person>(Query.empty(), Update.empty())
|
||||
verify(operations).update(Query.empty(), Update.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `delete(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.delete(Query.empty(), Person::class)
|
||||
verify(operations).delete(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `delete(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.delete<Person>(Query.empty())
|
||||
verify(operations).delete(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Methods dealing with entities
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.count(Person::class)
|
||||
verify(operations).count(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.count<Person>()
|
||||
verify(operations).count(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.count(Query.empty(), Person::class)
|
||||
verify(operations).count(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `count(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.count<Person>(Query.empty())
|
||||
verify(operations).count(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Any, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists("id", Person::class)
|
||||
verify(operations).exists("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Any) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists<Person>("id")
|
||||
verify(operations).exists("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Query, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists(Query.empty(), Person::class)
|
||||
verify(operations).exists(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `exists(Query) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.exists<Person>(Query.empty())
|
||||
verify(operations).exists(Query.empty(), Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOneById(Any, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOneById("id", Person::class)
|
||||
verify(operations).selectOneById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `selectOneById(Any) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.selectOneById<Person>("id")
|
||||
verify(operations).selectOneById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `deleteById(Any, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.deleteById("id", Person::class)
|
||||
verify(operations).deleteById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `deleteById(Any) with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.deleteById<Person>("id")
|
||||
verify(operations).deleteById("id", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `truncate(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.truncate(Person::class)
|
||||
verify(operations).truncate(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `truncate() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.truncate<Person>()
|
||||
verify(operations).truncate(Person::class.java)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
|
||||
/**
|
||||
* Unit tests for [ReactiveDeleteOperationExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class ReactiveDeleteOperationExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: ReactiveFluentCassandraOperations
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `delete(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.delete(Person::class);
|
||||
verify(operations).delete(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `delete() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.delete<Person>()
|
||||
verify(operations).delete(Person::class.java)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
|
||||
/**
|
||||
* Unit tests for [ReactiveInsertOperationExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class ReactiveInsertOperationExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: ReactiveFluentCassandraOperations
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `insert(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.insert(Person::class);
|
||||
verify(operations).insert(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `insert() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.insert<Person>()
|
||||
verify(operations).insert(Person::class.java)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
import org.springframework.data.cassandra.domain.User
|
||||
|
||||
/**
|
||||
* Unit tests for [ReactiveSelectOperationExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class ReactiveSelectOperationExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: ReactiveFluentCassandraOperations
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operationWithProjection: ReactiveSelectOperation.SelectWithProjection<User>
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `query(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.query(Person::class);
|
||||
verify(operations).query(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `query() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.query<Person>()
|
||||
verify(operations).query(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `asType(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operationWithProjection.asType(User::class);
|
||||
verify(operationWithProjection).`as`(User::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `asType() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operationWithProjection.asType<User>();
|
||||
verify(operationWithProjection).`as`(User::class.java)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core
|
||||
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
|
||||
/**
|
||||
* Unit tests for [ReactiveUpdateOperationExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class ReactiveUpdateOperationExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: ReactiveFluentCassandraOperations
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `update(KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.update(Person::class);
|
||||
verify(operations).update(Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `update() with reified type parameter extension should call its Java counterpart`() {
|
||||
|
||||
operations.update<Person>()
|
||||
verify(operations).update(Person::class.java)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core.cql
|
||||
|
||||
import com.datastax.driver.core.Row
|
||||
import com.datastax.driver.core.SimpleStatement
|
||||
import com.nhaarman.mockito_kotlin.any
|
||||
import com.nhaarman.mockito_kotlin.eq
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Ignore
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
|
||||
/**
|
||||
* Unit tests for [AsyncCqlOperationsExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class AsyncCqlOperationsExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: AsyncCqlOperations
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject("", Person::class)
|
||||
verify(operations).queryForObject("", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject<Person>("")
|
||||
verify(operations).queryForObject("", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, KClass, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject("", Person::class, "foo", "bar")
|
||||
verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject<Person>("", "foo", "bar")
|
||||
verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, RowMapper, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject("", 3) { rs: Row, _: Int -> rs.getInt(1) }
|
||||
verify(operations).queryForObject(eq(""), any<RowMapper<Int>>(), eq(3))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForObject(statement, Person::class)
|
||||
verify(operations).queryForObject(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(Statement) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForObject<Person>(statement)
|
||||
verify(operations).queryForObject(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForList(String) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForList<Person>("")
|
||||
verify(operations).queryForList("", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForList(String, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForList<Person>("", "foo", "bar")
|
||||
verify(operations).queryForList("", Person::class.java, arrayOf("foo", "bar"))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
@Ignore("No such method: queryForList(CQL, RowMapper, Args), see DATACASS-538")
|
||||
fun `queryForList(String, RowMapper, array) extension should call its Java counterpart`() {
|
||||
|
||||
//operations.queryForList("", 3) { rs: Row, _: Int -> rs.getInt(1) }
|
||||
verify(operations).queryForList(eq(""), any<RowMapper<Int>>(), eq(3))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForList(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForList(statement, Person::class)
|
||||
verify(operations).queryForList(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForList(Statement) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForList<Person>(statement)
|
||||
verify(operations).queryForList(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `query(String, ResultSetExtractor, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.query("", 3) { rs -> Person("Walter", rs.single().getString(0)) }
|
||||
verify(operations).query(eq(""), any<ResultSetExtractor<Person>>(), eq(3))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `query(String, RowMapper, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.query("", 3) { row, _ -> row.columnDefinitions }
|
||||
verify(operations).query(eq(""), any<RowMapper<Person>>(), eq(3))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core.cql
|
||||
|
||||
import com.datastax.driver.core.Row
|
||||
import com.datastax.driver.core.SimpleStatement
|
||||
import com.nhaarman.mockito_kotlin.any
|
||||
import com.nhaarman.mockito_kotlin.eq
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Ignore
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
|
||||
/**
|
||||
* Unit tests for [CqlOperationsExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class CqlOperationsExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: CqlOperations
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject("", Person::class)
|
||||
verify(operations).queryForObject("", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject<Person>("")
|
||||
verify(operations).queryForObject("", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, KClass, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject("", Person::class, "foo", "bar")
|
||||
verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject<Person>("", "foo", "bar")
|
||||
verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, RowMapper, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject("", 3) { rs: Row, _: Int -> rs.getInt(1) }
|
||||
verify(operations).queryForObject(eq(""), any<RowMapper<Int>>(), eq(3))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForObject(statement, Person::class)
|
||||
verify(operations).queryForObject(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(Statement) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForObject<Person>(statement)
|
||||
verify(operations).queryForObject(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForList(String) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForList<Person>("")
|
||||
verify(operations).queryForList("", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForList(String, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForList<Person>("", "foo", "bar")
|
||||
verify(operations).queryForList("", Person::class.java, arrayOf("foo", "bar"))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
@Ignore("No such method: queryForList(CQL, RowMapper, Args), see DATACASS-538")
|
||||
fun `queryForList(String, RowMapper, array) extension should call its Java counterpart`() {
|
||||
|
||||
//operations.queryForList("", 3) { rs: Row, _: Int -> rs.getInt(1) }
|
||||
verify(operations).queryForList(eq(""), any<RowMapper<Int>>(), eq(3))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForList(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForList(statement, Person::class)
|
||||
verify(operations).queryForList(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForList(Statement) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForList<Person>(statement)
|
||||
verify(operations).queryForList(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `query(String, ResultSetExtractor, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.query<Person>("", 3) { rs -> Person("Walter", rs.single().getString(0)) }
|
||||
verify(operations).query(eq(""), any<ResultSetExtractor<Person>>(), eq(3))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `query(String, RowCallbackHandler, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.query("", 3) { row -> row.columnDefinitions }
|
||||
verify(operations).query(eq(""), any(), eq(3))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `query(String, RowMapper, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.query("", 3) { row, _ -> row.columnDefinitions }
|
||||
verify(operations).query(eq(""), any<RowMapper<Person>>(), eq(3))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core.cql
|
||||
|
||||
import com.datastax.driver.core.Row
|
||||
import com.datastax.driver.core.SimpleStatement
|
||||
import com.nhaarman.mockito_kotlin.any
|
||||
import com.nhaarman.mockito_kotlin.eq
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.junit.Ignore
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
import org.springframework.data.cassandra.domain.Person
|
||||
|
||||
/**
|
||||
* Unit tests for [ReactiveCqlOperationsExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class ReactiveCqlOperationsExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var operations: ReactiveCqlOperations
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject("", Person::class)
|
||||
verify(operations).queryForObject("", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject<Person>("")
|
||||
verify(operations).queryForObject("", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, KClass, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject("", Person::class, "foo", "bar")
|
||||
verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject<Person>("", "foo", "bar")
|
||||
verify(operations).queryForObject("", Person::class.java, arrayOf("foo", "bar"))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(String, RowMapper, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForObject("", 3) { rs: Row, _: Int -> rs.getInt(1) }
|
||||
verify(operations).queryForObject(eq(""), any<RowMapper<Int>>(), eq(3))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForObject(statement, Person::class)
|
||||
verify(operations).queryForObject(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForObject(Statement) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForObject<Person>(statement)
|
||||
verify(operations).queryForObject(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForFlux(String) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForFlux<Person>("")
|
||||
verify(operations).queryForFlux("", Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForFlux(String, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.queryForFlux<Person>("", "foo", "bar")
|
||||
verify(operations).queryForFlux("", Person::class.java, arrayOf("foo", "bar"))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
@Ignore("No such method: queryForFlux(CQL, RowMapper, Args), see DATACASS-538")
|
||||
fun `queryForFlux(String, RowMapper, array) extension should call its Java counterpart`() {
|
||||
|
||||
//operations.queryForFlux("", 3) { rs: Row, _: Int -> rs.getInt(1) }
|
||||
verify(operations).queryForFlux(eq(""), any<RowMapper<Int>>(), eq(3))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForFlux(Statement, KClass) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForFlux(statement, Person::class)
|
||||
verify(operations).queryForFlux(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `queryForFlux(Statement) extension should call its Java counterpart`() {
|
||||
|
||||
val statement = SimpleStatement("SELECT * FROM person")
|
||||
|
||||
operations.queryForFlux<Person>(statement)
|
||||
verify(operations).queryForFlux(statement, Person::class.java)
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `query(String, ResultSetExtractor, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.query("", 3) { rs -> rs.rows().next().cast(Person::class.java) }
|
||||
verify(operations).query(eq(""), any<ReactiveResultSetExtractor<Person>>(), eq(3))
|
||||
}
|
||||
|
||||
@Test // DATACASS-484
|
||||
fun `query(String, RowMapper, array) extension should call its Java counterpart`() {
|
||||
|
||||
operations.query("", 3) { row, _ -> row.columnDefinitions }
|
||||
verify(operations).query(eq(""), any<RowMapper<Person>>(), eq(3))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core.query
|
||||
|
||||
import com.nhaarman.mockito_kotlin.verify
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
import org.mockito.Answers
|
||||
import org.mockito.Mock
|
||||
import org.mockito.Mockito
|
||||
import org.mockito.junit.MockitoJUnitRunner
|
||||
|
||||
/**
|
||||
* Unit tests for [CriteriaExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner::class)
|
||||
class CriteriaExtensionsUnitTests {
|
||||
|
||||
@Mock(answer = Answers.RETURNS_MOCKS)
|
||||
lateinit var criteria: Criteria
|
||||
|
||||
@Test
|
||||
fun `isEqualTo() extension should call its Java counterpart`() {
|
||||
|
||||
val foo = "foo"
|
||||
criteria.isEqualTo(foo)
|
||||
|
||||
verify(criteria).`is`(foo)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `isEqualTo() extension should support nullable value`() {
|
||||
|
||||
criteria.isEqualTo(null)
|
||||
|
||||
verify(criteria).`is`(null)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `inValues(varags) extension should call its Java counterpart`() {
|
||||
|
||||
val foo = "foo"
|
||||
val bar = "bar"
|
||||
|
||||
criteria.inValues(foo, bar)
|
||||
|
||||
Mockito.verify(criteria).`in`(foo, bar)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `inValues(varags) extension should support nullable values`() {
|
||||
|
||||
criteria.inValues(null, null)
|
||||
|
||||
Mockito.verify(criteria).`in`(null, null)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `inValues(Collection) extension should call its Java counterpart`() {
|
||||
|
||||
val c = listOf("foo", "bar")
|
||||
|
||||
criteria.inValues(c)
|
||||
|
||||
verify(criteria).`in`(c)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `inValues(Collection) extension should support nullable values`() {
|
||||
|
||||
val c = listOf("foo", null, "bar")
|
||||
|
||||
criteria.inValues(c)
|
||||
|
||||
verify(criteria).`in`(c)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `where(String) should create Criteria`() {
|
||||
|
||||
val criteria = where("foo").isEqualTo("bar");
|
||||
|
||||
assertThat(criteria.columnName.toCql()).isEqualTo("foo")
|
||||
assertThat(criteria.predicate).isNotNull()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `and(CriteriaDefinition) should concatenate criteria`() {
|
||||
|
||||
val criteriaDefinitions = where("foo").isEqualTo("bar") and where("baz").isEqualTo("bar") and where("name").isEqualTo("Doe")
|
||||
|
||||
assertThat(criteriaDefinitions.criteriaDefinitions).hasSize(3)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
/*
|
||||
* Copyright 2018 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.springframework.data.cassandra.core.query
|
||||
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.junit.Test
|
||||
|
||||
/**
|
||||
* Unit tests for [QueryExtensions].
|
||||
*
|
||||
* @author Mark Paluch
|
||||
*/
|
||||
class QueryExtensionsUnitTests {
|
||||
|
||||
@Test
|
||||
fun `should create query from concatenated criteria`() {
|
||||
|
||||
val query = query(where("foo").isEqualTo("bar") and //
|
||||
where("baz").isEqualTo("bar") and //
|
||||
where("name").isEqualTo("Doe"))
|
||||
|
||||
assertThat(query.toString()).contains("foo = 'bar' AND baz = 'bar' AND name = 'Doe'")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@ This chapter summarizes changes and new features for each release.
|
||||
* Support for Cassandra `time` columns via `LocalTime`.
|
||||
* Support for `map` columns using User-defined/converted types.
|
||||
* <<cassandra.mapping-usage.events>>
|
||||
* Kotlin extensions for Template API.
|
||||
|
||||
[[new-features.2-0-0]]
|
||||
== What's new in Spring Data for Apache Cassandra 2.0
|
||||
|
||||
Reference in New Issue
Block a user