Spring/spring-data-cassandra
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

DATACASS-485 - Imperative Fluent Cassandra API.

Browse Source 
We now provide an alternative API for CassandraOperations that allows defining operations in a fluent way. FluentCassandraOperations reduces the number of methods and strips down the interface to a minimum while offering a more readable API.

// select with filter query and projecting return type
template.query(Person.class)
    .as(Jedi.class)
    .matching(query(where("firstname").is("luke")))
    .all();

// insert
template.insert(Person.class)
    .inTable(STAR_WARS)
    .one(luke);

// update
template.update(Person.class)
    .apply(update("firstname", "Han"))
    .matching(query(where("id").is("han-solo")))
    .all();

// remove all matching
template.delete(Jedi.class)
    .inTable(STAR_WARS)
    .matching(query(where("name").is("luke")))
    .all();
This commit is contained in:
Mark Paluch
2018-01-26 11:53:06 +01:00
committed by John Blum
parent 7411dfee55
commit 1a3314a650
17 changed files with 1972 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraAdminTemplate.java
View File

@@ -64,8 +64,7 @@ public class CassandraAdminTemplate extends CassandraTemplate implements Cassand
super(sessionFactory, converter);
}
/*
* (non-Javadoc)
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraAdminOperations#createTable(boolean, org.springframework.data.cassandra.core.cql.CqlIdentifier, java.lang.Class, java.util.Map)
*/
@Override
@@ -84,8 +83,7 @@ public class CassandraAdminTemplate extends CassandraTemplate implements Cassand
dropTable(getTableName(entityClass));
}
/*
* (non-Javadoc)
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraAdminOperations#dropTable(org.springframework.data.cassandra.core.cql.CqlIdentifier)
*/
@Override
@@ -93,14 +91,16 @@ public class CassandraAdminTemplate extends CassandraTemplate implements Cassand
dropTable(false, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraAdminOperations#dropTable(boolean, CqlIdentifier)
*/
@Override
public void dropTable(boolean ifExists, CqlIdentifier tableName) {
getCqlOperations()
.execute(DropTableCqlGenerator.toCql(DropTableSpecification.dropTable(tableName).ifExists(ifExists)));
}
/*
* (non-Javadoc)
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraAdminOperations#dropUserType(org.springframework.data.cassandra.core.cql.CqlIdentifier)
*/
@Override
@@ -111,8 +111,7 @@ public class CassandraAdminTemplate extends CassandraTemplate implements Cassand
getCqlOperations().execute(DropUserTypeCqlGenerator.toCql(DropUserTypeSpecification.dropType(typeName)));
}
/*
* (non-Javadoc)
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraAdminOperations#getTableMetadata(java.lang.String, org.springframework.data.cassandra.core.cql.CqlIdentifier)
*/
@Override
@@ -125,8 +124,7 @@ public class CassandraAdminTemplate extends CassandraTemplate implements Cassand
.getCluster().getMetadata().getKeyspace(keyspace).getTable(tableName.toCql())));
}
/*
* (non-Javadoc)
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraAdminOperations#getKeyspaceMetadata()
*/
@Override

2
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraOperations.java
View File

@@ -47,7 +47,7 @@ import com.datastax.driver.core.Statement;
* @see InsertOptions
* @see UpdateOptions
*/
public interface CassandraOperations {
public interface CassandraOperations extends FluentCassandraOperations {
/**
* Returns a new {@link CassandraBatchOperations}. Each {@link CassandraBatchOperations} instance can be executed only

147
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraTemplate.java
View File

@@ -15,13 +15,14 @@
*/
package org.springframework.data.cassandra.core;
import java.util.List;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import lombok.NonNull;
import lombok.Value;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import org.springframework.dao.DataAccessException;
import org.springframework.data.cassandra.SessionFactory;
import org.springframework.data.cassandra.core.convert.CassandraConverter;
@@ -35,6 +36,7 @@ import org.springframework.data.cassandra.core.cql.CqlProvider;
import org.springframework.data.cassandra.core.cql.CqlTemplate;
import org.springframework.data.cassandra.core.cql.QueryOptions;
import org.springframework.data.cassandra.core.cql.SessionCallback;
import org.springframework.data.cassandra.core.cql.WriteOptions;
import org.springframework.data.cassandra.core.cql.session.DefaultSessionFactory;
import org.springframework.data.cassandra.core.mapping.CassandraMappingContext;
import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity;
@@ -42,11 +44,13 @@ import org.springframework.data.cassandra.core.mapping.CassandraPersistentProper
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.domain.Slice;
import org.springframework.data.mapping.context.MappingContext;
import org.springframework.data.projection.SpelAwareProxyProjectionFactory;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import com.datastax.driver.core.RegularStatement;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.Row;
import com.datastax.driver.core.Session;
import com.datastax.driver.core.SimpleStatement;
import com.datastax.driver.core.Statement;
@@ -85,6 +89,8 @@ public class CassandraTemplate implements CassandraOperations {
private final StatementFactory statementFactory;
private final SpelAwareProxyProjectionFactory projectionFactory;
/**
* Creates an instance of {@link CassandraTemplate} initialized with the given {@link Session} and a default
* {@link MappingCassandraConverter}.
@@ -144,6 +150,7 @@ public class CassandraTemplate implements CassandraOperations {
this.cqlOperations = cqlOperations;
this.mappingContext = converter.getMappingContext();
this.statementFactory = new StatementFactory(new QueryMapper(converter), new UpdateMapper(converter));
this.projectionFactory = new SpelAwareProxyProjectionFactory();
}
/* (non-Javadoc)
@@ -172,8 +179,8 @@ public class CassandraTemplate implements CassandraOperations {
}
/**
* Returns the {@link CassandraMappingContext} used by this template to access mapping meta-data
* in order to store (map) object to Cassandra tables.
* Returns the {@link CassandraMappingContext} used by this template to access mapping meta-data in order to store
* (map) object to Cassandra tables.
*
* @return the {@link CassandraMappingContext} used by this template.
* @see org.springframework.data.cassandra.core.mapping.CassandraMappingContext
@@ -264,7 +271,9 @@ public class CassandraTemplate implements CassandraOperations {
Assert.notNull(statement, "Statement must not be null");
Assert.notNull(entityClass, "Entity type must not be null");
return getCqlOperations().query(statement, (row, rowNum) -> getConverter().read(entityClass, row));
Function<Row, T> mapper = getMapper(entityClass, entityClass);
return getCqlOperations().query(statement, (row, rowNum) -> mapper.apply(row));
}
/* (non-Javadoc)
@@ -278,10 +287,9 @@ public class CassandraTemplate implements CassandraOperations {
ResultSet resultSet = getCqlOperations().queryForResultSet(statement);
CassandraConverter converter = getConverter();
Function<Row, T> mapper = getMapper(entityClass, entityClass);
return QueryUtils.readSlice(resultSet, (row, rowNum) -> converter.read(entityClass, row), 0,
getEffectiveFetchSize(statement));
return QueryUtils.readSlice(resultSet, (row, rowNum) -> mapper.apply(row), 0, getEffectiveFetchSize(statement));
}
/* (non-Javadoc)
@@ -294,7 +302,7 @@ public class CassandraTemplate implements CassandraOperations {
Assert.notNull(entityClass, "Entity type must not be null");
return StreamSupport.stream(getCqlOperations().queryForResultSet(statement).spliterator(), false)
.map(row -> getConverter().read(entityClass, row));
.map(getMapper(entityClass, entityClass));
}
/* (non-Javadoc)
@@ -318,8 +326,16 @@ public class CassandraTemplate implements CassandraOperations {
Assert.notNull(query, "Query must not be null");
Assert.notNull(entityClass, "Entity type must not be null");
return select(getStatementFactory().select(query, getMappingContext().getRequiredPersistentEntity(entityClass)),
entityClass);
return doSelect(query, entityClass, getTableName(entityClass), entityClass);
}
<T> List<T> doSelect(Query query, Class<?> entityClass, CqlIdentifier tableName, Class<T> returnType) {
Function<Row, T> mapper = getMapper(entityClass, returnType);
RegularStatement select = getStatementFactory().select(query,
getMappingContext().getRequiredPersistentEntity(entityClass), tableName);
return getCqlOperations().query(select, (row, rowNum) -> mapper.apply(row));
}
/* (non-Javadoc)
@@ -344,8 +360,16 @@ public class CassandraTemplate implements CassandraOperations {
Assert.notNull(query, "Query must not be null");
Assert.notNull(entityClass, "Entity type must not be null");
return stream(getStatementFactory().select(query, getMappingContext().getRequiredPersistentEntity(entityClass)),
entityClass);
return doStream(query, entityClass, getTableName(entityClass), entityClass);
}
<T> Stream<T> doStream(Query query, Class<?> entityClass, CqlIdentifier tableName, Class<T> returnType) {
RegularStatement statement = getStatementFactory().select(query,
getMappingContext().getRequiredPersistentEntity(entityClass), tableName);
return StreamSupport.stream(getCqlOperations().queryForResultSet(statement).spliterator(), false)
.map(getMapper(entityClass, returnType));
}
/* (non-Javadoc)
@@ -374,6 +398,14 @@ public class CassandraTemplate implements CassandraOperations {
getStatementFactory().update(query, update, getMappingContext().getRequiredPersistentEntity(entityClass)));
}
WriteResult doUpdate(Query query, org.springframework.data.cassandra.core.query.Update update, Class<?> entityClass,
CqlIdentifier tableName) {
RegularStatement statement = getStatementFactory().update(query, update,
getMappingContext().getRequiredPersistentEntity(entityClass), tableName);
return getCqlOperations().execute(new StatementCallback(statement));
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#delete(org.springframework.data.cassandra.core.query.Query, java.lang.Class)
*/
@@ -383,8 +415,14 @@ public class CassandraTemplate implements CassandraOperations {
Assert.notNull(query, "Query must not be null");
Assert.notNull(entityClass, "Entity type must not be null");
return getCqlOperations()
.execute(getStatementFactory().delete(query, getMappingContext().getRequiredPersistentEntity(entityClass)));
return doDelete(query, entityClass, getTableName(entityClass)).wasApplied();
}
WriteResult doDelete(Query query, Class<?> entityClass, CqlIdentifier tableName) {
RegularStatement delete = getStatementFactory().delete(query, getRequiredPersistentEntity(entityClass), tableName);
return getCqlOperations().execute(new StatementCallback(delete));
}
// -------------------------------------------------------------------------
@@ -415,7 +453,12 @@ public class CassandraTemplate implements CassandraOperations {
Assert.notNull(query, "Query must not be null");
Assert.notNull(entityClass, "Entity type must not be null");
RegularStatement count = getStatementFactory().count(query, getRequiredPersistentEntity(entityClass));
return doCount(query, entityClass, getTableName(entityClass));
}
long doCount(Query query, Class<?> entityClass, CqlIdentifier tableName) {
RegularStatement count = getStatementFactory().count(query, getRequiredPersistentEntity(entityClass), tableName);
Long result = getCqlOperations().queryForObject(count, Long.class);
@@ -433,7 +476,7 @@ public class CassandraTemplate implements CassandraOperations {
CassandraPersistentEntity<?> entity = getRequiredPersistentEntity(entityClass);
Select select = QueryBuilder.select().from(entity.getTableName().toCql());
Select select = QueryBuilder.select().from(getTableName(entityClass).toCql());
getConverter().write(id, select.where(), entity);
@@ -449,8 +492,13 @@ public class CassandraTemplate implements CassandraOperations {
Assert.notNull(query, "Query must not be null");
Assert.notNull(entityClass, "Entity type must not be null");
RegularStatement select = getStatementFactory()
.select(query.limit(1), getRequiredPersistentEntity(entityClass));
return doExists(query, entityClass, getTableName(entityClass));
}
boolean doExists(Query query, Class<?> entityClass, CqlIdentifier tableName) {
RegularStatement select = getStatementFactory().select(query.limit(1), getRequiredPersistentEntity(entityClass),
tableName);
return getCqlOperations().queryForResultSet(select).iterator().hasNext();
}
@@ -490,7 +538,13 @@ public class CassandraTemplate implements CassandraOperations {
Assert.notNull(entity, "Entity must not be null");
Assert.notNull(options, "InsertOptions must not be null");
Insert insert = QueryUtils.createInsertQuery(getTableName(entity).toCql(), entity, options, getConverter());
CqlIdentifier tableName = getTableName(entity);
return doInsert(entity, options, tableName);
}
WriteResult doInsert(Object entity, WriteOptions options, CqlIdentifier tableName) {
Insert insert = QueryUtils.createInsertQuery(tableName.toCql(), entity, options, getConverter());
// noinspection ConstantConditions
return getCqlOperations().execute(new StatementCallback(insert));
@@ -573,10 +627,59 @@ public class CassandraTemplate implements CassandraOperations {
getCqlOperations().execute(truncate);
}
// -------------------------------------------------------------------------
// Fluent API entry points
// -------------------------------------------------------------------------
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation#query(java.lang.Class)
*/
@Override
public <T> ExecutableSelect<T> query(Class<T> domainType) {
return new ExecutableSelectOperationSupport(this).query(domainType);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableInsertOperation#insert(java.lang.Class)
*/
@Override
public <T> ExecutableInsert<T> insert(Class<T> domainType) {
return new ExecutableInsertOperationSupport(this).insert(domainType);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableUpdateOperation#update(java.lang.Class)
*/
@Override
public <T> ExecutableUpdate<T> update(Class<T> domainType) {
return new ExecutableUpdateOperationSupport(this).update(domainType);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableDeleteOperation#remove(java.lang.Class)
*/
@Override
public ExecutableDelete delete(Class<?> domainType) {
return new ExecutableDeleteOperationSupport(this).delete(domainType);
}
// -------------------------------------------------------------------------
// Implementation hooks and helper methods
// -------------------------------------------------------------------------
@SuppressWarnings("unchecked")
private <T> Function<Row, T> getMapper(Class<?> entityType, Class<T> targetType) {
Class<?> typeToRead = targetType.isInterface() || targetType.isAssignableFrom(entityType) ? entityType : targetType;
return row -> {
Object source = getConverter().read(typeToRead, row);
return (T) (targetType.isInterface() ? projectionFactory.createProjection(targetType, source) : source);
};
}
private int getConfiguredFetchSize(Session session) {
return session.getCluster().getConfiguration().getQueryOptions().getFetchSize();
}

107
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/ExecutableDeleteOperation.java Normal file
View File

@@ -0,0 +1,107 @@
/*
* 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 org.springframework.data.cassandra.core.cql.CqlIdentifier;
import org.springframework.data.cassandra.core.query.Query;
/**
* {@link ExecutableDeleteOperation} allows creation and execution of Cassandra {@code DELETE} operations in a fluent
* API style.
* <p>
* The starting {@literal domainType} is used for mapping the {@link Query} provided via {@code matching} into the
* Cassandra specific representation. The table to operate on is by default derived from the initial
* {@literal domainType} and can be defined there via {@link org.springframework.data.cassandra.core.mapping.Table}.
* Using {@code inTable} allows to override the table name for the execution.
*
* <pre>
* <code>
* delete(Jedi.class)
* .inTable("star_wars")
* .matching(query(where("firstname").is("luke")))
* .all();
* </code>
* </pre>
*
* @author Mark Paluch
* @since 2.1
*/
public interface ExecutableDeleteOperation {
/**
* Start creating a {@code DELETE} operation for the given {@literal domainType}.
*
* @param domainType must not be {@literal null}.
* @return new instance of {@link ExecutableDelete}.
* @throws IllegalArgumentException if domainType is {@literal null}.
*/
ExecutableDelete delete(Class<?> domainType);
/**
* Table override (optional).
*/
interface DeleteWithTable {
/**
* Explicitly set the name of the table to perform the query on.
* <p>
* Skip this step to use the default table derived from the domain type.
*
* @param table must not be {@literal null} or empty.
* @return new instance of {@link DeleteWithTable}.
* @throws IllegalArgumentException if {@code table} is {@literal null} or empty.
*/
DeleteWithQuery inTable(String table);
/**
* Explicitly set the name of the table to perform the query on.
* <p>
* Skip this step to use the default table derived from the domain type.
*
* @param table must not be {@literal null}.
* @return new instance of {@link DeleteWithTable}.
* @throws IllegalArgumentException if {@link CqlIdentifier} is {@literal null}.
*/
DeleteWithQuery inTable(CqlIdentifier table);
}
interface TerminatingDelete {
/**
* Remove all matching rows.
*
* @return the {@link WriteResult}. Never {@literal null}.
*/
WriteResult all();
}
interface DeleteWithQuery {
/**
* Define the query filtering elements.
*
* @param query must not be {@literal null}.
* @return new instance of {@link TerminatingDelete}.
* @throws IllegalArgumentException if query is {@literal null}.
*/
TerminatingDelete matching(Query query);
}
/**
* {@link ExecutableDelete} provides methods for constructing {@code DELETE} operations in a fluent way.
*/
interface ExecutableDelete extends DeleteWithTable, DeleteWithQuery {}
}

106
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/ExecutableDeleteOperationSupport.java Normal file
View File

@@ -0,0 +1,106 @@
/*
* 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 lombok.AccessLevel;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.experimental.FieldDefaults;
import org.springframework.data.cassandra.core.cql.CqlIdentifier;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
/**
* Implementation of {@link ExecutableDeleteOperation}.
*
* @author Mark Paluch
* @since 2.1
*/
@RequiredArgsConstructor
class ExecutableDeleteOperationSupport implements ExecutableDeleteOperation {
private final @NonNull CassandraTemplate template;
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableDeleteOperation#remove(java.lang.Class)
*/
@Override
public ExecutableDelete delete(Class<?> domainType) {
Assert.notNull(domainType, "DomainType must not be null!");
return new ExecutableDeleteSupport(template, domainType, Query.empty(), null);
}
@RequiredArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
static class ExecutableDeleteSupport implements ExecutableDelete, DeleteWithTable, TerminatingDelete {
@NonNull CassandraTemplate template;
@NonNull Class<?> domainType;
@NonNull Query query;
@Nullable CqlIdentifier tableName;
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableDeleteOperation.DeleteWithTable#inTable(java.lang.String)
*/
@Override
public DeleteWithQuery inTable(String tableName) {
Assert.hasText(tableName, "Table name must not be null or empty");
return new ExecutableDeleteSupport(template, domainType, query, CqlIdentifier.of(tableName));
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableDeleteOperation.DeleteWithTable#inTable(org.springframework.data.cassandra.core.cql.CqlIdentifier)
*/
@Override
public DeleteWithQuery inTable(CqlIdentifier tableName) {
Assert.notNull(tableName, "Table name must not be null");
return new ExecutableDeleteSupport(template, domainType, query, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableDeleteOperation.DeleteWithQuery#matching(org.springframework.data.cassandra.core.query.Query)
*/
@Override
public TerminatingDelete matching(Query query) {
Assert.notNull(query, "Query must not be null!");
return new ExecutableDeleteSupport(template, domainType, query, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableDeleteOperation.TerminatingDelete#all()
*/
public WriteResult all() {
return template.doDelete(query, domainType, getTableName());
}
private CqlIdentifier getTableName() {
return tableName != null ? tableName : template.getTableName(domainType);
}
}
}

111
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/ExecutableInsertOperation.java Normal file
View File

@@ -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;
import org.springframework.data.cassandra.core.cql.CqlIdentifier;
/**
* {@link ExecutableInsertOperation} allows creation and execution of Cassandra {@code INSERT} insert operations in a
* fluent API style.
* <p>
* The table to operate on is by default derived from the initial {@literal domainType} and can be defined there via
* {@link org.springframework.data.cassandra.core.mapping.Table}. Using {@code inTable} allows to override the
* collection name for the execution.
*
* <pre>
* <code>
* insert(Jedi.class)
* .inTable("star_wars")
* .one(luke);
* </code>
* </pre>
*
* @author Mark Paluch
* @since 2.1
*/
public interface ExecutableInsertOperation {
/**
* Start creating an {@code INSERT} operation for given {@literal domainType}.
*
* @param domainType must not be {@literal null}.
* @return new instance of {@link ExecutableInsert}.
* @throws IllegalArgumentException if domainType is {@literal null}.
*/
<T> ExecutableInsert<T> insert(Class<T> domainType);
/**
* Trigger insert execution by calling one of the terminating methods.
*/
interface TerminatingInsert<T> {
/**
* Insert exactly one object.
*
* @param object must not be {@literal null}.
* @throws IllegalArgumentException if object is {@literal null}.
*/
WriteResult one(T object);
}
/**
* Collection override (optional).
*/
interface InsertWithTable<T> extends InsertWithOptions<T> {
/**
* Explicitly set the name of the table.
* <p>
* Skip this step to use the default table derived from the domain type.
*
* @param table must not be {@literal null} or empty.
* @return new instance of {@link TerminatingInsert}.
* @throws IllegalArgumentException if {@code table} is {@literal null} or empty.
*/
InsertWithOptions<T> inTable(String table);
/**
* Explicitly set the name of the table.
* <p>
* Skip this step to use the default table derived from the domain type.
*
* @param table must not be {@literal null}.
* @return new instance of {@link TerminatingInsert}.
* @throws IllegalArgumentException if {@link CqlIdentifier} is {@literal null}.
*/
InsertWithOptions<T> inTable(CqlIdentifier table);
}
/**
* Apply {@link InsertOptions} (optional).
*/
interface InsertWithOptions<T> extends TerminatingInsert<T> {
/**
* Set insert options.
*
* @param insertOptions insertOptions not be {@literal null}.
* @return new instance of {@link TerminatingInsert}.
* @throws IllegalArgumentException if {@link InsertOptions} is {@literal null}.
*/
TerminatingInsert<T> withOptions(InsertOptions insertOptions);
}
/**
* {@link ExecutableInsert} provides methods for constructing {@code INSERT} operations in a fluent way.
*/
interface ExecutableInsert<T> extends TerminatingInsert<T>, InsertWithTable<T>, InsertWithOptions<T> {}
}

109
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/ExecutableInsertOperationSupport.java Normal file
View File

@@ -0,0 +1,109 @@
/*
* 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 lombok.AccessLevel;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.experimental.FieldDefaults;
import org.springframework.data.cassandra.core.cql.CqlIdentifier;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
/**
* Implementation of {@link ExecutableInsertOperation}.
*
* @author Mark Paluch
* @since 2.1
*/
@RequiredArgsConstructor
class ExecutableInsertOperationSupport implements ExecutableInsertOperation {
private final @NonNull CassandraTemplate template;
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableInsertOperation#insert(java.lang.Class)
*/
@Override
public <T> ExecutableInsert<T> insert(Class<T> domainType) {
Assert.notNull(domainType, "DomainType must not be null!");
return new ExecutableInsertSupport<>(template, domainType, null, InsertOptions.empty());
}
@RequiredArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
static class ExecutableInsertSupport<T> implements ExecutableInsert<T> {
@NonNull CassandraTemplate template;
@NonNull Class<T> domainType;
@Nullable CqlIdentifier tableName;
@NonNull InsertOptions insertOptions;
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableInsertOperation.InsertWithTable#inTable(java.lang.String)
*/
@Override
public InsertWithOptions<T> inTable(String tableName) {
Assert.hasText(tableName, "Table name must not be null or empty");
return new ExecutableInsertSupport<>(template, domainType, CqlIdentifier.of(tableName), insertOptions);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableInsertOperation.InsertWithTable#inTable(org.springframework.data.cassandra.core.cql.CqlIdentifier)
*/
@Override
public InsertWithOptions<T> inTable(CqlIdentifier tableName) {
Assert.notNull(tableName, "Table name must not be null");
return new ExecutableInsertSupport<>(template, domainType, tableName, insertOptions);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableInsertOperation.InsertWithOptions#withOptions(org.springframework.data.cassandra.core.InsertOptions)
*/
@Override
public TerminatingInsert<T> withOptions(InsertOptions insertOptions) {
Assert.notNull(insertOptions, "InsertOptions must not be null");
return new ExecutableInsertSupport<>(template, domainType, tableName, insertOptions);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableInsertOperation.TerminatingInsert#one(java.lang.Object)
*/
@Override
public WriteResult one(T object) {
Assert.notNull(object, "Object must not be null!");
return template.doInsert(object, insertOptions, getTableName());
}
private CqlIdentifier getTableName() {
return tableName != null ? tableName : template.getTableName(domainType);
}
}
}

198
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/ExecutableSelectOperation.java Normal file
View File

@@ -0,0 +1,198 @@
/*
* 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 java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
import org.springframework.data.cassandra.core.cql.CqlIdentifier;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.lang.Nullable;
/**
* {@link ExecutableSelectOperation} allows creation and execution of Cassandra {@code SELECT} operations in a fluent
* API style.
* <p>
* The starting {@literal domainType} is used for mapping the {@link Query} provided via {@code matching} into the
* Cassandra specific representation. By default, the originating {@literal domainType} is also used for mapping back
* the result from the {@link com.datastax.driver.core.Row}. However, it is possible to define an different
* {@literal returnType} via {@code as} to mapping the result.
* <p>
* The table to operate on is by default derived from the initial {@literal domainType} and can be defined there via
* {@link org.springframework.data.cassandra.core.mapping.Table}. Using {@code inTable} allows to override the table
* name for the execution.
*
* <pre>
* <code>
* query(Human.class)
* .inTable("star_wars")
* .as(Jedi.class)
* .matching(query(where("firstname").is("luke")))
* .all();
* </code>
* </pre>
*
* @author Mark Paluch
* @since 2.1
*/
public interface ExecutableSelectOperation {
/**
* Start creating a {@code SELECT} operation for the given {@literal domainType}.
*
* @param domainType must not be {@literal null}.
* @return new instance of {@link ExecutableSelect}.
* @throws IllegalArgumentException if domainType is {@literal null}.
*/
<T> ExecutableSelect<T> query(Class<T> domainType);
/**
* Trigger {@code SELECT} execution by calling one of the terminating methods.
*/
interface TerminatingSelect<T> {
/**
* Get exactly zero or one result.
*
* @return {@link Optional#empty()} if no match found.
* @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one match found.
*/
default Optional<T> one() {
return Optional.ofNullable(oneValue());
}
/**
* Get exactly zero or one result.
*
* @return {@literal null} if no match found.
* @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one match found.
*/
@Nullable
T oneValue();
/**
* Get the first or no result.
*
* @return {@link Optional#empty()} if no match found.
*/
default Optional<T> first() {
return Optional.ofNullable(firstValue());
}
/**
* Get the first or no result.
*
* @return {@literal null} if no match found.
*/
@Nullable
T firstValue();
/**
* Get all matching elements.
*
* @return never {@literal null}.
*/
List<T> all();
/**
* Stream all matching elements.
*
* @return a {@link Stream} that wraps the a Cassandra {@link com.datastax.driver.core.ResultSet} that needs to be
* closed. Never {@literal null}.
*/
Stream<T> stream();
/**
* Get the number of matching elements.
*
* @return total number of matching elements.
*/
long count();
/**
* Check for the presence of matching elements.
*
* @return {@literal true} if at least one matching element exists.
*/
boolean exists();
}
/**
* Terminating operations invoking the actual query execution.
*/
interface SelectWithQuery<T> extends TerminatingSelect<T> {
/**
* Set the filter query to be used.
*
* @param query must not be {@literal null}.
* @return new instance of {@link TerminatingSelect}.
* @throws IllegalArgumentException if query is {@literal null}.
*/
TerminatingSelect<T> matching(Query query);
}
/**
* Table override (Optional).
*/
interface SelectWithTable<T> extends SelectWithQuery<T> {
/**
* Explicitly set the name of the table to perform the query on.
* <p>
* Skip this step to use the default table derived from the domain type.
*
* @param table must not be {@literal null} or empty.
* @return new instance of {@link SelectWithProjection}.
* @throws IllegalArgumentException if {@code table} is {@literal null} or empty.
*/
SelectWithProjection<T> inTable(String table);
/**
* Explicitly set the name of the table to perform the query on.
* <p>
* Skip this step to use the default table derived from the domain type.
*
* @param table must not be {@literal null}.
* @return new instance of {@link SelectWithProjection}.
* @throws IllegalArgumentException if {@link CqlIdentifier} is {@literal null}.
*/
SelectWithProjection<T> inTable(CqlIdentifier table);
}
/**
* Result type override (Optional).
*/
interface SelectWithProjection<T> extends SelectWithQuery<T> {
/**
* Define the target type fields should be mapped to. <br />
* Skip this step if you are anyway only interested in the original domain type.
*
* @param resultType must not be {@literal null}.
* @param <R> result type.
* @return new instance of {@link SelectWithProjection}.
* @throws IllegalArgumentException if resultType is {@literal null}.
*/
<R> SelectWithQuery<R> as(Class<R> resultType);
}
/**
* {@link ExecutableSelect} provides methods for constructing {@code SELECT} operations in a fluent way.
*/
interface ExecutableSelect<T> extends SelectWithTable<T>, SelectWithProjection<T> {}
}

180
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/ExecutableSelectOperationSupport.java Normal file
View File

@@ -0,0 +1,180 @@
/*
* 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 lombok.AccessLevel;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.experimental.FieldDefaults;
import java.util.List;
import java.util.stream.Stream;
import org.springframework.dao.IncorrectResultSizeDataAccessException;
import org.springframework.data.cassandra.core.cql.CqlIdentifier;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ObjectUtils;
/**
* Implementation of {@link ExecutableSelectOperation}.
*
* @author Mark Paluch
* @since 2.1
*/
@RequiredArgsConstructor
class ExecutableSelectOperationSupport implements ExecutableSelectOperation {
private final @NonNull CassandraTemplate template;
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation#query(java.lang.Class)
*/
@Override
public <T> ExecutableSelect<T> query(Class<T> domainType) {
Assert.notNull(domainType, "DomainType must not be null!");
return new ExecutableSelectSupport<>(template, domainType, domainType, Query.empty(), null);
}
@RequiredArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
static class ExecutableSelectSupport<T>
implements ExecutableSelect<T>, SelectWithTable<T>, SelectWithProjection<T>, SelectWithQuery<T> {
@NonNull CassandraTemplate template;
@NonNull Class<?> domainType;
@NonNull Class<T> returnType;
@NonNull Query query;
@Nullable CqlIdentifier tableName;
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation.SelectWithTable#inTable(java.lang.String)
*/
@Override
public SelectWithProjection<T> inTable(String tableName) {
Assert.hasText(tableName, "Table name must not be null or empty!");
return new ExecutableSelectSupport<>(template, domainType, returnType, query, CqlIdentifier.of(tableName));
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation.SelectWithTable#inTable(org.springframework.data.cassandra.core.cql.CqlIdentifier)
*/
@Override
public SelectWithProjection<T> inTable(CqlIdentifier tableName) {
Assert.notNull(tableName, "Table name must not be null!");
return new ExecutableSelectSupport<>(template, domainType, returnType, query, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation.SelectWithProjection#as(java.lang.Class)
*/
@Override
public <R> SelectWithQuery<R> as(Class<R> returnType) {
Assert.notNull(returnType, "ReturnType must not be null!");
return new ExecutableSelectSupport<>(template, domainType, returnType, query, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation.SelectWithQuery#matching(org.springframework.data.cassandra.core.query.Query)
*/
@Override
public TerminatingSelect<T> matching(Query query) {
Assert.notNull(query, "Query must not be null!");
return new ExecutableSelectSupport<>(template, domainType, returnType, query, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation.TerminatingSelect#oneValue()
*/
@Override
public T oneValue() {
List<T> result = template.doSelect(query.limit(2), domainType, getTableName(), returnType);
if (ObjectUtils.isEmpty(result)) {
return null;
}
if (result.size() > 1) {
throw new IncorrectResultSizeDataAccessException("Query " + query + " returned non unique result.", 1);
}
return result.iterator().next();
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation.TerminatingSelect#firstValue()
*/
@Override
public T firstValue() {
List<T> result = template.doSelect(query.limit(1), domainType, getTableName(), returnType);
return ObjectUtils.isEmpty(result) ? null : result.iterator().next();
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation.TerminatingSelect#all()
*/
@Override
public List<T> all() {
return template.doSelect(query, domainType, getTableName(), returnType);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation.TerminatingSelect#stream()
*/
@Override
public Stream<T> stream() {
return template.doStream(query, domainType, getTableName(), returnType);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation.TerminatingSelect#count()
*/
@Override
public long count() {
return template.doCount(query, domainType, getTableName());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableSelectOperation.TerminatingSelect#exists()
*/
@Override
public boolean exists() {
return template.doExists(query, domainType, getTableName());
}
private CqlIdentifier getTableName() {
return tableName != null ? tableName : template.getTableName(domainType);
}
}
}

131
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/ExecutableUpdateOperation.java Normal file
View File

@@ -0,0 +1,131 @@
/*
* 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 org.springframework.data.cassandra.core.cql.CqlIdentifier;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.core.query.Update;
/**
* {@link ExecutableUpdateOperation} allows creation and execution of Cassandra {@code UPDATE} operation in a fluent API
* style.
* <p>
* The starting {@literal domainType} is used for mapping the {@link Query} provided via {@code matching}, as well as
* the {@link Update} via {@code apply} into the Cassandra specific representations. The table to operate on is by
* default derived from the initial {@literal domainType} and can be defined there via
* {@link org.springframework.data.cassandra.core.mapping.Table}. Using {@code inTable} allows to override the table
* name for the execution.
*
* <pre>
* <code>
* update(Jedi.class)
* .inTable("star_wars")
* .matching(query(where("firstname").is("luke")))
* .apply(update("lastname", "skywalker"))
* .all();
* </code>
* </pre>
*
* @author Mark Paluch
* @since 2.1
*/
public interface ExecutableUpdateOperation {
/**
* Start creating an {@code UPDATE} operation for the given {@literal domainType}.
*
* @param domainType must not be {@literal null}.
* @return new instance of {@link ExecutableUpdate}.
* @throws IllegalArgumentException if domainType is {@literal null}.
*/
<T> ExecutableUpdate<T> update(Class<T> domainType);
/**
* Declare the {@link Update} to apply.
*/
interface UpdateWithUpdate<T> {
/**
* Set the {@link Update} to be applied.
*
* @param update must not be {@literal null}.
* @return new instance of {@link TerminatingUpdate}.
* @throws IllegalArgumentException if update is {@literal null}.
*/
TerminatingUpdate<T> apply(Update update);
}
/**
* Explicitly define the name of the table to perform operation in.
*/
interface UpdateWithTable<T> {
/**
* Explicitly set the name of the table to perform the query on.
* <p>
* Skip this step to use the default table derived from the domain type.
*
* @param table must not be {@literal null} or empty.
* @return new instance of {@link UpdateWithTable}.
* @throws IllegalArgumentException if {@code table} is {@literal null} or empty.
*/
UpdateWithQuery<T> inTable(String table);
/**
* Explicitly set the name of the table to perform the query on.
* <p>
* Skip this step to use the default table derived from the domain type.
*
* @param table must not be {@literal null}.
* @return new instance of {@link UpdateWithTable}.
* @throws IllegalArgumentException if {@link CqlIdentifier} is {@literal null}.
*/
UpdateWithQuery<T> inTable(CqlIdentifier table);
}
/**
* Define a filter query for the {@link Update}.
*/
interface UpdateWithQuery<T> {
/**
* Filter documents by given {@literal query}.
*
* @param query must not be {@literal null}.
* @return new instance of {@link UpdateWithQuery}.
* @throws IllegalArgumentException if query is {@literal null}.
*/
UpdateWithUpdate<T> matching(Query query);
}
/**
* Trigger update execution by calling one of the terminating methods.
*/
interface TerminatingUpdate<T> {
/**
* Update all matching rows in the table.
*
* @return never {@literal null}.
*/
WriteResult all();
}
/**
* {@link ExecutableUpdate} provides methods for constructing {@code UPDATE} operations in a fluent way.
*/
interface ExecutableUpdate<T> extends UpdateWithTable<T>, UpdateWithQuery<T> {}
}

122
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/ExecutableUpdateOperationSupport.java Normal file
View File

@@ -0,0 +1,122 @@
/*
* 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 lombok.AccessLevel;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import lombok.experimental.FieldDefaults;
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.lang.Nullable;
import org.springframework.util.Assert;
/**
* Implementation of {@link ExecutableUpdateOperation}.
*
* @author Mark Paluch
* @since 2.1
*/
@RequiredArgsConstructor
class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
private final @NonNull CassandraTemplate template;
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableUpdateOperation#update(java.lang.Class)
*/
@Override
public <T> ExecutableUpdate<T> update(Class<T> domainType) {
Assert.notNull(domainType, "DomainType must not be null!");
return new ExecutableUpdateSupport<>(template, domainType, Query.empty(), null, null);
}
@RequiredArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
static class ExecutableUpdateSupport<T> implements ExecutableUpdate<T>, UpdateWithTable<T>, UpdateWithQuery<T>,
UpdateWithUpdate<T>, TerminatingUpdate<T> {
@NonNull CassandraTemplate template;
@NonNull Class<T> domainType;
@NonNull Query query;
@Nullable Update update;
@Nullable CqlIdentifier tableName;
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableUpdateOperation.UpdateWithUpdate#apply(org.springframework.data.cassandra.core.query.Update)
*/
@Override
public TerminatingUpdate<T> apply(Update update) {
Assert.notNull(update, "Update must not be null!");
return new ExecutableUpdateSupport<>(template, domainType, query, update, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableUpdateOperation.UpdateWithTable#inTable(java.lang.String)
*/
@Override
public UpdateWithQuery<T> inTable(String tableName) {
Assert.hasText(tableName, "Table name must not be null or empty!");
return new ExecutableUpdateSupport<>(template, domainType, query, update, CqlIdentifier.of(tableName));
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableUpdateOperation.UpdateWithTable#inTable(org.springframework.data.cassandra.core.cql.CqlIdentifier)
*/
@Override
public UpdateWithQuery<T> inTable(CqlIdentifier tableName) {
Assert.notNull(tableName, "Table name must not be null!");
return new ExecutableUpdateSupport<>(template, domainType, query, update, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableUpdateOperation.UpdateWithQuery#matching(org.springframework.data.cassandra.core.query.Query)
*/
@Override
public UpdateWithUpdate<T> matching(Query query) {
Assert.notNull(query, "Query must not be null!");
return new ExecutableUpdateSupport<>(template, domainType, query, update, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.ExecutableUpdateOperation.TerminatingUpdate#all()
*/
@Override
public WriteResult all() {
return template.doUpdate(query, update, domainType, getTableName());
}
private CqlIdentifier getTableName() {
return tableName != null ? tableName : template.getTableName(domainType);
}
}
}

26
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/FluentCassandraOperations.java Normal file
View File

@@ -0,0 +1,26 @@
/*
* 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;
/**
* Stripped down interface providing access to a fluent API that specifies a basic set of Cassandra operations.
*
* @author Mark Paluch
* @since 2.1
* @see CassandraOperations
*/
public interface FluentCassandraOperations extends ExecutableSelectOperation, ExecutableInsertOperation,
ExecutableUpdateOperation, ExecutableDeleteOperation {}

85
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/StatementFactory.java
View File

@@ -138,11 +138,25 @@ public class StatementFactory {
Assert.notNull(query, "Query must not be null");
Assert.notNull(entity, "Entity must not be null");
return count(query, entity, entity.getTableName());
}
/**
* Create a {@literal COUNT} statement by mapping {@link Query} to {@link Select}.
*
* @param query user-defined count {@link Query} to execute; must not be {@literal null}.
* @param entity {@link CassandraPersistentEntity entity} to count; must not be {@literal null}.
* @param tableName must not be {@literal null}.
* @return the rendered {@link RegularStatement}.
* @since 2.1
*/
public RegularStatement count(Query query, CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {
Filter filter = getQueryMapper().getMappedObject(query, entity);
List<Selector> selectors = Collections.singletonList(FunctionCall.from("COUNT", 1L));
return createSelect(query, entity, filter, selectors);
return createSelect(query, entity, filter, selectors, tableName);
}
/**
@@ -157,20 +171,38 @@ public class StatementFactory {
Assert.notNull(query, "Query must not be null");
Assert.notNull(entity, "Entity must not be null");
return select(query, entity, entity.getTableName());
}
/**
* Create a {@literal SELECT} statement by mapping {@link Query} to {@link Select}.
*
* @param query must not be {@literal null}.
* @param entity must not be {@literal null}.
* @param tableName must not be {@literal null}.
* @return the rendered {@link RegularStatement}.
* @since 2.1
*/
public RegularStatement select(Query query, CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {
Assert.notNull(query, "Query must not be null");
Assert.notNull(entity, "Entity must not be null");
Assert.notNull(entity, "Table name must not be null");
Filter filter = getQueryMapper().getMappedObject(query, entity);
List<Selector> selectors = getQueryMapper().getMappedSelectors(query.getColumns(), entity);
return createSelect(query, entity, filter, selectors);
return createSelect(query, entity, filter, selectors, tableName);
}
private Select createSelect(Query query, CassandraPersistentEntity<?> entity, Filter filter,
List<Selector> selectors) {
List<Selector> selectors, CqlIdentifier tableName) {
Sort sort = Optional.of(query.getSort()).map(querySort -> getQueryMapper().getMappedSort(querySort, entity))
.orElse(Sort.unsorted());
Select select = createSelectAndOrder(selectors, entity.getTableName(), filter, sort);
Select select = createSelectAndOrder(selectors, tableName, filter, sort);
query.getQueryOptions().ifPresent(queryOptions -> QueryOptionsUtil.addQueryOptions(select, queryOptions));
@@ -253,16 +285,37 @@ public class StatementFactory {
* @param entity must not be {@literal null}.
* @return the rendered {@link RegularStatement}.
*/
public RegularStatement update(Query query, Update updateObj, CassandraPersistentEntity<?> entity) {
public RegularStatement update(Query query, Update update, CassandraPersistentEntity<?> entity) {
Assert.notNull(query, "Query must not be null");
Assert.notNull(update, "Update must not be null");
Assert.notNull(entity, "Entity must not be null");
return update(query, update, entity, entity.getTableName());
}
/**
* Create an {@literal UPDATE} statement by mapping {@link Query} to {@link Update}.
*
* @param query must not be {@literal null}.
* @param updateObj must not be {@literal null}.
* @param entity must not be {@literal null}.
* @param tableName must not be {@literal null}.
* @return the rendered {@link RegularStatement}.
* @since 2.1
*/
RegularStatement update(Query query, Update updateObj, CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {
Assert.notNull(query, "Query must not be null");
Assert.notNull(updateObj, "Update must not be null");
Assert.notNull(entity, "Entity must not be null");
Assert.notNull(tableName, "Table name must not be null");
Filter filter = getQueryMapper().getMappedObject(query, entity);
Update mappedUpdate = getUpdateMapper().getMappedObject(updateObj, entity);
com.datastax.driver.core.querybuilder.Update update = update(entity.getTableName(), mappedUpdate, filter);
com.datastax.driver.core.querybuilder.Update update = update(tableName, mappedUpdate, filter);
query.getQueryOptions().ifPresent(queryOptions -> {
if (queryOptions instanceof WriteOptions) {
@@ -381,11 +434,29 @@ public class StatementFactory {
Assert.notNull(query, "Query must not be null");
Assert.notNull(entity, "Entity must not be null");
return delete(query, entity, entity.getTableName());
}
/**
* Create a {@literal DELETE} statement by mapping {@link Query} to {@link Delete}.
*
* @param query must not be {@literal null}.
* @param entity must not be {@literal null}.
* @param tableName must not be {@literal null}.
* @return the rendered {@link RegularStatement}.
* @see 2.1
*/
public RegularStatement delete(Query query, CassandraPersistentEntity<?> entity, CqlIdentifier tableName) {
Assert.notNull(query, "Query must not be null");
Assert.notNull(entity, "Entity must not be null");
Assert.notNull(tableName, "Table name must not be null");
Filter filter = getQueryMapper().getMappedObject(query, entity);
List<String> columnNames = getQueryMapper().getMappedColumnNames(query.getColumns(), entity);
Delete delete = delete(columnNames, entity.getTableName(), filter);
Delete delete = delete(columnNames, tableName, filter);
query.getQueryOptions().ifPresent(queryOptions -> QueryOptionsUtil.addQueryOptions(delete, queryOptions));

100
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/ExecutableDeleteOperationSupportTests.java Normal file
View File

@@ -0,0 +1,100 @@
/*
* 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 static org.assertj.core.api.Assertions.*;
import static org.springframework.data.cassandra.core.query.Criteria.*;
import static org.springframework.data.cassandra.core.query.Query.*;
import lombok.Data;
import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
import org.springframework.data.annotation.Id;
import org.springframework.data.cassandra.core.convert.MappingCassandraConverter;
import org.springframework.data.cassandra.core.cql.CqlIdentifier;
import org.springframework.data.cassandra.core.mapping.Column;
import org.springframework.data.cassandra.core.mapping.Indexed;
import org.springframework.data.cassandra.core.mapping.Table;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.test.util.AbstractKeyspaceCreatingIntegrationTest;
/**
* Integration tests for {@link ExecutableDeleteOperationSupport}.
*
* @author Mark Paluch
*/
public class ExecutableDeleteOperationSupportTests extends AbstractKeyspaceCreatingIntegrationTest {
CassandraAdminTemplate template;
Person han;
Person luke;
@Before
public void setUp() {
template = new CassandraAdminTemplate(session, new MappingCassandraConverter());
template.dropTable(true, CqlIdentifier.of("person"));
template.createTable(true, CqlIdentifier.of("person"), ExecutableInsertOperationSupportTests.Person.class,
Collections.emptyMap());
han = new Person();
han.firstname = "han";
han.id = "id-1";
luke = new Person();
luke.firstname = "luke";
luke.id = "id-2";
template.insert(han);
template.insert(luke);
}
@Test // DATACASS-485
public void removeAllMatching() {
WriteResult writeResult = template.delete(Person.class).matching(query(where("id").is(han.id))).all();
assertThat(writeResult.wasApplied()).isTrue();
}
@Test // DATACASS-485
public void removeAllMatchingWithAlternateDomainTypeAndCollection() {
WriteResult writeResult = template.delete(Jedi.class).inTable("person")
.matching(query(where("id").in(han.id, luke.id)))
.all();
assertThat(writeResult.wasApplied()).isTrue();
assertThat(template.select(Query.empty(), Person.class)).isEmpty();
}
@Data
@Table
static class Person {
@Id String id;
@Indexed String firstname;
}
@Data
static class Jedi {
@Column("firstname") String name;
}
}

112
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/ExecutableInsertOperationSupportTests.java Normal file
View File

@@ -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;
import static org.assertj.core.api.Assertions.*;
import lombok.Data;
import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
import org.springframework.data.annotation.Id;
import org.springframework.data.cassandra.core.convert.MappingCassandraConverter;
import org.springframework.data.cassandra.core.cql.CqlIdentifier;
import org.springframework.data.cassandra.core.mapping.Indexed;
import org.springframework.data.cassandra.core.mapping.Table;
import org.springframework.data.cassandra.test.util.AbstractKeyspaceCreatingIntegrationTest;
/**
* Integration tests for {@link ExecutableInsertOperationSupport}.
*
* @author Mark Paluch
*/
public class ExecutableInsertOperationSupportTests extends AbstractKeyspaceCreatingIntegrationTest {
CassandraAdminTemplate template;
Person han;
Person luke;
@Before
public void setUp() {
template = new CassandraAdminTemplate(session, new MappingCassandraConverter());
template.dropTable(true, CqlIdentifier.of("person"));
template.createTable(true, CqlIdentifier.of("person"), Person.class, Collections.emptyMap());
initPersons();
}
@Test(expected = IllegalArgumentException.class) // DATACASS-485
public void domainTypeIsRequired() {
template.insert((Class) null);
}
@Test(expected = IllegalArgumentException.class) // DATACASS-485
public void tableIsRequiredOnSet() {
template.insert(Person.class).inTable((String) null);
}
@Test(expected = IllegalArgumentException.class) // DATACASS-485
public void optionsIsRequiredOnSet() {
template.insert(Person.class).withOptions(null);
}
@Test // DATACASS-485
public void insertOne() {
WriteResult writeResult = template.insert(Person.class).inTable("person").one(han);
assertThat(writeResult.wasApplied()).isTrue();
assertThat(template.selectOneById(han.id, Person.class)).isEqualTo(han);
}
@Test // DATACASS-485
public void insertOneWithOptions() {
template.insert(Person.class).inTable("person").one(han);
WriteResult writeResult = template.insert(Person.class).inTable("person")
.withOptions(InsertOptions.builder().withIfNotExists().build()).one(han);
assertThat(writeResult.wasApplied()).isFalse();
assertThat(template.selectOneById(han.id, Person.class)).isEqualTo(han);
}
@Data
@Table
static class Person {
@Id String id;
@Indexed String firstname;
@Indexed String lastname;
}
private void initPersons() {
han = new Person();
han.firstname = "han";
han.lastname = "solo";
han.id = "id-1";
luke = new Person();
luke.firstname = "luke";
luke.lastname = "skywalker";
luke.id = "id-2";
}
}

337
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/ExecutableSelectOperationSupportTests.java Normal file
View File

@@ -0,0 +1,337 @@
/*
* 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 static org.assertj.core.api.Assertions.*;
import static org.springframework.data.cassandra.core.query.Criteria.*;
import static org.springframework.data.cassandra.core.query.Query.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Collections;
import java.util.stream.Stream;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.dao.IncorrectResultSizeDataAccessException;
import org.springframework.data.annotation.Id;
import org.springframework.data.cassandra.core.ExecutableSelectOperation.TerminatingSelect;
import org.springframework.data.cassandra.core.convert.MappingCassandraConverter;
import org.springframework.data.cassandra.core.cql.CqlIdentifier;
import org.springframework.data.cassandra.core.mapping.Column;
import org.springframework.data.cassandra.core.mapping.Indexed;
import org.springframework.data.cassandra.core.mapping.Table;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.test.util.AbstractKeyspaceCreatingIntegrationTest;
/**
* Integration tests for {@link ExecutableSelectOperationSupport}.
*
* @author Mark Paluch
*/
public class ExecutableSelectOperationSupportTests extends AbstractKeyspaceCreatingIntegrationTest {
CassandraAdminTemplate template;
Person han;
Person luke;
@Before
public void setUp() {
template = new CassandraAdminTemplate(session, new MappingCassandraConverter());
template.dropTable(true, CqlIdentifier.of("person"));
template.createTable(true, CqlIdentifier.of("person"), Person.class, Collections.emptyMap());
initPersons();
}
@Test(expected = IllegalArgumentException.class) // DATACASS-485
public void domainTypeIsRequired() {
template.query(null);
}
@Test(expected = IllegalArgumentException.class) // DATACASS-485
public void returnTypeIsRequiredOnSet() {
template.query(Person.class).as(null);
}
@Test(expected = IllegalArgumentException.class) // DATACASS-485
public void tableIsRequiredOnSet() {
template.query(Person.class).inTable((String) null);
}
@Test // DATACASS-485
public void findAll() {
assertThat(template.query(Person.class).all()).containsExactlyInAnyOrder(han, luke);
}
@Test // DATACASS-485
public void findAllWithCollection() {
assertThat(template.query(Human.class).inTable("person").all()).hasSize(2);
}
@Test // DATACASS-485
public void findAllWithProjection() {
assertThat(template.query(Person.class).as(Jedi.class).all()).hasOnlyElementsOfType(Jedi.class).hasSize(2);
}
@Test // DATACASS-485
public void findByReturningAllValuesAsClosedInterfaceProjection() {
assertThat(template.query(Person.class).as(PersonProjection.class).all())
.hasOnlyElementsOfTypes(PersonProjection.class);
}
@Test // DATACASS-485
public void findAllBy() {
assertThat(template.query(Person.class).matching(queryLuke()).all()).containsExactlyInAnyOrder(luke);
}
@Test // DATACASS-485
public void findAllByWithCollectionUsingMappingInformation() {
assertThat(template.query(Jedi.class).inTable("person").all()).isNotEmpty().hasOnlyElementsOfType(Jedi.class);
}
@Test // DATACASS-485
public void findAllByWithCollection() {
assertThat(template.query(Human.class).inTable("person").matching(queryLuke()).all()).hasSize(1);
}
@Test // DATACASS-485
public void findAllByWithProjection() {
assertThat(template.query(Person.class).as(Jedi.class).all()).hasOnlyElementsOfType(Jedi.class).isNotEmpty();
}
@Test // DATACASS-485
public void findBy() {
assertThat(template.query(Person.class).matching(queryLuke()).one()).contains(luke);
}
@Test // DATACASS-485
public void findByNoMatch() {
assertThat(template.query(Person.class).matching(querySpock()).one()).isEmpty();
}
@Test(expected = IncorrectResultSizeDataAccessException.class) // DATACASS-485
public void findByTooManyResults() {
template.query(Person.class).one();
}
@Test // DATACASS-485
public void findByReturningOneValue() {
assertThat(template.query(Person.class).matching(queryLuke()).oneValue()).isEqualTo(luke);
}
@Test(expected = IncorrectResultSizeDataAccessException.class) // DATACASS-485
public void findByReturningOneValueButTooManyResults() {
template.query(Person.class).oneValue();
}
@Test // DATACASS-485
public void findByReturningFirstValue() {
assertThat(template.query(Person.class).matching(queryLuke()).firstValue()).isEqualTo(luke);
}
@Test // DATACASS-485
public void findByReturningFirstValueForManyResults() {
assertThat(template.query(Person.class).firstValue()).isIn(han, luke);
}
@Test // DATACASS-485
public void findByReturningFirstValueAsClosedInterfaceProjection() {
PersonProjection result = template.query(Person.class).as(PersonProjection.class)
.matching(query(where("firstname").is("han")).withAllowFiltering()).firstValue();
assertThat(result).isInstanceOf(PersonProjection.class);
assertThat(result.getFirstname()).isEqualTo("han");
}
@Test // DATACASS-485
public void findByReturningFirstValueAsOpenInterfaceProjection() {
PersonSpELProjection result = template.query(Person.class).as(PersonSpELProjection.class)
.matching(query(where("firstname").is("han")).withAllowFiltering()).firstValue();
assertThat(result).isInstanceOf(PersonSpELProjection.class);
assertThat(result.getName()).isEqualTo("han");
}
@Test // DATACASS-485
public void streamAll() {
try (Stream<Person> stream = template.query(Person.class).stream()) {
assertThat(stream).containsExactlyInAnyOrder(han, luke);
}
}
@Test // DATACASS-485
public void streamAllWithCollection() {
Stream<Human> stream = template.query(Human.class).inTable("person").stream();
assertThat(stream).hasSize(2);
}
@Test // DATACASS-485
public void streamAllWithProjection() {
try (Stream<Jedi> stream = template.query(Person.class).as(Jedi.class).stream()) {
assertThat(stream).hasOnlyElementsOfType(Jedi.class).hasSize(2);
}
}
@Test // DATACASS-485
public void streamAllReturningResultsAsClosedInterfaceProjection() {
TerminatingSelect<PersonProjection> operation = template.query(Person.class).as(PersonProjection.class);
assertThat(operation.stream()) //
.hasSize(2) //
.allSatisfy(it -> {
assertThat(it).isInstanceOf(PersonProjection.class);
assertThat(it.getFirstname()).isNotBlank();
});
}
@Test // DATACASS-485
public void streamAllReturningResultsAsOpenInterfaceProjection() {
TerminatingSelect<PersonSpELProjection> operation = template.query(Person.class).as(PersonSpELProjection.class);
assertThat(operation.stream()) //
.hasSize(2) //
.allSatisfy(it -> {
assertThat(it).isInstanceOf(PersonSpELProjection.class);
assertThat(it.getName()).isNotBlank();
});
}
@Test // DATACASS-485
public void streamAllBy() {
Stream<Person> stream = template.query(Person.class).matching(queryLuke()).stream();
assertThat(stream).containsExactlyInAnyOrder(luke);
}
@Test // DATACASS-485
public void firstShouldReturnFirstEntryInCollection() {
assertThat(template.query(Person.class).first()).isNotEmpty();
}
@Test // DATACASS-485
public void countShouldReturnNrOfElementsInCollectionWhenNoQueryPresent() {
assertThat(template.query(Person.class).count()).isEqualTo(2);
}
@Test // DATACASS-485
public void countShouldReturnNrOfElementsMatchingQuery() {
assertThat(template.query(Person.class)
.matching(query(where("firstname").is(luke.getFirstname())).withAllowFiltering()).count()).isEqualTo(1);
}
@Test // DATACASS-485
public void existsShouldReturnTrueIfAtLeastOneElementExistsInCollection() {
assertThat(template.query(Person.class).exists()).isTrue();
}
@Test // DATACASS-485
public void existsShouldReturnFalseIfNoElementExistsInCollection() {
template.truncate(Person.class);
assertThat(template.query(Person.class).exists()).isFalse();
}
@Test // DATACASS-485
public void existsShouldReturnTrueIfAtLeastOneElementMatchesQuery() {
assertThat(template.query(Person.class).matching(queryLuke()).exists()).isTrue();
}
@Test // DATACASS-485
public void existsShouldReturnFalseWhenNoElementMatchesQuery() {
assertThat(template.query(Person.class).matching(querySpock()).exists()).isFalse();
}
@Test // DATACASS-485
public void returnsTargetObjectDirectlyIfProjectionInterfaceIsImplemented() {
assertThat(template.query(Person.class).as(Contact.class).all()).allMatch(it -> it instanceof Person);
}
private static Query queryLuke() {
return query(where("firstname").is("luke")).withAllowFiltering();
}
private static Query querySpock() {
return query(where("firstname").is("spock")).withAllowFiltering();
}
interface Contact {}
@Data
@Table
static class Person implements Contact {
@Id String id;
@Indexed String firstname;
@Indexed String lastname;
}
interface PersonProjection {
String getFirstname();
}
public interface PersonSpELProjection {
@Value("#{target.firstname}")
String getName();
}
@Data
static class Human {
@Id String id;
}
@Data
@AllArgsConstructor
@NoArgsConstructor
static class Jedi {
@Column("firstname") String name;
}
private void initPersons() {
han = new Person();
han.firstname = "han";
han.lastname = "solo";
han.id = "id-1";
luke = new Person();
luke.firstname = "luke";
luke.lastname = "skywalker";
luke.id = "id-2";
template.insert(han);
template.insert(luke);
}
}

121
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/ExecutableUpdateOperationSupportTests.java Normal file
View File

@@ -0,0 +1,121 @@
/*
* 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 static org.assertj.core.api.Assertions.*;
import static org.springframework.data.cassandra.core.query.Criteria.*;
import static org.springframework.data.cassandra.core.query.Query.*;
import static org.springframework.data.cassandra.core.query.Update.*;
import lombok.Data;
import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
import org.springframework.data.annotation.Id;
import org.springframework.data.cassandra.core.convert.MappingCassandraConverter;
import org.springframework.data.cassandra.core.cql.CqlIdentifier;
import org.springframework.data.cassandra.core.mapping.Column;
import org.springframework.data.cassandra.core.mapping.Indexed;
import org.springframework.data.cassandra.core.mapping.Table;
import org.springframework.data.cassandra.core.query.Query;
import org.springframework.data.cassandra.test.util.AbstractKeyspaceCreatingIntegrationTest;
/**
* Integration tests for {@link ExecutableUpdateOperationSupport}.
*
* @author Mark Paluch
*/
public class ExecutableUpdateOperationSupportTests extends AbstractKeyspaceCreatingIntegrationTest {
CassandraAdminTemplate template;
Person han;
Person luke;
@Before
public void setUp() {
template = new CassandraAdminTemplate(session, new MappingCassandraConverter());
template.dropTable(true, CqlIdentifier.of("person"));
template.createTable(false, CqlIdentifier.of("person"), Person.class, Collections.emptyMap());
han = new Person();
han.firstname = "han";
han.id = "id-1";
luke = new Person();
luke.firstname = "luke";
luke.id = "id-2";
template.insert(han);
template.insert(luke);
}
@Test(expected = IllegalArgumentException.class) // DATACASS-485
public void domainTypeIsRequired() {
template.update(null);
}
@Test(expected = IllegalArgumentException.class) // DATACASS-485
public void queryIsRequired() {
template.update(Person.class).matching(null);
}
@Test(expected = IllegalArgumentException.class) // DATACASS-485
public void tableIsRequiredOnSet() {
template.update(Person.class).inTable((CqlIdentifier) null);
}
@Test // DATACASS-485
public void updateAllMatching() {
WriteResult writeResult = template.update(Person.class).matching(queryHan()).apply(update("firstname", "Han"))
.all();
assertThat(writeResult.wasApplied()).isTrue();
}
@Test // DATACASS-485
public void updateWithDifferentDomainClassAndCollection() {
WriteResult writeResult = template.update(Jedi.class).inTable("person").matching(query(where("id").is(han.getId())))
.apply(update("name", "Han")).all();
assertThat(writeResult.wasApplied()).isTrue();
assertThat(template.selectOne(queryHan(), Person.class)).isNotEqualTo(han).hasFieldOrPropertyWithValue("firstname",
"Han");
}
private Query queryHan() {
return query(where("id").is(han.getId()));
}
@Data
@Table
static class Person {
@Id String id;
@Indexed String firstname;
}
@Data
static class Jedi {
@Column("firstname") String name;
}
}