From fe71cb6050433b65e7a62913f6164bc012b2b861 Mon Sep 17 00:00:00 2001 From: Alex Shvid Date: Tue, 26 Nov 2013 21:30:37 -0800 Subject: [PATCH] created SimpleCassandraRepository --- .../core/CassandraDataOperations.java | 28 +- .../cassandra/core/CassandraDataTemplate.java | 49 +++- .../query/CassandraEntityInformation.java | 44 ++++ .../support/CassandraRepositoryFactory.java | 92 +++++++ .../CassandraRepositoryFactoryBean.java | 51 +++- .../MappingCassandraEntityInformation.java | 107 ++++++++ .../support/SimpleCassandraRepository.java | 244 ++++++++++++++++++ .../src/test/resources/META-INF/beans.xml | 6 + .../cassandra-named-queries.properties | 1 + ...fileRepositoryIntegrationTests-context.xml | 17 +- 10 files changed, 621 insertions(+), 18 deletions(-) create mode 100644 spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/CassandraEntityInformation.java create mode 100644 spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/CassandraRepositoryFactory.java create mode 100644 spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/MappingCassandraEntityInformation.java create mode 100644 spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/SimpleCassandraRepository.java create mode 100644 spring-data-cassandra/src/test/resources/META-INF/beans.xml create mode 100644 spring-data-cassandra/src/test/resources/META-INF/cassandra-named-queries.properties diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraDataOperations.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraDataOperations.java index 39a0722a8..4e0f8aecc 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraDataOperations.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraDataOperations.java @@ -50,6 +50,16 @@ public interface CassandraDataOperations { */ List select(String cql, Class selectClass); + /** + * Execute query and convert ResultSet to the list of entities + * + * @param selectQuery must not be {@literal null}. + * @param selectClass must not be {@literal null}, mapped entity type. + * @return + */ + + List select(Select selectQuery, Class selectClass); + /** * Execute query and convert ResultSet to the entity * @@ -59,12 +69,26 @@ public interface CassandraDataOperations { */ T selectOne(String cql, Class selectClass); - List select(Select selectQuery, Class selectClass); - T selectOne(Select selectQuery, Class selectClass); + /** + * Counts rows for given query + * + * @param selectQuery + * @return + */ + Long count(Select selectQuery); + /** + * Counts all rows for given table + * + * @param tableName + * @return + */ + + Long count(String tableName); + /** * Insert the given object to the table by id. * diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraDataTemplate.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraDataTemplate.java index 32e577a9b..6772c7827 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraDataTemplate.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraDataTemplate.java @@ -18,7 +18,6 @@ package org.springframework.data.cassandra.core; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; -import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; @@ -43,6 +42,7 @@ import com.datastax.driver.core.ResultSet; import com.datastax.driver.core.Row; import com.datastax.driver.core.Session; import com.datastax.driver.core.querybuilder.Batch; +import com.datastax.driver.core.querybuilder.QueryBuilder; import com.datastax.driver.core.querybuilder.Select; /** @@ -123,13 +123,22 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr } /* (non-Javadoc) - * @see org.springframework.data.cassandra.core.CassandraOperations#selectCount(com.datastax.driver.core.querybuilder.Select) + * @see org.springframework.data.cassandra.core.CassandraOperations#count(com.datastax.driver.core.querybuilder.Select) */ @Override public Long count(Select selectQuery) { return doSelectCount(selectQuery); } + /* (non-Javadoc) + * @see org.springframework.data.cassandra.core.CassandraOperations#count(java.lang.String) + */ + @Override + public Long count(String tableName) { + Select select = QueryBuilder.select().countAll().from(tableName); + return doSelectCount(select); + } + /* (non-Javadoc) * @see org.springframework.data.cassandra.core.CassandraOperations#delete(java.util.List) */ @@ -165,7 +174,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public void delete(List entities, String tableName) { - delete(entities, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + delete(entities, tableName, defaultOptions); } /* (non-Javadoc) @@ -223,7 +233,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public void delete(T entity, String tableName) { - delete(entity, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + delete(entity, tableName, defaultOptions); } /* (non-Javadoc) @@ -280,7 +291,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public void deleteAsynchronously(List entities, String tableName) { - insertAsynchronously(entities, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + insertAsynchronously(entities, tableName, defaultOptions); } /* (non-Javadoc) @@ -338,7 +350,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public void deleteAsynchronously(T entity, String tableName) { - deleteAsynchronously(entity, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + deleteAsynchronously(entity, tableName, defaultOptions); } /* (non-Javadoc) @@ -430,7 +443,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public List insert(List entities, String tableName) { - return insert(entities, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + return insert(entities, tableName, defaultOptions); } /* (non-Javadoc) @@ -488,7 +502,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public T insert(T entity, String tableName) { - return insert(entity, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + return insert(entity, tableName, defaultOptions); } /* (non-Javadoc) @@ -545,7 +560,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public List insertAsynchronously(List entities, String tableName) { - return insertAsynchronously(entities, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + return insertAsynchronously(entities, tableName, defaultOptions); } /* (non-Javadoc) @@ -603,7 +619,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public T insertAsynchronously(T entity, String tableName) { - return insertAsynchronously(entity, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + return insertAsynchronously(entity, tableName, defaultOptions); } /* (non-Javadoc) @@ -695,7 +712,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public List update(List entities, String tableName) { - return update(entities, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + return update(entities, tableName, defaultOptions); } /* (non-Javadoc) @@ -753,7 +771,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public T update(T entity, String tableName) { - return update(entity, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + return update(entity, tableName, defaultOptions); } /* (non-Javadoc) @@ -810,7 +829,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public List updateAsynchronously(List entities, String tableName) { - return updateAsynchronously(entities, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + return updateAsynchronously(entities, tableName, defaultOptions); } /* (non-Javadoc) @@ -868,7 +888,8 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr */ @Override public T updateAsynchronously(T entity, String tableName) { - return updateAsynchronously(entity, tableName, new HashMap()); + Map defaultOptions = Collections.emptyMap(); + return updateAsynchronously(entity, tableName, defaultOptions); } /* (non-Javadoc) diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/CassandraEntityInformation.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/CassandraEntityInformation.java new file mode 100644 index 000000000..528defa6d --- /dev/null +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/CassandraEntityInformation.java @@ -0,0 +1,44 @@ +/* + * Copyright 2011 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.repository.query; + +import java.io.Serializable; + +import org.springframework.data.repository.core.EntityInformation; + +/** + * Cassandra specific {@link EntityInformation}. + * + * @author Alex Shvid + * + */ +public interface CassandraEntityInformation extends EntityInformation { + + /** + * Returns the name of the table the entity shall be persisted to. + * + * @return + */ + String getTableName(); + + /** + * Returns the column that the id will be persisted to. + * + * @return + */ + String getIdColumn(); + +} diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/CassandraRepositoryFactory.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/CassandraRepositoryFactory.java new file mode 100644 index 000000000..0fa105867 --- /dev/null +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/CassandraRepositoryFactory.java @@ -0,0 +1,92 @@ +/* + * Copyright 2010-2012 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.repository.support; + +import java.io.Serializable; + +import org.springframework.cassandra.core.CassandraOperations; +import org.springframework.data.cassandra.core.CassandraDataOperations; +import org.springframework.data.cassandra.mapping.CassandraPersistentEntity; +import org.springframework.data.cassandra.mapping.CassandraPersistentProperty; +import org.springframework.data.cassandra.repository.CassandraRepository; +import org.springframework.data.cassandra.repository.query.CassandraEntityInformation; +import org.springframework.data.mapping.context.MappingContext; +import org.springframework.data.mapping.model.MappingException; +import org.springframework.data.repository.core.RepositoryMetadata; +import org.springframework.data.repository.core.support.RepositoryFactorySupport; +import org.springframework.util.Assert; + +/** + * Factory to create {@link CassandraRepository} instances. + * + * @author Alex Shvid + * + */ + +public class CassandraRepositoryFactory extends RepositoryFactorySupport { + + private final CassandraOperations operations; + private final CassandraDataOperations dataOperations; + private final MappingContext, CassandraPersistentProperty> mappingContext; + + /** + * Creates a new {@link MongoRepositoryFactory} with the given {@link MongoOperations}. + * + * @param mongoOperations must not be {@literal null} + */ + public CassandraRepositoryFactory(CassandraOperations operations, CassandraDataOperations dataOperations) { + + Assert.notNull(operations); + Assert.notNull(dataOperations); + + this.operations = operations; + this.dataOperations = dataOperations; + this.mappingContext = dataOperations.getConverter().getMappingContext(); + } + + @Override + protected Class getRepositoryBaseClass(RepositoryMetadata metadata) { + return SimpleCassandraRepository.class; + } + + @Override + @SuppressWarnings({ "rawtypes", "unchecked" }) + protected Object getTargetRepository(RepositoryMetadata metadata) { + + CassandraEntityInformation entityInformation = getEntityInformation(metadata.getDomainType()); + + return new SimpleCassandraRepository(entityInformation, operations, dataOperations); + + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.core.support.RepositoryFactorySupport#getEntityInformation(java.lang.Class) + */ + @Override + @SuppressWarnings("unchecked") + public CassandraEntityInformation getEntityInformation(Class domainClass) { + + CassandraPersistentEntity entity = mappingContext.getPersistentEntity(domainClass); + + if (entity == null) { + throw new MappingException(String.format("Could not lookup mapping metadata for domain class %s!", + domainClass.getName())); + } + + return new MappingCassandraEntityInformation((CassandraPersistentEntity) entity); + } +} diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/CassandraRepositoryFactoryBean.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/CassandraRepositoryFactoryBean.java index e32ba9261..67471d546 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/CassandraRepositoryFactoryBean.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/CassandraRepositoryFactoryBean.java @@ -15,7 +15,15 @@ */ package org.springframework.data.cassandra.repository.support; +import java.io.Serializable; + +import org.springframework.cassandra.core.CassandraOperations; +import org.springframework.data.cassandra.core.CassandraDataOperations; import org.springframework.data.cassandra.repository.CassandraRepository; +import org.springframework.data.repository.Repository; +import org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport; +import org.springframework.data.repository.core.support.RepositoryFactorySupport; +import org.springframework.util.Assert; /** * {@link org.springframework.beans.factory.FactoryBean} to create {@link CassandraRepository} instances. @@ -23,6 +31,47 @@ import org.springframework.data.cassandra.repository.CassandraRepository; * @author Alex Shvid * */ -public class CassandraRepositoryFactoryBean { +public class CassandraRepositoryFactoryBean, S, ID extends Serializable> extends + RepositoryFactoryBeanSupport { + + private CassandraOperations operations; + private CassandraDataOperations dataOperations; + + @Override + protected RepositoryFactorySupport createRepositoryFactory() { + return new CassandraRepositoryFactory(operations, dataOperations); + } + + /** + * Configures the {@link CassandraOperations} to be used. + * + * @param operations the operations to set + */ + public void setCassandraOperations(CassandraOperations operations) { + this.operations = operations; + } + + /** + * Configures the {@link CassandraDataOperations} to be used. + * + * @param operations the operations to set + */ + public void setCassandraDataOperations(CassandraDataOperations dataOperations) { + this.dataOperations = dataOperations; + setMappingContext(dataOperations.getConverter().getMappingContext()); + } + + /* + * (non-Javadoc) + * + * @see + * org.springframework.data.repository.support.RepositoryFactoryBeanSupport + * #afterPropertiesSet() + */ + @Override + public void afterPropertiesSet() { + super.afterPropertiesSet(); + Assert.notNull(dataOperations, "CassandraDataOperations must not be null!"); + } } diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/MappingCassandraEntityInformation.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/MappingCassandraEntityInformation.java new file mode 100644 index 000000000..a49c61178 --- /dev/null +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/MappingCassandraEntityInformation.java @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2011 by the original author(s). + * + * 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.repository.support; + +import java.io.Serializable; + +import org.springframework.data.cassandra.mapping.CassandraPersistentEntity; +import org.springframework.data.cassandra.mapping.CassandraPersistentProperty; +import org.springframework.data.cassandra.repository.query.CassandraEntityInformation; +import org.springframework.data.mapping.model.BeanWrapper; +import org.springframework.data.repository.core.support.AbstractEntityInformation; + +/** + * {@link CassandraEntityInformation} implementation using a {@link CassandraPersistentEntity} instance to lookup the + * necessary information. Can be configured with a custom collection to be returned which will trump the one returned by + * the {@link CassandraPersistentEntity} if given. + * + * @author Alex Shvid + * + */ +public class MappingCassandraEntityInformation extends AbstractEntityInformation + implements CassandraEntityInformation { + + private final CassandraPersistentEntity entityMetadata; + private final String customTableName; + + /** + * Creates a new {@link MappingCassandraEntityInformation} for the given {@link CassandraPersistentEntity}. + * + * @param entity must not be {@literal null}. + */ + public MappingCassandraEntityInformation(CassandraPersistentEntity entity) { + this(entity, null); + } + + /** + * Creates a new {@link MappingCassandraEntityInformation} for the given {@link CassandraPersistentEntity} and custom + * table name. + * + * @param entity must not be {@literal null}. + * @param customTableName + */ + public MappingCassandraEntityInformation(CassandraPersistentEntity entity, String customTableName) { + super(entity.getType()); + this.entityMetadata = entity; + this.customTableName = customTableName; + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.support.EntityInformation#getId(java.lang.Object) + */ + @SuppressWarnings("unchecked") + @Override + public ID getId(T entity) { + + CassandraPersistentProperty idProperty = entityMetadata.getIdProperty(); + + if (idProperty == null) { + return null; + } + + try { + return (ID) BeanWrapper.create(entity, null).getProperty(idProperty); + } catch (Exception e) { + throw new RuntimeException(e); + } + } + + /* (non-Javadoc) + * @see org.springframework.data.repository.support.EntityInformation#getIdType() + */ + @SuppressWarnings("unchecked") + @Override + public Class getIdType() { + return (Class) entityMetadata.getIdProperty().getType(); + } + + /* (non-Javadoc) + * @see org.springframework.data.mongodb.repository.CassandraEntityInformation#getTableName() + */ + @Override + public String getTableName() { + return customTableName == null ? entityMetadata.getTable() : customTableName; + } + + /* (non-Javadoc) + * @see org.springframework.data.mongodb.repository.CassandraEntityInformation#getIdColumn() + */ + public String getIdColumn() { + return entityMetadata.getIdProperty().getName(); + } + +} diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/SimpleCassandraRepository.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/SimpleCassandraRepository.java new file mode 100644 index 000000000..cee155359 --- /dev/null +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/support/SimpleCassandraRepository.java @@ -0,0 +1,244 @@ +/* + * Copyright 2010-2012 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.repository.support; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import org.springframework.cassandra.core.CassandraOperations; +import org.springframework.data.cassandra.core.CassandraDataOperations; +import org.springframework.data.cassandra.core.CassandraDataTemplate; +import org.springframework.data.cassandra.repository.CassandraRepository; +import org.springframework.data.cassandra.repository.query.CassandraEntityInformation; +import org.springframework.util.Assert; + +import com.datastax.driver.core.querybuilder.Clause; +import com.datastax.driver.core.querybuilder.Delete; +import com.datastax.driver.core.querybuilder.QueryBuilder; +import com.datastax.driver.core.querybuilder.Select; + +/** + * Repository base implementation for Cassandra. + * + * @author Alex Shvid + * + */ + +public class SimpleCassandraRepository implements CassandraRepository { + + private final CassandraOperations operations; + private final CassandraDataOperations dataOperations; + private final CassandraEntityInformation entityInformation; + + /** + * Creates a new {@link SimpleCassandraRepository} for the given {@link CassandraEntityInformation} and + * {@link CassandraDataTemplate}. + * + * @param metadata must not be {@literal null}. + * @param template must not be {@literal null}. + */ + public SimpleCassandraRepository(CassandraEntityInformation metadata, CassandraOperations operations, + CassandraDataOperations dataOperations) { + + Assert.notNull(operations); + Assert.notNull(dataOperations); + Assert.notNull(metadata); + + this.entityInformation = metadata; + this.operations = operations; + this.dataOperations = dataOperations; + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.CrudRepository#save(java.lang.Object) + */ + public S save(S entity) { + + Assert.notNull(entity, "Entity must not be null!"); + + // INSERT OR OPDATE? + + dataOperations.update(entity, entityInformation.getTableName()); + return entity; + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.CrudRepository#save(java.lang.Iterable) + */ + public List save(Iterable entities) { + + Assert.notNull(entities, "The given Iterable of entities not be null!"); + + List result = new ArrayList(); + + for (S entity : entities) { + save(entity); + result.add(entity); + } + + return result; + } + + private Clause getIdClause(ID id) { + Clause clause = QueryBuilder.eq(entityInformation.getIdColumn(), id); + return clause; + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.CrudRepository#findOne(java.io.Serializable) + */ + public T findOne(ID id) { + Assert.notNull(id, "The given id must not be null!"); + + Select select = QueryBuilder.select().all().from(entityInformation.getTableName()); + select.where(getIdClause(id)); + + return dataOperations.selectOne(select, entityInformation.getJavaType()); + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.CrudRepository#exists(java.io.Serializable) + */ + public boolean exists(ID id) { + + Assert.notNull(id, "The given id must not be null!"); + + Select select = QueryBuilder.select().countAll().from(entityInformation.getTableName()); + select.where(getIdClause(id)); + + Long num = dataOperations.count(select); + return num != null && num.longValue() > 0; + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.CrudRepository#count() + */ + public long count() { + return dataOperations.count(entityInformation.getTableName()); + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.CrudRepository#delete(java.io.Serializable) + */ + public void delete(ID id) { + Assert.notNull(id, "The given id must not be null!"); + + Delete delete = QueryBuilder.delete().all().from(entityInformation.getTableName()); + delete.where(getIdClause(id)); + + operations.execute(delete.getQueryString()); + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.CrudRepository#delete(java.lang.Object) + */ + public void delete(T entity) { + Assert.notNull(entity, "The given entity must not be null!"); + delete(entityInformation.getId(entity)); + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.CrudRepository#delete(java.lang.Iterable) + */ + public void delete(Iterable entities) { + + Assert.notNull(entities, "The given Iterable of entities not be null!"); + + for (T entity : entities) { + delete(entity); + } + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.CrudRepository#deleteAll() + */ + public void deleteAll() { + Delete delete = QueryBuilder.delete().all().from(entityInformation.getTableName()); + operations.execute(delete.getQueryString()); + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.CrudRepository#findAll() + */ + public List findAll() { + Select select = QueryBuilder.select().all().from(entityInformation.getTableName()); + return findAll(select); + } + + /* + * (non-Javadoc) + * @see org.springframework.data.repository.CrudRepository#findAll(java.lang.Iterable) + */ + public Iterable findAll(Iterable ids) { + + List parameters = new ArrayList(); + for (ID id : ids) { + parameters.add(id); + } + Clause clause = QueryBuilder.in(entityInformation.getIdColumn(), parameters.toArray()); + Select select = QueryBuilder.select().all().from(entityInformation.getTableName()); + select.where(clause); + + return findAll(select); + } + + private List findAll(Select query) { + + if (query == null) { + return Collections.emptyList(); + } + + return dataOperations.select(query, entityInformation.getJavaType()); + } + + /** + * Returns the underlying {@link CassandraOperations} instance. + * + * @return + */ + protected CassandraOperations getCassandraOperations() { + return this.operations; + } + + /** + * Returns the underlying {@link CassandraDataOperations} instance. + * + * @return + */ + protected CassandraDataOperations getCassandraDataOperations() { + return this.dataOperations; + } + + /** + * @return the entityInformation + */ + protected CassandraEntityInformation getEntityInformation() { + return entityInformation; + } + +} diff --git a/spring-data-cassandra/src/test/resources/META-INF/beans.xml b/spring-data-cassandra/src/test/resources/META-INF/beans.xml new file mode 100644 index 000000000..73ae3a251 --- /dev/null +++ b/spring-data-cassandra/src/test/resources/META-INF/beans.xml @@ -0,0 +1,6 @@ + + + + diff --git a/spring-data-cassandra/src/test/resources/META-INF/cassandra-named-queries.properties b/spring-data-cassandra/src/test/resources/META-INF/cassandra-named-queries.properties new file mode 100644 index 000000000..168cc6a11 --- /dev/null +++ b/spring-data-cassandra/src/test/resources/META-INF/cassandra-named-queries.properties @@ -0,0 +1 @@ +Profile.findByNamedQuery=SELECT firstName FROM table WHERE firstName=?0 diff --git a/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/repository/ProfileRepositoryIntegrationTests-context.xml b/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/repository/ProfileRepositoryIntegrationTests-context.xml index 9a5e68f7d..711e28f53 100644 --- a/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/repository/ProfileRepositoryIntegrationTests-context.xml +++ b/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/repository/ProfileRepositoryIntegrationTests-context.xml @@ -2,9 +2,11 @@ + http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd + http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"> @@ -58,4 +60,17 @@ + + + + + + + + + + + + +