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

merged from master

Browse Source
This commit is contained in:
Matthew Adams
2013-12-12 11:40:52 -06:00
parent 68b624ec83 9811cadb56
commit a31d0a7202
73 changed files with 1548 additions and 2087 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
pom.xml
View File

@@ -27,11 +27,14 @@
</modules>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<project.type>multi</project.type>
<dist.id>spring-data-cassandra</dist.id>
<springdata.commons>1.6.2.RELEASE</springdata.commons>
<cassandra-unit.version>1.2.0.1</cassandra-unit.version>
<cassandra-driver-core.version>1.0.4-dse</cassandra-driver-core.version>
<failsafe.version>2.16</failsafe.version>
</properties>
<developers>
@@ -64,7 +67,7 @@
<name>Alex Shvid</name>
<email>a at shvid.com</email>
<roles>
<role>Project Lead</role>
<role>Project Lead</role>
<role>Developer</role>
</roles>
<timezone>-8</timezone>
@@ -123,10 +126,19 @@
<version>${spring}</version>
</dependency>
<!-- Logging Dependencies -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.4</version>
<artifactId>log4j-over-slf4j</artifactId>
<version>${slf4j}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jul-to-slf4j</artifactId>
<version>${slf4j}</version>
<scope>test</scope>
</dependency>
<!-- CDI -->
@@ -227,7 +239,7 @@
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<argLine>-Xmx2048m -XX:MaxPermSize=512m</argLine>
<argLine>-Xmx2048m -XX:MaxPermSize=512m</argLine>
<parallel>methods</parallel>
<threadCount>10</threadCount>
<useFile>false</useFile>
@@ -246,8 +258,10 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
<version>${failsafe.version}</version>
<configuration>
<argLine>-Xmx2048m -XX:MaxPermSize=512m</argLine>
<forkMode>always</forkMode>
<argLine>-Xmx2048m -XX:MaxPermSize=512m</argLine>
<useFile>false</useFile>
<includes>
<include>**/test/integration/**/*.java</include>

11
spring-cassandra/pom.xml
View File

@@ -44,6 +44,12 @@
<dependency>
<groupId>com.datastax.cassandra</groupId>
<artifactId>cassandra-driver-core</artifactId>
<exclusions>
<exclusion>
<artifactId>log4j</artifactId>
<groupId>log4j</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>javax.enterprise</groupId>
@@ -72,6 +78,11 @@
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib-nodep</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>javax.el</groupId>
<artifactId>el-api</artifactId>

6
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraClusterFactoryBean.java → spring-cassandra/src/main/java/org/springframework/cassandra/config/CassandraClusterFactoryBean.java
View File

@@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.cassandra.core;
package org.springframework.cassandra.config;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
@@ -21,9 +21,6 @@ import org.springframework.beans.factory.InitializingBean;
import org.springframework.cassandra.support.CassandraExceptionTranslator;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.support.PersistenceExceptionTranslator;
import org.springframework.data.cassandra.config.CompressionType;
import org.springframework.data.cassandra.config.PoolingOptionsConfig;
import org.springframework.data.cassandra.config.SocketOptionsConfig;
import org.springframework.util.StringUtils;
import com.datastax.driver.core.AuthProvider;
@@ -40,6 +37,7 @@ import com.datastax.driver.core.policies.RetryPolicy;
* Convenient factory for configuring a Cassandra Cluster.
*
* @author Alex Shvid
* @author Matthew T. Adams
*/
public class CassandraClusterFactoryBean implements FactoryBean<Cluster>, InitializingBean, DisposableBean,

109
spring-cassandra/src/main/java/org/springframework/cassandra/config/CassandraSessionFactoryBean.java Normal file
View File

@@ -0,0 +1,109 @@
/*
* Copyright 2011-2013 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.cassandra.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.cassandra.support.CassandraExceptionTranslator;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.support.PersistenceExceptionTranslator;
import org.springframework.util.StringUtils;
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;
/**
* Factory for configuring a Cassandra {@link Session}, which is a thread-safe singleton. As such, it is sufficient to
* have one {@link Session} per application and keyspace.
*
* @author Alex Shvid
* @author Matthew T. Adams
*/
public class CassandraSessionFactoryBean implements FactoryBean<Session>, InitializingBean, DisposableBean,
PersistenceExceptionTranslator {
private static final Logger log = LoggerFactory.getLogger(CassandraSessionFactoryBean.class);
public static final String DEFAULT_REPLICATION_STRATEGY = "SimpleStrategy";
public static final int DEFAULT_REPLICATION_FACTOR = 1;
private Cluster cluster;
private Session session;
private String keyspaceName;
private final PersistenceExceptionTranslator exceptionTranslator = new CassandraExceptionTranslator();
public Session getObject() {
return session;
}
/*
* (non-Javadoc)
* @see org.springframework.beans.factory.FactoryBean#getObjectType()
*/
public Class<? extends Session> getObjectType() {
return Session.class;
}
/*
* (non-Javadoc)
* @see org.springframework.beans.factory.FactoryBean#isSingleton()
*/
public boolean isSingleton() {
return true;
}
/*
* (non-Javadoc)
* @see org.springframework.dao.support.PersistenceExceptionTranslator#translateExceptionIfPossible(java.lang.RuntimeException)
*/
public DataAccessException translateExceptionIfPossible(RuntimeException ex) {
return exceptionTranslator.translateExceptionIfPossible(ex);
}
/*
* (non-Javadoc)
* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
*/
public void afterPropertiesSet() throws Exception {
if (cluster == null) {
throw new IllegalArgumentException("at least one cluster is required");
}
this.session = StringUtils.hasText(this.keyspaceName) ? cluster.connect(keyspaceName) : cluster.connect();
}
/*
* (non-Javadoc)
* @see org.springframework.beans.factory.DisposableBean#destroy()
*/
public void destroy() throws Exception {
this.session.shutdown();
}
public void setKeyspaceName(String keyspaceName) {
this.keyspaceName = keyspaceName;
}
public void setCluster(Cluster cluster) {
this.cluster = cluster;
}
}

63
spring-cassandra/src/main/java/org/springframework/cassandra/config/CassandraTemplateFactoryBean.java Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2011-2013 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.cassandra.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.cassandra.core.CassandraOperations;
import org.springframework.cassandra.core.CassandraTemplate;
import com.datastax.driver.core.Session;
/**
* Factory for configuring a {@link CassandraTemplate}.
*
* @author Matthew T. Adams
*/
public class CassandraTemplateFactoryBean implements FactoryBean<CassandraOperations>, InitializingBean {
private static final Logger log = LoggerFactory.getLogger(CassandraTemplateFactoryBean.class);
private CassandraTemplate template;
private Session session;
public CassandraOperations getObject() {
return template;
}
public Class<? extends CassandraOperations> getObjectType() {
return CassandraOperations.class;
}
public boolean isSingleton() {
return true;
}
public void afterPropertiesSet() throws Exception {
if (session == null) {
throw new IllegalStateException("session is required");
}
this.template = new CassandraTemplate(session);
}
public void setSession(Session session) {
this.session = session;
}
}

2
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CompressionType.java → spring-cassandra/src/main/java/org/springframework/cassandra/config/CompressionType.java
View File

@@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.cassandra.config;
package org.springframework.cassandra.config;
/**
* Simple enumeration for the various compression types.

57
spring-cassandra/src/main/java/org/springframework/cassandra/config/KeyspaceAttributes.java Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2011-2013 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.cassandra.config;
/**
* Keyspace attributes.
*
* @author Alex Shvid
* @author Matthew T. Adams
*/
public class KeyspaceAttributes {
public static final String DEFAULT_REPLICATION_STRATEGY = "SimpleStrategy";
public static final int DEFAULT_REPLICATION_FACTOR = 1;
public static final boolean DEFAULT_DURABLE_WRITES = true;
private String replicationStrategy = DEFAULT_REPLICATION_STRATEGY;
private int replicationFactor = DEFAULT_REPLICATION_FACTOR;
private boolean durableWrites = DEFAULT_DURABLE_WRITES;
public String getReplicationStrategy() {
return replicationStrategy;
}
public void setReplicationStrategy(String replicationStrategy) {
this.replicationStrategy = replicationStrategy;
}
public int getReplicationFactor() {
return replicationFactor;
}
public void setReplicationFactor(int replicationFactor) {
this.replicationFactor = replicationFactor;
}
public boolean isDurableWrites() {
return durableWrites;
}
public void setDurableWrites(boolean durableWrites) {
this.durableWrites = durableWrites;
}
}

6
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/PoolingOptionsConfig.java → spring-cassandra/src/main/java/org/springframework/cassandra/config/PoolingOptionsConfig.java
View File

@@ -13,12 +13,13 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.cassandra.config;
package org.springframework.cassandra.config;
/**
* Pooling options POJO. Can be remote or local.
* Pooling options.
*
* @author Alex Shvid
* @author Matthew T. Adams
*/
public class PoolingOptionsConfig {
@@ -58,5 +59,4 @@ public class PoolingOptionsConfig {
public void setMaxConnections(Integer maxConnections) {
this.maxConnections = maxConnections;
}
}

6
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/SocketOptionsConfig.java → spring-cassandra/src/main/java/org/springframework/cassandra/config/SocketOptionsConfig.java
View File

@@ -13,12 +13,13 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.cassandra.config;
package org.springframework.cassandra.config;
/**
* Socket options POJO. Uses to configure Netty.
* Socket options.
*
* @author Alex Shvid
* @author Matthew T. Adams
*/
public class SocketOptionsConfig {
@@ -85,5 +86,4 @@ public class SocketOptionsConfig {
public void setSendBufferSize(Integer sendBufferSize) {
this.sendBufferSize = sendBufferSize;
}
}

49
spring-cassandra/src/main/java/org/springframework/cassandra/config/TableAttributes.java Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2011-2013 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.cassandra.config;
/**
* Table attributes are used for manipulation around table at the startup (create/update/validate).
*
* @author Alex Shvid
*/
public class TableAttributes {
private String entity;
private String name;
public String getEntity() {
return entity;
}
public void setEntity(String entity) {
this.entity = entity;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "TableAttributes [entity=" + entity + "]";
}
}

65
spring-cassandra/src/main/java/org/springframework/cassandra/config/java/AbstractCassandraConfiguration.java Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2011-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.cassandra.config.java;
import org.springframework.cassandra.core.CassandraOperations;
import org.springframework.cassandra.core.CassandraTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;
/**
* Base class for Spring Cassandra configuration using JavaConfig.
*
* @author Alex Shvid
* @author Matthew T. Adams
*/
@Configuration
public abstract class AbstractCassandraConfiguration {
/**
* The name of the keyspace to connect to. If {@literal null} or empty, then the system keyspace will be used.
*/
protected abstract String getKeyspaceName();
/**
* The {@link Cluster} instance to connect to. Must not be null.
*/
@Bean
public abstract Cluster cluster();
/**
* Creates a {@link Session} using the {@link Cluster} instance configured in {@link #cluster()}.
*
* @see #cluster()
*/
@Bean
public Session session() {
String keyspaceName = getKeyspaceName();
return StringUtils.hasText(keyspaceName) ? cluster().connect(keyspaceName) : cluster().connect();
}
/**
* A {@link CassandraTemplate} created from the {@link Session} returned by {@link #session()}.
*/
@Bean
public CassandraOperations template() {
return new CassandraTemplate(session());
}
}

5
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/BeanNames.java → spring-cassandra/src/main/java/org/springframework/cassandra/config/xml/BeanNames.java
View File

@@ -13,11 +13,12 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.cassandra.config;
package org.springframework.cassandra.config.xml;
/**
* @author Alex Shvid
* @author David Webb
* @author Matthew T. Adams
*/
public final class BeanNames {
@@ -27,5 +28,5 @@ public final class BeanNames {
public static final String CASSANDRA_CLUSTER = "cassandra-cluster";
public static final String CASSANDRA_KEYSPACE = "cassandra-keyspace";
public static final String CASSANDRA_SESSION = "cassandra-session";
public static final String CASSANDRA_TEMPLATE = "cassandra-template";
}

52
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraClusterParser.java → spring-cassandra/src/main/java/org/springframework/cassandra/config/xml/CassandraClusterParser.java
View File

@@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.cassandra.config;
package org.springframework.cassandra.config.xml;
import java.util.List;
@@ -23,8 +23,10 @@ import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.data.cassandra.core.CassandraClusterFactoryBean;
import org.springframework.data.config.ParsingUtils;
import org.springframework.cassandra.config.CassandraClusterFactoryBean;
import org.springframework.cassandra.config.CompressionType;
import org.springframework.cassandra.config.PoolingOptionsConfig;
import org.springframework.cassandra.config.SocketOptionsConfig;
import org.springframework.util.StringUtils;
import org.springframework.util.xml.DomUtils;
import org.w3c.dom.Element;
@@ -33,6 +35,7 @@ import org.w3c.dom.Element;
* Parser for &lt;cluster;gt; definitions.
*
* @author Alex Shvid
* @author Matthew T. Adams
*/
public class CassandraClusterParser extends AbstractSimpleBeanDefinitionParser {
@@ -72,15 +75,14 @@ public class CassandraClusterParser extends AbstractSimpleBeanDefinitionParser {
builder.addPropertyValue("compressionType", CompressionType.valueOf(compression));
}
postProcess(builder, element);
parseChildElements(builder, element);
}
@Override
protected void postProcess(BeanDefinitionBuilder builder, Element element) {
List<Element> subElements = DomUtils.getChildElements(element);
protected void parseChildElements(BeanDefinitionBuilder builder, Element element) {
List<Element> elements = DomUtils.getChildElements(element);
// parse nested elements
for (Element subElement : subElements) {
for (Element subElement : elements) {
String name = subElement.getLocalName();
if ("local-pooling-options".equals(name)) {
@@ -95,24 +97,28 @@ public class CassandraClusterParser extends AbstractSimpleBeanDefinitionParser {
}
private BeanDefinition parsePoolingOptions(Element element) {
BeanDefinitionBuilder defBuilder = BeanDefinitionBuilder.genericBeanDefinition(PoolingOptionsConfig.class);
ParsingUtils.setPropertyValue(defBuilder, element, "min-simultaneous-requests", "minSimultaneousRequests");
ParsingUtils.setPropertyValue(defBuilder, element, "max-simultaneous-requests", "maxSimultaneousRequests");
ParsingUtils.setPropertyValue(defBuilder, element, "core-connections", "coreConnections");
ParsingUtils.setPropertyValue(defBuilder, element, "max-connections", "maxConnections");
return defBuilder.getBeanDefinition();
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(PoolingOptionsConfig.class);
ParsingUtils.setPropertyValue(builder, element, "min-simultaneous-requests", "minSimultaneousRequests");
ParsingUtils.setPropertyValue(builder, element, "max-simultaneous-requests", "maxSimultaneousRequests");
ParsingUtils.setPropertyValue(builder, element, "core-connections", "coreConnections");
ParsingUtils.setPropertyValue(builder, element, "max-connections", "maxConnections");
return builder.getBeanDefinition();
}
private BeanDefinition parseSocketOptions(Element element) {
BeanDefinitionBuilder defBuilder = BeanDefinitionBuilder.genericBeanDefinition(SocketOptionsConfig.class);
ParsingUtils.setPropertyValue(defBuilder, element, "connect-timeout-mls", "connectTimeoutMls");
ParsingUtils.setPropertyValue(defBuilder, element, "keep-alive", "keepAlive");
ParsingUtils.setPropertyValue(defBuilder, element, "reuse-address", "reuseAddress");
ParsingUtils.setPropertyValue(defBuilder, element, "so-linger", "soLinger");
ParsingUtils.setPropertyValue(defBuilder, element, "tcp-no-delay", "tcpNoDelay");
ParsingUtils.setPropertyValue(defBuilder, element, "receive-buffer-size", "receiveBufferSize");
ParsingUtils.setPropertyValue(defBuilder, element, "send-buffer-size", "sendBufferSize");
return defBuilder.getBeanDefinition();
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(SocketOptionsConfig.class);
ParsingUtils.setPropertyValue(builder, element, "connect-timeout-mls", "connectTimeoutMls");
ParsingUtils.setPropertyValue(builder, element, "keep-alive", "keepAlive");
ParsingUtils.setPropertyValue(builder, element, "reuse-address", "reuseAddress");
ParsingUtils.setPropertyValue(builder, element, "so-linger", "soLinger");
ParsingUtils.setPropertyValue(builder, element, "tcp-no-delay", "tcpNoDelay");
ParsingUtils.setPropertyValue(builder, element, "receive-buffer-size", "receiveBufferSize");
ParsingUtils.setPropertyValue(builder, element, "send-buffer-size", "sendBufferSize");
return builder.getBeanDefinition();
}
}

17
spring-cassandra/src/main/java/org/springframework/cassandra/core/CqlProvider.java → spring-cassandra/src/main/java/org/springframework/cassandra/config/xml/CassandraNamespaceHandler.java
View File

@@ -13,14 +13,23 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.cassandra.core;
package org.springframework.cassandra.config.xml;
import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
/**
* @author David Webb
* Namespace handler for &lt;cassandra&gt; elements.
*
* @author Alex Shvid
* @author Matthew T. Adams
*/
public interface CqlProvider {
String getCql();
public class CassandraNamespaceHandler extends NamespaceHandlerSupport {
public void init() {
registerBeanDefinitionParser("cluster", new CassandraClusterParser());
registerBeanDefinitionParser("session", new CassandraSessionParser());
registerBeanDefinitionParser("template", new CassandraTemplateParser());
}
}

29
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraSessionParser.java → spring-cassandra/src/main/java/org/springframework/cassandra/config/xml/CassandraSessionParser.java
View File

@@ -13,28 +13,29 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.cassandra.config;
package org.springframework.cassandra.config.xml;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.cassandra.core.SessionFactoryBean;
import org.springframework.cassandra.config.CassandraSessionFactoryBean;
import org.springframework.util.StringUtils;
import org.w3c.dom.Element;
/**
* Parser for &lt;session;gt; definitions.
* Parser for &lt;session&gt; definitions.
*
* @author David Webb
* @author Matthew T. Adams
*/
public class CassandraSessionParser extends AbstractSimpleBeanDefinitionParser {
@Override
protected Class<?> getBeanClass(Element element) {
return SessionFactoryBean.class;
return CassandraSessionFactoryBean.class;
}
/*
@@ -52,18 +53,16 @@ public class CassandraSessionParser extends AbstractSimpleBeanDefinitionParser {
@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
String keyspaceRef = element.getAttribute("cassandra-keyspace-ref");
if (!StringUtils.hasText(keyspaceRef)) {
keyspaceRef = BeanNames.CASSANDRA_KEYSPACE;
String keyspaceName = element.getAttribute("keyspace-name");
if (!StringUtils.hasText(keyspaceName)) {
keyspaceName = null;
}
builder.addPropertyReference("keyspace", keyspaceRef);
builder.addPropertyValue("keyspaceName", keyspaceName);
postProcess(builder, element);
String clusterRef = element.getAttribute("cluster-ref");
if (!StringUtils.hasText(clusterRef)) {
clusterRef = BeanNames.CASSANDRA_CLUSTER;
}
builder.addPropertyReference("cluster", clusterRef);
}
@Override
protected void postProcess(BeanDefinitionBuilder builder, Element element) {
}
}

58
spring-cassandra/src/main/java/org/springframework/cassandra/config/xml/CassandraTemplateParser.java Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2011-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.cassandra.config.xml;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.cassandra.config.CassandraTemplateFactoryBean;
import org.springframework.util.StringUtils;
import org.w3c.dom.Element;
/**
* Parser for &lt;template&gt; definitions.
*
* @author David Webb
* @author Matthew T. Adams
*/
public class CassandraTemplateParser extends AbstractSimpleBeanDefinitionParser {
@Override
protected Class<?> getBeanClass(Element element) {
return CassandraTemplateFactoryBean.class;
}
@Override
protected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext)
throws BeanDefinitionStoreException {
String id = super.resolveId(element, definition, parserContext);
return StringUtils.hasText(id) ? id : BeanNames.CASSANDRA_TEMPLATE;
}
@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
String sessionRef = element.getAttribute("session-ref");
if (!StringUtils.hasText(sessionRef)) {
sessionRef = BeanNames.CASSANDRA_SESSION;
}
builder.addPropertyReference("session", sessionRef);
}
}

33
spring-cassandra/src/main/java/org/springframework/cassandra/config/xml/ParsingUtils.java Normal file
View File

@@ -0,0 +1,33 @@
package org.springframework.cassandra.config.xml;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import org.w3c.dom.Element;
public class ParsingUtils {
/**
* Configures a property value for the given property name reading the attribute of the given name from the given
* {@link Element} if the attribute is configured.
*
* @param builder must not be {@literal null}.
* @param element must not be {@literal null}.
* @param attrName must not be {@literal null} or empty.
* @param propertyName must not be {@literal null} or empty.
*/
public static void setPropertyValue(BeanDefinitionBuilder builder, Element element, String attrName,
String propertyName) {
Assert.notNull(builder, "BeanDefinitionBuilder must not be null!");
Assert.notNull(element, "Element must not be null!");
Assert.hasText(attrName, "Attribute name must not be null!");
Assert.hasText(propertyName, "Property name must not be null!");
String attr = element.getAttribute(attrName);
if (StringUtils.hasText(attr)) {
builder.addPropertyValue(propertyName, attr);
}
}
}

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

@@ -66,19 +66,6 @@ public interface CassandraOperations {
*/
<T> T query(final String cql, ResultSetExtractor<T> rse) throws DataAccessException;
/**
* Executes the provided CQL Query, and extracts the results with the ResultSetExtractor.
*
* @param cql The Query
* @param rse The implementation for extracting the ResultSet
* @param optionsByName Query Options Map
*
* @return
* @throws DataAccessException
*/
<T> T query(final String cql, ResultSetExtractor<T> rse, final Map<String, Object> optionsByName)
throws DataAccessException;
/**
* Executes the provided CQL Query, and extracts the results with the ResultSetExtractor.
*
@@ -101,18 +88,6 @@ public interface CassandraOperations {
*/
<T> T queryAsynchronously(final String cql, ResultSetFutureExtractor<T> rse) throws DataAccessException;
/**
* Executes the provided CQL Query asynchronously, and extracts the results with the ResultSetFutureExtractor
*
* @param cql The Query
* @param rse The implementation for extracting the future results
* @param optionsByName Query Options Map
* @return
* @throws DataAccessException
*/
<T> T queryAsynchronously(final String cql, ResultSetFutureExtractor<T> rse, final Map<String, Object> optionsByName)
throws DataAccessException;
/**
* Executes the provided CQL Query asynchronously, and extracts the results with the ResultSetFutureExtractor
*
@@ -134,17 +109,6 @@ public interface CassandraOperations {
*/
void query(final String cql, RowCallbackHandler rch) throws DataAccessException;
/**
* Executes the provided CQL Query, and then processes the results with the <code>RowCallbackHandler</code>.
*
* @param cql The Query
* @param rch The implementation for processing the rows returned.
* @param options Query Options Map
* @throws DataAccessException
*/
void query(final String cql, RowCallbackHandler rch, final Map<String, Object> optionsByName)
throws DataAccessException;
/**
* Executes the provided CQL Query, and then processes the results with the <code>RowCallbackHandler</code>.
*
@@ -176,18 +140,6 @@ public interface CassandraOperations {
*/
<T> List<T> query(final String cql, RowMapper<T> rowMapper) throws DataAccessException;
/**
* Executes the provided CQL Query, and maps all Rows returned with the supplied RowMapper.
*
* @param cql The Query
* @param rowMapper The implementation for mapping all rows
* @param optionsByName Query Options Map
* @return List of <T> processed by the RowMapper
* @throws DataAccessException
*/
<T> List<T> query(final String cql, RowMapper<T> rowMapper, final Map<String, Object> optionsByName)
throws DataAccessException;
/**
* Executes the provided CQL Query, and maps all Rows returned with the supplied RowMapper.
*
@@ -363,9 +315,6 @@ public interface CassandraOperations {
*/
<T> T query(final String cql, PreparedStatementBinder psb, ResultSetExtractor<T> rse) throws DataAccessException;
<T> T query(final String cql, PreparedStatementBinder psb, ResultSetExtractor<T> rse,
final Map<String, Object> optionsByName) throws DataAccessException;
<T> T query(final String cql, PreparedStatementBinder psb, ResultSetExtractor<T> rse, final QueryOptions options)
throws DataAccessException;
@@ -381,20 +330,6 @@ public interface CassandraOperations {
*/
void query(final String cql, PreparedStatementBinder psb, RowCallbackHandler rch) throws DataAccessException;
/**
* Converts the CQL provided into a {@link SimplePreparedStatementCreator}. Then, the PreparedStatementBinder will
* bind its values to the bind variables in the provided CQL String. The results of the PreparedStatement are
* processed with the RowCallbackHandler implementation provided and nothing is returned.
*
* @param cql The Query to Prepare
* @param psb The Binding implementation
* @param rch The RowCallbackHandler for processing the ResultSet
* @param optionsByName The Query Options Map
* @throws DataAccessException
*/
void query(final String cql, PreparedStatementBinder psb, RowCallbackHandler rch,
final Map<String, Object> optionsByName) throws DataAccessException;
/**
* Converts the CQL provided into a {@link SimplePreparedStatementCreator}. Then, the PreparedStatementBinder will
* bind its values to the bind variables in the provided CQL String. The results of the PreparedStatement are
@@ -423,22 +358,6 @@ public interface CassandraOperations {
*/
<T> List<T> query(final String cql, PreparedStatementBinder psb, RowMapper<T> rowMapper) throws DataAccessException;
/**
* Converts the CQL provided into a {@link SimplePreparedStatementCreator}. Then, the PreparedStatementBinder will
* bind its values to the bind variables in the provided CQL String. The results of the PreparedStatement are
* processed with the RowMapper implementation provided and a List is returned with elements of Type <T> for each Row
* returned.
*
* @param cql The Query to Prepare
* @param psb The Binding implementation
* @param rowMapper The implementation for Mapping a Row to Type <T>
* @param optionsByName The Query Options Map
* @return List of <T> for each Row returned from the Query.
* @throws DataAccessException
*/
<T> List<T> query(final String cql, PreparedStatementBinder psb, RowMapper<T> rowMapper,
final Map<String, Object> optionsByName) throws DataAccessException;
/**
* Converts the CQL provided into a {@link SimplePreparedStatementCreator}. Then, the PreparedStatementBinder will
* bind its values to the bind variables in the provided CQL String. The results of the PreparedStatement are
@@ -467,20 +386,6 @@ public interface CassandraOperations {
*/
<T> T query(PreparedStatementCreator psc, ResultSetExtractor<T> rse) throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. <b>This can only be used for CQL
* Statements that do not have data binding.</b> The results of the PreparedStatement are processed with
* ResultSetExtractor implementation provided by the Application Code.
*
* @param psc The implementation to create the PreparedStatement
* @param rse Implementation for extracting from the ResultSet
* @param optionsByName The Query Options Map
* @return Type <T> which is the output of the ResultSetExtractor
* @throws DataAccessException
*/
<T> T query(PreparedStatementCreator psc, ResultSetExtractor<T> rse, final Map<String, Object> optionsByName)
throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. <b>This can only be used for CQL
* Statements that do not have data binding.</b> The results of the PreparedStatement are processed with
@@ -506,19 +411,6 @@ public interface CassandraOperations {
*/
void query(PreparedStatementCreator psc, RowCallbackHandler rch) throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. <b>This can only be used for CQL
* Statements that do not have data binding.</b> The results of the PreparedStatement are processed with
* RowCallbackHandler and nothing is returned.
*
* @param psc The implementation to create the PreparedStatement
* @param rch The implementation to process Results
* @param optionsByName The Query Options Map
* @throws DataAccessException
*/
void query(PreparedStatementCreator psc, RowCallbackHandler rch, final Map<String, Object> optionsByName)
throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. <b>This can only be used for CQL
* Statements that do not have data binding.</b> The results of the PreparedStatement are processed with
@@ -544,20 +436,6 @@ public interface CassandraOperations {
*/
<T> List<T> query(PreparedStatementCreator psc, RowMapper<T> rowMapper) throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. <b>This can only be used for CQL
* Statements that do not have data binding.</b> The results of the PreparedStatement are processed with RowMapper
* implementation provided and a List is returned with elements of Type <T> for each Row returned.
*
* @param psc The implementation to create the PreparedStatement
* @param rowMapper The implementation for mapping each Row returned.
* @param optionsByName The Query Options Map
* @return List of Type <T> mapped from each Row in the Results
* @throws DataAccessException
*/
<T> List<T> query(PreparedStatementCreator psc, RowMapper<T> rowMapper, final Map<String, Object> optionsByName)
throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. <b>This can only be used for CQL
* Statements that do not have data binding.</b> The results of the PreparedStatement are processed with RowMapper
@@ -572,21 +450,6 @@ public interface CassandraOperations {
<T> List<T> query(PreparedStatementCreator psc, RowMapper<T> rowMapper, final QueryOptions options)
throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. Binds the values from the
* PreparedStatementBinder to the available bind variables. The results of the PreparedStatement are processed with
* ResultSetExtractor implementation provided by the Application Code.
*
* @param psc The implementation to create the PreparedStatement
* @param psb The implementation to bind variables to values
* @param rse Implementation for extracting from the ResultSet
* @param optionsByName The Query Options Map
* @return Type <T> which is the output of the ResultSetExtractor
* @throws DataAccessException
*/
<T> T query(PreparedStatementCreator psc, final PreparedStatementBinder psb, final ResultSetExtractor<T> rse,
final Map<String, Object> optionsByName) throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. Binds the values from the
* PreparedStatementBinder to the available bind variables. The results of the PreparedStatement are processed with
@@ -616,21 +479,6 @@ public interface CassandraOperations {
<T> T query(PreparedStatementCreator psc, final PreparedStatementBinder psb, final ResultSetExtractor<T> rse)
throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. Binds the values from the
* PreparedStatementBinder to the available bind variables. The results of the PreparedStatement are processed with
* RowCallbackHandler and nothing is returned.
*
* @param psc The implementation to create the PreparedStatement
* @param psb The implementation to bind variables to values
* @param rch The implementation to process Results
* @param optionsByName The Query Options Map
* @return Type <T> which is the output of the ResultSetExtractor
* @throws DataAccessException
*/
void query(PreparedStatementCreator psc, final PreparedStatementBinder psb, final RowCallbackHandler rch,
final Map<String, Object> optionsByName) throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. Binds the values from the
* PreparedStatementBinder to the available bind variables. The results of the PreparedStatement are processed with
@@ -660,21 +508,6 @@ public interface CassandraOperations {
void query(PreparedStatementCreator psc, final PreparedStatementBinder psb, final RowCallbackHandler rch)
throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. Binds the values from the
* PreparedStatementBinder to the available bind variables. The results of the PreparedStatement are processed with
* RowMapper implementation provided and a List is returned with elements of Type <T> for each Row returned.
*
* @param psc The implementation to create the PreparedStatement
* @param psb The implementation to bind variables to values
* @param rowMapper The implementation for mapping each Row returned.
* @param optionsByName The Query Options Map
* @return Type <T> which is the output of the ResultSetExtractor
* @throws DataAccessException
*/
<T> List<T> query(PreparedStatementCreator psc, final PreparedStatementBinder psb, final RowMapper<T> rowMapper,
final Map<String, Object> optionsByName) throws DataAccessException;
/**
* Uses the provided PreparedStatementCreator to prepare a new Session call. Binds the values from the
* PreparedStatementBinder to the available bind variables. The results of the PreparedStatement are processed with
@@ -729,21 +562,6 @@ public interface CassandraOperations {
*/
Session getSession();
/**
* This is an operation designed for high performance writes. The cql is used to create a PreparedStatement once, then
* all row values are bound to the single PreparedStatement and executed against the Session.
*
* <p>
* This is used internally by the other ingest() methods, but can be used if you want to write your own RowIterator.
* The Object[] length returned by the next() implementation must match the number of bind variables in the CQL.
* </p>
*
* @param cql The CQL
* @param rowIterator Implementation to provide the Object[] to be bound to the CQL.
* @param optionsByName The Query Options Map
*/
void ingest(String cql, RowIterator rowIterator, Map<String, Object> optionsByName);
/**
* This is an operation designed for high performance writes. The cql is used to create a PreparedStatement once, then
* all row values are bound to the single PreparedStatement and executed against the Session.
@@ -773,20 +591,6 @@ public interface CassandraOperations {
*/
void ingest(String cql, RowIterator rowIterator);
/**
* This is an operation designed for high performance writes. The cql is used to create a PreparedStatement once, then
* all row values are bound to the single PreparedStatement and executed against the Session.
*
* <p>
* The List<?> length must match the number of bind variables in the CQL.
* </p>
*
* @param cql The CQL
* @param rows List of List<?> with data to bind to the CQL.
* @param optionsByName The Query Options Map
*/
void ingest(String cql, List<List<?>> rows, Map<String, Object> optionsByName);
/**
* This is an operation designed for high performance writes. The cql is used to create a PreparedStatement once, then
* all row values are bound to the single PreparedStatement and executed against the Session.
@@ -814,20 +618,6 @@ public interface CassandraOperations {
*/
void ingest(String cql, List<List<?>> rows);
/**
* This is an operation designed for high performance writes. The cql is used to create a PreparedStatement once, then
* all row values are bound to the single PreparedStatement and executed against the Session.
*
* <p>
* The Object[] length of the nested array must match the number of bind variables in the CQL.
* </p>
*
* @param cql The CQL
* @param rows Object array of Object array of values to bind to the CQL.
* @param optionsByName The Query Options Map
*/
void ingest(String cql, Object[][] rows, Map<String, Object> optionsByName);
/**
* This is an operation designed for high performance writes. The cql is used to create a PreparedStatement once, then
* all row values are bound to the single PreparedStatement and executed against the Session.

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

@@ -17,8 +17,8 @@ package org.springframework.cassandra.core;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -30,7 +30,6 @@ import org.springframework.util.Assert;
import com.datastax.driver.core.BoundStatement;
import com.datastax.driver.core.ColumnDefinitions;
import com.datastax.driver.core.ColumnDefinitions.Definition;
import com.datastax.driver.core.DataType;
import com.datastax.driver.core.Host;
import com.datastax.driver.core.Metadata;
import com.datastax.driver.core.PreparedStatement;
@@ -91,33 +90,23 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public void execute(final String cql) throws DataAccessException {
doExecute(cql, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#queryAsynchronously(java.lang.String, org.springframework.cassandra.core.ResultSetFutureExtractor, java.util.Map)
*/
@Override
public <T> T queryAsynchronously(final String cql, ResultSetFutureExtractor<T> rse,
final Map<String, Object> optionsByName) throws DataAccessException {
return rse.extractData(execute(new SessionCallback<ResultSetFuture>() {
@Override
public ResultSetFuture doInSession(Session s) throws DataAccessException {
Statement statement = new SimpleStatement(cql);
addQueryOptions(statement, optionsByName);
return s.executeAsync(statement);
}
}));
doExecute(cql, null);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#queryAsynchronously(java.lang.String, org.springframework.cassandra.core.ResultSetFutureExtractor, org.springframework.cassandra.core.QueryOptions)
*/
@Override
public <T> T queryAsynchronously(String cql, ResultSetFutureExtractor<T> rse, QueryOptions options)
public <T> T queryAsynchronously(final String cql, ResultSetFutureExtractor<T> rse, final QueryOptions options)
throws DataAccessException {
Assert.notNull(options);
return queryAsynchronously(cql, rse, options.toMap());
return rse.extractData(execute(new SessionCallback<ResultSetFuture>() {
@Override
public ResultSetFuture doInSession(Session s) throws DataAccessException {
Statement statement = new SimpleStatement(cql);
addQueryOptions(statement, options);
return s.executeAsync(statement);
}
}));
}
/* (non-Javadoc)
@@ -125,18 +114,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public <T> T queryAsynchronously(final String cql, ResultSetFutureExtractor<T> rse) throws DataAccessException {
return queryAsynchronously(cql, rse, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(java.lang.String, org.springframework.cassandra.core.ResultSetExtractor)
*/
public <T> T query(String cql, ResultSetExtractor<T> rse, Map<String, Object> optionsByName)
throws DataAccessException {
Assert.notNull(cql);
Assert.notNull(optionsByName);
ResultSet rs = doExecute(cql, optionsByName);
return rse.extractData(rs);
return queryAsynchronously(cql, rse, null);
}
/* (non-Javadoc)
@@ -144,7 +122,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public <T> T query(String cql, ResultSetExtractor<T> rse) throws DataAccessException {
return query(cql, rse, Collections.<String, Object> emptyMap());
return query(cql, rse, null);
}
/* (non-Javadoc)
@@ -152,16 +130,9 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public <T> T query(String cql, ResultSetExtractor<T> rse, QueryOptions options) throws DataAccessException {
Assert.notNull(options);
return query(cql, rse, options.toMap());
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(java.lang.String, org.springframework.cassandra.core.RowCallbackHandler, java.util.Map)
*/
@Override
public void query(String cql, RowCallbackHandler rch, Map<String, Object> optionsByName) throws DataAccessException {
process(doExecute(cql, optionsByName), rch);
Assert.notNull(cql);
ResultSet rs = doExecute(cql, options);
return rse.extractData(rs);
}
/* (non-Javadoc)
@@ -169,25 +140,14 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public void query(String cql, RowCallbackHandler rch, QueryOptions options) throws DataAccessException {
Assert.notNull(options);
query(cql, rch, options.toMap());
process(doExecute(cql, options), rch);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(java.lang.String, org.springframework.cassandra.core.RowCallbackHandler)
*/
public void query(String cql, RowCallbackHandler rch) throws DataAccessException {
query(cql, rch, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(java.lang.String, org.springframework.cassandra.core.RowMapper, java.util.Map)
*/
@Override
public <T> List<T> query(String cql, RowMapper<T> rowMapper, Map<String, Object> optionsByName)
throws DataAccessException {
Assert.notNull(optionsByName);
return process(doExecute(cql, optionsByName), rowMapper);
query(cql, rch, null);
}
/* (non-Javadoc)
@@ -195,50 +155,49 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public <T> List<T> query(String cql, RowMapper<T> rowMapper, QueryOptions options) throws DataAccessException {
Assert.notNull(options);
return query(cql, rowMapper, options.toMap());
return process(doExecute(cql, options), rowMapper);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(java.lang.String, org.springframework.cassandra.core.RowMapper)
*/
public <T> List<T> query(String cql, RowMapper<T> rowMapper) throws DataAccessException {
return query(cql, rowMapper, Collections.<String, Object> emptyMap());
return query(cql, rowMapper, null);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#queryForList(java.lang.String)
*/
public List<Map<String, Object>> queryForListOfMap(String cql) throws DataAccessException {
return processListOfMap(doExecute(cql, Collections.<String, Object> emptyMap()));
return processListOfMap(doExecute(cql, null));
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#queryForList(java.lang.String, java.lang.Class)
*/
public <T> List<T> queryForList(String cql, Class<T> elementType) throws DataAccessException {
return processList(doExecute(cql, Collections.<String, Object> emptyMap()), elementType);
return processList(doExecute(cql, null), elementType);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#queryForMap(java.lang.String)
*/
public Map<String, Object> queryForMap(String cql) throws DataAccessException {
return processMap(doExecute(cql, Collections.<String, Object> emptyMap()));
return processMap(doExecute(cql, null));
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#queryForObject(java.lang.String, java.lang.Class)
*/
public <T> T queryForObject(String cql, Class<T> requiredType) throws DataAccessException {
return processOne(doExecute(cql, Collections.<String, Object> emptyMap()), requiredType);
return processOne(doExecute(cql, null), requiredType);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#queryForObject(java.lang.String, org.springframework.cassandra.core.RowMapper)
*/
public <T> T queryForObject(String cql, RowMapper<T> rowMapper) throws DataAccessException {
return processOne(doExecute(cql, Collections.<String, Object> emptyMap()), rowMapper);
return processOne(doExecute(cql, null), rowMapper);
}
/**
@@ -266,7 +225,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
* @param callback
* @return
*/
protected ResultSet doExecute(final String cql, final Map<String, Object> optionsByName) {
protected ResultSet doExecute(final String cql, final QueryOptions options) {
logger.info(cql);
@@ -275,7 +234,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
@Override
public ResultSet doInSession(Session s) throws DataAccessException {
SimpleStatement statement = new SimpleStatement(cql);
addQueryOptions(statement, optionsByName);
addQueryOptions(statement, options);
return s.execute(statement);
}
});
@@ -287,13 +246,13 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
* @param callback
* @return
*/
protected ResultSet doExecute(final BoundStatement bs, final Map<String, Object> optionsByName) {
protected ResultSet doExecute(final BoundStatement bs, final QueryOptions options) {
return doExecute(new SessionCallback<ResultSet>() {
@Override
public ResultSet doInSession(Session s) throws DataAccessException {
addQueryOptions(bs, optionsByName);
addQueryOptions(bs, options);
return s.execute(bs);
}
});
@@ -325,7 +284,6 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
for (Definition def : cols.asList()) {
String name = def.getName();
DataType dataType = def.getType();
map.put(name, def.getType().deserialize(row.getBytesUnsafe(name)));
}
@@ -527,24 +485,13 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
return execute(new SimplePreparedStatementCreator(cql), action);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(org.springframework.cassandra.core.PreparedStatementCreator, org.springframework.cassandra.core.ResultSetExtractor, java.util.Map)
*/
@Override
public <T> T query(PreparedStatementCreator psc, ResultSetExtractor<T> rse, Map<String, Object> optionsByName)
throws DataAccessException {
Assert.notNull(optionsByName);
return query(psc, null, rse, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(org.springframework.cassandra.core.PreparedStatementCreator, org.springframework.cassandra.core.ResultSetExtractor, org.springframework.cassandra.core.QueryOptions)
*/
@Override
public <T> T query(PreparedStatementCreator psc, ResultSetExtractor<T> rse, QueryOptions options)
throws DataAccessException {
Assert.notNull(options);
return query(psc, rse, options.toMap());
return query(psc, null, rse, options);
}
/* (non-Javadoc)
@@ -552,17 +499,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public <T> T query(PreparedStatementCreator psc, ResultSetExtractor<T> rse) throws DataAccessException {
return query(psc, rse, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(org.springframework.cassandra.core.PreparedStatementCreator, org.springframework.cassandra.core.RowCallbackHandler, java.util.Map)
*/
@Override
public void query(PreparedStatementCreator psc, RowCallbackHandler rch, Map<String, Object> optionsByName)
throws DataAccessException {
Assert.notNull(optionsByName);
query(psc, null, rch, optionsByName);
return query(psc, rse, null);
}
/* (non-Javadoc)
@@ -571,8 +508,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
@Override
public void query(PreparedStatementCreator psc, RowCallbackHandler rch, QueryOptions options)
throws DataAccessException {
Assert.notNull(options);
query(psc, rch, options.toMap());
query(psc, null, rch, options);
}
/* (non-Javadoc)
@@ -580,17 +516,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public void query(PreparedStatementCreator psc, RowCallbackHandler rch) throws DataAccessException {
query(psc, rch, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(org.springframework.cassandra.core.PreparedStatementCreator, org.springframework.cassandra.core.RowMapper, java.util.Map)
*/
@Override
public <T> List<T> query(PreparedStatementCreator psc, RowMapper<T> rowMapper, Map<String, Object> optionsByName)
throws DataAccessException {
Assert.notNull(optionsByName);
return query(psc, null, rowMapper, optionsByName);
query(psc, rch, null);
}
/* (non-Javadoc)
@@ -599,8 +525,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
@Override
public <T> List<T> query(PreparedStatementCreator psc, RowMapper<T> rowMapper, QueryOptions options)
throws DataAccessException {
Assert.notNull(options);
return query(psc, rowMapper, options.toMap());
return query(psc, null, rowMapper, options);
}
/* (non-Javadoc)
@@ -608,41 +533,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public <T> List<T> query(PreparedStatementCreator psc, RowMapper<T> rowMapper) throws DataAccessException {
return query(psc, rowMapper, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(org.springframework.cassandra.core.PreparedStatementCreator, org.springframework.cassandra.core.PreparedStatementSetter, org.springframework.cassandra.core.ResultSetExtractor)
*/
public <T> T query(PreparedStatementCreator psc, final PreparedStatementBinder psb, final ResultSetExtractor<T> rse,
final Map<String, Object> optionsByName) throws DataAccessException {
Assert.notNull(rse, "ResultSetExtractor must not be null");
logger.debug("Executing prepared CQL query");
return execute(psc, new PreparedStatementCallback<T>() {
public T doInPreparedStatement(PreparedStatement ps) throws DriverException {
ResultSet rs = null;
BoundStatement bs = null;
if (psb != null) {
bs = psb.bindValues(ps);
} else {
bs = ps.bind();
}
rs = doExecute(bs, optionsByName);
return rse.extractData(rs);
}
});
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(java.lang.String, org.springframework.cassandra.core.PreparedStatementBinder, org.springframework.cassandra.core.ResultSetExtractor, java.util.Map)
*/
@Override
public <T> T query(String cql, PreparedStatementBinder psb, ResultSetExtractor<T> rse,
Map<String, Object> optionsByName) throws DataAccessException {
Assert.notNull(optionsByName);
return query(new SimplePreparedStatementCreator(cql), psb, rse, optionsByName);
return query(psc, rowMapper, null);
}
/* (non-Javadoc)
@@ -651,8 +542,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
@Override
public <T> T query(String cql, PreparedStatementBinder psb, ResultSetExtractor<T> rse, QueryOptions options)
throws DataAccessException {
Assert.notNull(options);
return query(cql, psb, rse, options.toMap());
return query(new SimplePreparedStatementCreator(cql), psb, rse, options);
}
/* (non-Javadoc)
@@ -660,17 +550,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public <T> T query(String cql, PreparedStatementBinder psb, ResultSetExtractor<T> rse) throws DataAccessException {
return query(cql, psb, rse, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(java.lang.String, org.springframework.cassandra.core.PreparedStatementBinder, org.springframework.cassandra.core.RowCallbackHandler, java.util.Map)
*/
@Override
public void query(String cql, PreparedStatementBinder psb, RowCallbackHandler rch, Map<String, Object> optionsByName)
throws DataAccessException {
Assert.notNull(optionsByName);
query(new SimplePreparedStatementCreator(cql), psb, rch, optionsByName);
return query(cql, psb, rse, null);
}
/* (non-Javadoc)
@@ -679,8 +559,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
@Override
public void query(String cql, PreparedStatementBinder psb, RowCallbackHandler rch, QueryOptions options)
throws DataAccessException {
Assert.notNull(options);
query(cql, psb, rch, options.toMap());
query(new SimplePreparedStatementCreator(cql), psb, rch, options);
}
/* (non-Javadoc)
@@ -688,17 +567,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public void query(String cql, PreparedStatementBinder psb, RowCallbackHandler rch) throws DataAccessException {
query(cql, psb, rch, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(java.lang.String, org.springframework.cassandra.core.PreparedStatementBinder, org.springframework.cassandra.core.RowMapper, java.util.Map)
*/
@Override
public <T> List<T> query(String cql, PreparedStatementBinder psb, RowMapper<T> rowMapper,
Map<String, Object> optionsByName) throws DataAccessException {
Assert.notNull(optionsByName);
return query(new SimplePreparedStatementCreator(cql), psb, rowMapper, optionsByName);
query(cql, psb, rch, null);
}
/* (non-Javadoc)
@@ -707,8 +576,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
@Override
public <T> List<T> query(String cql, PreparedStatementBinder psb, RowMapper<T> rowMapper, QueryOptions options)
throws DataAccessException {
Assert.notNull(options);
return query(cql, psb, rowMapper, options.toMap());
return query(new SimplePreparedStatementCreator(cql), psb, rowMapper, options);
}
/* (non-Javadoc)
@@ -716,72 +584,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public <T> List<T> query(String cql, PreparedStatementBinder psb, RowMapper<T> rowMapper) throws DataAccessException {
return query(cql, psb, rowMapper, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(org.springframework.cassandra.core.PreparedStatementCreator, org.springframework.cassandra.core.PreparedStatementBinder, org.springframework.cassandra.core.RowCallbackHandler)
*/
@Override
public void query(PreparedStatementCreator psc, final PreparedStatementBinder psb, final RowCallbackHandler rch,
final Map<String, Object> optionsByName) throws DataAccessException {
Assert.notNull(rch, "RowCallbackHandler must not be null");
logger.debug("Executing prepared CQL query");
execute(psc, new PreparedStatementCallback<Object>() {
public Object doInPreparedStatement(PreparedStatement ps) throws DriverException {
ResultSet rs = null;
BoundStatement bs = null;
if (psb != null) {
bs = psb.bindValues(ps);
} else {
bs = ps.bind();
}
rs = doExecute(bs, optionsByName);
process(rs, rch);
return null;
}
});
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(org.springframework.cassandra.core.PreparedStatementCreator, org.springframework.cassandra.core.PreparedStatementBinder, org.springframework.cassandra.core.RowMapper)
*/
@Override
public <T> List<T> query(PreparedStatementCreator psc, final PreparedStatementBinder psb,
final RowMapper<T> rowMapper, final Map<String, Object> optionsByName) throws DataAccessException {
Assert.notNull(rowMapper, "RowMapper must not be null");
logger.debug("Executing prepared CQL query");
return execute(psc, new PreparedStatementCallback<List<T>>() {
public List<T> doInPreparedStatement(PreparedStatement ps) throws DriverException {
ResultSet rs = null;
BoundStatement bs = null;
if (psb != null) {
bs = psb.bindValues(ps);
} else {
bs = ps.bind();
}
rs = doExecute(bs, optionsByName);
return process(rs, rowMapper);
}
});
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#execute(java.lang.String, org.springframework.cassandra.core.RowProvider, int)
*/
@Override
public void ingest(String cql, RowIterator rowIterator, Map<String, Object> optionsByName) {
PreparedStatement preparedStatement = getSession().prepare(cql);
addPreparedStatementOptions(preparedStatement, optionsByName);
while (rowIterator.hasNext()) {
getSession().execute(preparedStatement.bind(rowIterator.next()));
}
return query(cql, psb, rowMapper, null);
}
/* (non-Javadoc)
@@ -789,8 +592,13 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public void ingest(String cql, RowIterator rowIterator, QueryOptions options) {
Assert.notNull(options);
ingest(cql, rowIterator, options.toMap());
PreparedStatement preparedStatement = getSession().prepare(cql);
addPreparedStatementOptions(preparedStatement, options);
while (rowIterator.hasNext()) {
getSession().execute(preparedStatement.bind(rowIterator.next()));
}
}
/* (non-Javadoc)
@@ -798,36 +606,34 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public void ingest(String cql, RowIterator rowIterator) {
ingest(cql, rowIterator, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#execute(java.lang.String, java.util.List)
*/
@Override
public void ingest(String cql, List<List<?>> rows, Map<String, Object> optionsByName) {
Assert.notNull(optionsByName);
Assert.notNull(rows);
Assert.notEmpty(rows);
Object[][] values = new Object[rows.size()][];
int i = 0;
for (List<?> row : rows) {
values[i++] = row.toArray();
}
ingest(cql, values, optionsByName);
ingest(cql, rowIterator, null);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#ingest(java.lang.String, java.util.List, org.springframework.cassandra.core.QueryOptions)
*/
@Override
public void ingest(String cql, List<List<?>> rows, QueryOptions options) {
Assert.notNull(options);
ingest(cql, rows, options.toMap());
public void ingest(String cql, final List<List<?>> rows, QueryOptions options) {
Assert.notNull(rows);
Assert.notEmpty(rows);
ingest(cql, new RowIterator() {
Iterator<List<?>> i = rows.iterator();
@Override
public Object[] next() {
return i.next().toArray();
}
@Override
public boolean hasNext() {
return i.hasNext();
}
}, options);
}
/* (non-Javadoc)
@@ -835,16 +641,14 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public void ingest(String cql, List<List<?>> rows) {
ingest(cql, rows, Collections.<String, Object> emptyMap());
ingest(cql, rows, null);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#execute(java.lang.String, java.lang.Object[][])
* @see org.springframework.cassandra.core.CassandraOperations#ingest(java.lang.String, java.lang.Object[][], org.springframework.cassandra.core.QueryOptions)
*/
@Override
public void ingest(String cql, final Object[][] rows, final Map<String, Object> optionsByName) {
Assert.notNull(optionsByName);
public void ingest(String cql, final Object[][] rows, QueryOptions options) {
ingest(cql, new RowIterator() {
@@ -860,16 +664,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
return index < rows.length;
}
}, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#ingest(java.lang.String, java.lang.Object[][], org.springframework.cassandra.core.QueryOptions)
*/
@Override
public void ingest(String cql, final Object[][] rows, QueryOptions options) {
Assert.notNull(options);
ingest(cql, rows, options.toMap());
}, options);
}
/* (non-Javadoc)
@@ -877,7 +672,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
*/
@Override
public void ingest(String cql, final Object[][] rows) {
ingest(cql, rows, Collections.<String, Object> emptyMap());
ingest(cql, rows, null);
}
/* (non-Javadoc)
@@ -886,7 +681,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
@Override
public void truncate(String tableName) throws DataAccessException {
Truncate truncate = QueryBuilder.truncate(tableName);
doExecute(truncate.getQueryString(), Collections.<String, Object> emptyMap());
doExecute(truncate.getQueryString(), null);
}
/**
@@ -895,22 +690,20 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
* @param q
* @param optionsByName
*/
public static void addQueryOptions(Query q, Map<String, Object> optionsByName) {
public static void addQueryOptions(Query q, QueryOptions options) {
if (optionsByName == null) {
if (options == null) {
return;
}
/*
* Add Query Options
*/
if (optionsByName.get(QueryOptions.QueryOptionMapKeys.CONSISTENCY_LEVEL) != null) {
q.setConsistencyLevel(ConsistencyLevelResolver.resolve((ConsistencyLevel) optionsByName
.get(QueryOptions.QueryOptionMapKeys.CONSISTENCY_LEVEL)));
if (options.getConsistencyLevel() != null) {
q.setConsistencyLevel(ConsistencyLevelResolver.resolve(options.getConsistencyLevel()));
}
if (optionsByName.get(QueryOptions.QueryOptionMapKeys.RETRY_POLICY) != null) {
q.setRetryPolicy(RetryPolicyResolver.resolve((RetryPolicy) optionsByName
.get(QueryOptions.QueryOptionMapKeys.RETRY_POLICY)));
if (options.getRetryPolicy() != null) {
q.setRetryPolicy(RetryPolicyResolver.resolve(options.getRetryPolicy()));
}
}
@@ -921,22 +714,20 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
* @param q
* @param optionsByName
*/
public static void addPreparedStatementOptions(PreparedStatement s, Map<String, Object> optionsByName) {
public static void addPreparedStatementOptions(PreparedStatement s, QueryOptions options) {
if (optionsByName == null) {
if (options == null) {
return;
}
/*
* Add Query Options
*/
if (optionsByName.get(QueryOptions.QueryOptionMapKeys.CONSISTENCY_LEVEL) != null) {
s.setConsistencyLevel(ConsistencyLevelResolver.resolve((ConsistencyLevel) optionsByName
.get(QueryOptions.QueryOptionMapKeys.CONSISTENCY_LEVEL)));
if (options.getConsistencyLevel() != null) {
s.setConsistencyLevel(ConsistencyLevelResolver.resolve(options.getConsistencyLevel()));
}
if (optionsByName.get(QueryOptions.QueryOptionMapKeys.RETRY_POLICY) != null) {
s.setRetryPolicy(RetryPolicyResolver.resolve((RetryPolicy) optionsByName
.get(QueryOptions.QueryOptionMapKeys.RETRY_POLICY)));
if (options.getRetryPolicy() != null) {
s.setRetryPolicy(RetryPolicyResolver.resolve(options.getRetryPolicy()));
}
}
@@ -945,10 +736,25 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
* @see org.springframework.cassandra.core.CassandraOperations#query(org.springframework.cassandra.core.PreparedStatementCreator, org.springframework.cassandra.core.PreparedStatementBinder, org.springframework.cassandra.core.ResultSetExtractor, org.springframework.cassandra.core.QueryOptions)
*/
@Override
public <T> T query(PreparedStatementCreator psc, PreparedStatementBinder psb, ResultSetExtractor<T> rse,
QueryOptions options) throws DataAccessException {
Assert.notNull(options);
return query(psc, psb, rse, options.toMap());
public <T> T query(PreparedStatementCreator psc, final PreparedStatementBinder psb, final ResultSetExtractor<T> rse,
final QueryOptions options) throws DataAccessException {
Assert.notNull(rse, "ResultSetExtractor must not be null");
logger.debug("Executing prepared CQL query");
return execute(psc, new PreparedStatementCallback<T>() {
public T doInPreparedStatement(PreparedStatement ps) throws DriverException {
ResultSet rs = null;
BoundStatement bs = null;
if (psb != null) {
bs = psb.bindValues(ps);
} else {
bs = ps.bind();
}
rs = doExecute(bs, options);
return rse.extractData(rs);
}
});
}
/* (non-Javadoc)
@@ -957,17 +763,33 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
@Override
public <T> T query(PreparedStatementCreator psc, PreparedStatementBinder psb, ResultSetExtractor<T> rse)
throws DataAccessException {
return query(psc, psb, rse, Collections.<String, Object> emptyMap());
return query(psc, psb, rse, null);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(org.springframework.cassandra.core.PreparedStatementCreator, org.springframework.cassandra.core.PreparedStatementBinder, org.springframework.cassandra.core.RowCallbackHandler, org.springframework.cassandra.core.QueryOptions)
*/
@Override
public void query(PreparedStatementCreator psc, PreparedStatementBinder psb, RowCallbackHandler rch,
QueryOptions options) throws DataAccessException {
Assert.notNull(options);
query(psc, psb, rch, options.toMap());
public void query(PreparedStatementCreator psc, final PreparedStatementBinder psb, final RowCallbackHandler rch,
final QueryOptions options) throws DataAccessException {
Assert.notNull(rch, "RowCallbackHandler must not be null");
logger.debug("Executing prepared CQL query");
execute(psc, new PreparedStatementCallback<Object>() {
public Object doInPreparedStatement(PreparedStatement ps) throws DriverException {
ResultSet rs = null;
BoundStatement bs = null;
if (psb != null) {
bs = psb.bindValues(ps);
} else {
bs = ps.bind();
}
rs = doExecute(bs, options);
process(rs, rch);
return null;
}
});
}
/* (non-Javadoc)
@@ -976,17 +798,32 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
@Override
public void query(PreparedStatementCreator psc, PreparedStatementBinder psb, RowCallbackHandler rch)
throws DataAccessException {
query(psc, psb, rch, Collections.<String, Object> emptyMap());
query(psc, psb, rch, null);
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CassandraOperations#query(org.springframework.cassandra.core.PreparedStatementCreator, org.springframework.cassandra.core.PreparedStatementBinder, org.springframework.cassandra.core.RowMapper, org.springframework.cassandra.core.QueryOptions)
*/
@Override
public <T> List<T> query(PreparedStatementCreator psc, PreparedStatementBinder psb, RowMapper<T> rowMapper,
QueryOptions options) throws DataAccessException {
Assert.notNull(options);
return query(psc, psb, rowMapper, options.toMap());
public <T> List<T> query(PreparedStatementCreator psc, final PreparedStatementBinder psb,
final RowMapper<T> rowMapper, final QueryOptions options) throws DataAccessException {
Assert.notNull(rowMapper, "RowMapper must not be null");
logger.debug("Executing prepared CQL query");
return execute(psc, new PreparedStatementCallback<List<T>>() {
public List<T> doInPreparedStatement(PreparedStatement ps) throws DriverException {
ResultSet rs = null;
BoundStatement bs = null;
if (psb != null) {
bs = psb.bindValues(ps);
} else {
bs = ps.bind();
}
rs = doExecute(bs, options);
return process(rs, rowMapper);
}
});
}
/* (non-Javadoc)
@@ -995,7 +832,7 @@ public class CassandraTemplate extends CassandraAccessor implements CassandraOpe
@Override
public <T> List<T> query(PreparedStatementCreator psc, PreparedStatementBinder psb, RowMapper<T> rowMapper)
throws DataAccessException {
return query(psc, psb, rowMapper, Collections.<String, Object> emptyMap());
return query(psc, psb, rowMapper, null);
}
}

6
spring-cassandra/src/main/java/org/springframework/cassandra/core/PreparedStatementCreatorImpl.java
View File

@@ -26,7 +26,7 @@ import com.datastax.driver.core.exceptions.DriverException;
* @author David Webb
*
*/
public class PreparedStatementCreatorImpl implements PreparedStatementCreator, CqlProvider, PreparedStatementBinder {
public class PreparedStatementCreatorImpl implements PreparedStatementCreator, PreparedStatementBinder {
private final String cql;
private List<Object> values;
@@ -54,10 +54,6 @@ public class PreparedStatementCreatorImpl implements PreparedStatementCreator, C
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CqlProvider#getCql()
*/
@Override
public String getCql() {
return this.cql;
}

87
spring-cassandra/src/main/java/org/springframework/cassandra/core/SessionFactoryBean.java
View File

@@ -1,87 +0,0 @@
/*
* Copyright 2011-2013 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.cassandra.core;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.cassandra.core.Keyspace;
import com.datastax.driver.core.Session;
/**
* @author David Webb
*
*/
public class SessionFactoryBean implements FactoryBean<Session>, InitializingBean {
private Keyspace keyspace;
public SessionFactoryBean() {
}
public SessionFactoryBean(Keyspace keyspace) {
setKeyspace(keyspace);
}
/* (non-Javadoc)
* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
*/
@Override
public void afterPropertiesSet() throws Exception {
if (keyspace == null) {
throw new IllegalStateException("Keyspace required.");
}
}
/**
* @return Returns the keyspace.
*/
public Keyspace getKeyspace() {
return keyspace;
}
/**
* @param keyspace The keyspace to set.
*/
public void setKeyspace(Keyspace keyspace) {
this.keyspace = keyspace;
}
/* (non-Javadoc)
* @see org.springframework.beans.factory.FactoryBean#getObject()
*/
@Override
public Session getObject() {
return keyspace.getSession();
}
/* (non-Javadoc)
* @see org.springframework.beans.factory.FactoryBean#getObjectType()
*/
@Override
public Class<?> getObjectType() {
return Session.class;
}
/* (non-Javadoc)
* @see org.springframework.beans.factory.FactoryBean#isSingleton()
*/
@Override
public boolean isSingleton() {
return true;
}
}

6
spring-cassandra/src/main/java/org/springframework/cassandra/core/SimplePreparedStatementCreator.java
View File

@@ -25,7 +25,7 @@ import com.datastax.driver.core.exceptions.DriverException;
* @author David Webb
*
*/
public class SimplePreparedStatementCreator implements PreparedStatementCreator, CqlProvider {
public class SimplePreparedStatementCreator implements PreparedStatementCreator {
private final String cql;
@@ -39,10 +39,6 @@ public class SimplePreparedStatementCreator implements PreparedStatementCreator,
this.cql = cql;
}
/* (non-Javadoc)
* @see org.springframework.cassandra.core.CqlProvider#getCql()
*/
@Override
public String getCql() {
return this.cql;
}

10
spring-cassandra/src/main/java/org/springframework/cassandra/core/cql/generator/CreateTableCqlGenerator.java
View File

@@ -65,14 +65,14 @@ public class CreateTableCqlGenerator extends TableCqlGenerator<CreateTableSpecif
cql.append(" (");
List<ColumnSpecification> partitionKeys = new ArrayList<ColumnSpecification>();
List<ColumnSpecification> clusteredKeys = new ArrayList<ColumnSpecification>();
List<ColumnSpecification> clusterKeys = new ArrayList<ColumnSpecification>();
for (ColumnSpecification col : spec().getColumns()) {
col.toCql(cql).append(", ");
if (col.getKeyType() == PARTITIONED) {
partitionKeys.add(col);
} else if (col.getKeyType() == CLUSTERED) {
clusteredKeys.add(col);
clusterKeys.add(col);
}
}
@@ -91,11 +91,11 @@ public class CreateTableCqlGenerator extends TableCqlGenerator<CreateTableSpecif
// end partition key clause
}
if (!clusteredKeys.isEmpty()) {
if (!clusterKeys.isEmpty()) {
cql.append(", ");
}
appendColumnNames(cql, clusteredKeys);
appendColumnNames(cql, clusterKeys);
cql.append(")");
// end primary key clause
@@ -103,7 +103,7 @@ public class CreateTableCqlGenerator extends TableCqlGenerator<CreateTableSpecif
cql.append(")");
// end columns
StringBuilder ordering = createOrderingClause(clusteredKeys);
StringBuilder ordering = createOrderingClause(clusterKeys);
// begin options
// begin option clause
Map<String, Object> options = spec().getOptions();

5
spring-cassandra/src/main/java/org/springframework/cassandra/core/keyspace/ColumnChangeSpecification.java
View File

@@ -18,6 +18,11 @@ package org.springframework.cassandra.core.keyspace;
import static org.springframework.cassandra.core.cql.CqlStringUtils.checkIdentifier;
import static org.springframework.cassandra.core.cql.CqlStringUtils.identifize;
/**
* Base class for column change specifications.
*
* @author Matthew T. Adams
*/
public abstract class ColumnChangeSpecification {
private String name;

34
spring-cassandra/src/main/java/org/springframework/cassandra/core/keyspace/ColumnSpecification.java
View File

@@ -28,12 +28,12 @@ import org.springframework.cassandra.core.Ordering;
import com.datastax.driver.core.DataType;
/**
* Builder class to help construct CQL statements that involve column manipulation. Not threadsafe.
* Builder class to specify columns.
* <p/>
* Use {@link #name(String)} and {@link #type(String)} to set the name and type of the column, respectively. To specify
* a <code>PRIMARY KEY</code> column, use {@link #primary()} or {@link #primary(Ordering)}. To specify that the
* <code>PRIMARY KEY</code> column is or is part of the partition key, use {@link #partition()} instead of
* {@link #primary()} or {@link #primary(Ordering)}.
* a clustered <code>PRIMARY KEY</code> column, use {@link #clustered()} or {@link #clustered(Ordering)}. To specify
* that the <code>PRIMARY KEY</code> column is or is part of the partition key, use {@link #partitioned()} instead of
* {@link #clustered()} or {@link #clustered(Ordering)}.
*
* @author Matthew T. Adams
* @author Alex Shvid
@@ -77,8 +77,8 @@ public class ColumnSpecification {
*
* @return this
*/
public ColumnSpecification partition() {
return partition(true);
public ColumnSpecification partitioned() {
return partitioned(true);
}
/**
@@ -88,40 +88,40 @@ public class ColumnSpecification {
*
* @return this
*/
public ColumnSpecification partition(boolean partition) {
this.keyType = partition ? PARTITIONED : null;
public ColumnSpecification partitioned(boolean partitioned) {
this.keyType = partitioned ? PARTITIONED : null;
this.ordering = null;
return this;
}
/**
* Identifies this column as a primary key column with default ordering. Sets the column's {@link #keyType} to
* Identifies this column as a clustered key column with default ordering. Sets the column's {@link #keyType} to
* {@link PrimaryKeyType#CLUSTERED} and its {@link #ordering} to {@link #DEFAULT_ORDERING}.
*
* @return this
*/
public ColumnSpecification primary() {
return primary(DEFAULT_ORDERING);
public ColumnSpecification clustered() {
return clustered(DEFAULT_ORDERING);
}
/**
* Identifies this column as a primary key column with the given ordering. Sets the column's {@link #keyType} to
* Identifies this column as a clustered key column with the given ordering. Sets the column's {@link #keyType} to
* {@link PrimaryKeyType#CLUSTERED} and its {@link #ordering} to the given {@link Ordering}.
*
* @return this
*/
public ColumnSpecification primary(Ordering order) {
return primary(order, true);
public ColumnSpecification clustered(Ordering order) {
return clustered(order, true);
}
/**
* Toggles the identification of this column as a primary key column. If the given boolean is <code>true</code>, then
* sets the column's {@link #keyType} to {@link PrimaryKeyType#PARTITIONED} and {@link #ordering} to the given
* Toggles the identification of this column as a clustered key column. If the given boolean is <code>true</code>,
* then sets the column's {@link #keyType} to {@link PrimaryKeyType#PARTITIONED} and {@link #ordering} to the given
* {@link Ordering} , else sets both {@link #keyType} and {@link #ordering} to <code>null</code>.
*
* @return this
*/
public ColumnSpecification primary(Ordering order, boolean primary) {
public ColumnSpecification clustered(Ordering order, boolean primary) {
this.keyType = primary ? CLUSTERED : null;
this.ordering = primary ? order : null;
return this;

5
spring-cassandra/src/main/java/org/springframework/cassandra/core/keyspace/ColumnTypeChangeSpecification.java
View File

@@ -19,6 +19,11 @@ import org.springframework.util.Assert;
import com.datastax.driver.core.DataType;
/**
* Base class for column changes that include {@link DataType} information.
*
* @author Matthew T. Adams
*/
public abstract class ColumnTypeChangeSpecification extends ColumnChangeSpecification {
private DataType type;

5
spring-cassandra/src/main/java/org/springframework/cassandra/core/keyspace/DropColumnSpecification.java
View File

@@ -15,6 +15,11 @@
*/
package org.springframework.cassandra.core.keyspace;
/**
* A specification to drop a column.
*
* @author Matthew T. Adams
*/
public class DropColumnSpecification extends ColumnChangeSpecification {
public DropColumnSpecification(String name) {

1
spring-cassandra/src/main/resources/META-INF/spring.handlers Normal file
View File

@@ -0,0 +1 @@
http\://www.springframework.org/schema/cassandra=org.springframework.cassandra.config.xml.CassandraNamespaceHandler

2
spring-cassandra/src/main/resources/META-INF/spring.schemas Normal file
View File

@@ -0,0 +1,2 @@
http\://www.springframework.org/schema/cassandra/spring-cassandra-1.0.xsd=org/springframework/cassandra/config/spring-cassandra-1.0.xsd
http\://www.springframework.org/schema/cassandra/spring-cassandra.xsd=org/springframework/cassandra/config/spring-cassandra-1.0.xsd

4
spring-cassandra/src/main/resources/META-INF/spring.tooling Normal file
View File

@@ -0,0 +1,4 @@
# Tooling related information for the cassandra namespace
http\://www.springframework.org/schema/cassandra@name=Spring Cassandra Namespace
http\://www.springframework.org/schema/cassandra@prefix=cassandra
http\://www.springframework.org/schema/cassandra@icon=org/springframework/data/cassandra/config/spring-cassandra.gif

342
spring-cassandra/src/main/resources/org/springframework/cassandra/config/spring-cassandra-1.0.xsd Normal file
View File

@@ -0,0 +1,342 @@
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.springframework.org/schema/cassandra"
xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tool="http://www.springframework.org/schema/tool"
targetNamespace="http://www.springframework.org/schema/cassandra"
elementFormDefault="qualified" attributeFormDefault="unqualified">
<xsd:import namespace="http://www.springframework.org/schema/tool"
schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd" />
<xsd:annotation>
<xsd:documentation><![CDATA[
Defines the configuration elements for Spring Cassandra support.
]]></xsd:documentation>
</xsd:annotation>
<xsd:element name="session" type="sessionType">
<xsd:annotation>
<xsd:documentation
source="org.springframework.cassandra.config.xml.SessionFactoryBean"><![CDATA[
Defines a Cassandra Session.
]]></xsd:documentation>
<xsd:appinfo>
<tool:annotation>
<tool:exports type="com.datastax.driver.core.Session" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
</xsd:element>
<xsd:element name="template" type="templateType">
<xsd:annotation>
<xsd:documentation
source="org.springframework.cassandra.config.xml.TemplateFactoryBean"><![CDATA[
Defines a Cassandra Templat.
]]></xsd:documentation>
<xsd:appinfo>
<tool:annotation>
<tool:exports type="org.springframework.cassandra.CassandraTemplate" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
</xsd:element>
<xsd:element name="cluster" type="clusterType">
<xsd:annotation>
<xsd:documentation
source="org.springframework.cassandra.config.xml.CassandraClusterFactoryBean"><![CDATA[
Defines a Cassandra Cluster.
]]></xsd:documentation>
<xsd:appinfo>
<tool:annotation>
<tool:exports type="com.datastax.driver.core.Cluster" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
</xsd:element>
<xsd:complexType name="clusterType">
<xsd:sequence>
<xsd:element name="local-pooling-options" type="poolingOptionsType"
maxOccurs="1" minOccurs="0">
</xsd:element>
<xsd:element name="remote-pooling-options" type="poolingOptionsType"
maxOccurs="1" minOccurs="0">
</xsd:element>
<xsd:element name="socket-options" type="socketOptionsType"
maxOccurs="1" minOccurs="0"></xsd:element>
</xsd:sequence>
<xsd:attribute name="id" type="xsd:ID" use="optional">
<xsd:annotation>
<xsd:documentation>
The name of the Cassandra Cluster definition (by
default "cassandra-cluster")
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="contactPoints" type="xsd:string"
use="optional" default="localhost">
<xsd:annotation>
<xsd:documentation><![CDATA[
The comma separated list of Cassandra servers. Default is localhost.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="port" type="xsd:string" use="optional"
default="9042">
<xsd:annotation>
<xsd:documentation><![CDATA[
The native CQL port to connect to. Default is 9042.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="compression" default="NONE" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
The protocol compression option. Default is 'none'.
]]></xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="NONE">
<xsd:annotation>
<xsd:documentation><![CDATA[
No compression.
]]></xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="SNAPPY">
<xsd:annotation>
<xsd:documentation><![CDATA[
Uses SNAPPY compression algorithm.
]]></xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="auth-info-provider" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
AuthInfoProvider implementation.
]]></xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to type="com.datastax.driver.core.AuthInfoProvider" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="load-balancing-policy" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
LoadBalancingPolicy implementation.
]]></xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to
type="com.datastax.driver.core.policies.LoadBalancingPolicy" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="reconnection-policy" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
ReconnectionPolicy implementation.
]]></xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to
type="com.datastax.driver.core.policies.ReconnectionPolicy" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="retry-policy" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
RetryPolicy implementation.
]]></xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to
type="com.datastax.driver.core.policies.RetryPolicy" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
</xsd:attribute>
</xsd:complexType>
<xsd:simpleType name="clusterRef" final="union">
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to type="com.datastax.driver.core.Cluster" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
<xsd:simpleType name="sessionRef" final="union">
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to type="com.datastax.driver.core.Session" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
<xsd:complexType name="poolingOptionsType">
<xsd:attribute name="min-simultaneous-requests" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
if the utilisation of opened connections drops below by this configured threshold, then cassandra drops connections till core-connections.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="max-simultaneous-requests" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
If the utilisation of connections reaches this configurable threshold, then cassandra creates more connections up to max-connections.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="core-connections" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
For each host, the driver keeps a core amount of connections open at all time.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="max-connections" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
More connections are created up to a configurable maximum number of connections.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="socketOptionsType">
<xsd:attribute name="connect-timeout-mls" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets connection timeout for client socket in milliseconds.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="keep-alive" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_KEEPALIVE socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="reuse-address" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_REUSEADDR socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="so-linger" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_LINGER socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="tcp-no-delay" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_TCPNODELAY socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="receive-buffer-size" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_RCVBUF socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="send-buffer-size" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_SNDBUF socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="sessionType">
<xsd:attribute name="id" type="xsd:ID" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
The name of the Session definition; default is 'cassandra-session'.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="cluster-ref" type="clusterRef"
use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
The reference to a Cassandra Cluster; default is 'cassandra-cluster'.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="keyspace-name" type="xsd:string"
use="required">
<xsd:annotation>
<xsd:documentation><![CDATA[
The name of a Cassandra Keyspace. No default; for the system keyspace, use the empty string.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="templateType">
<xsd:attribute name="id" type="xsd:ID" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
The name of the template; default is 'cassandra-template'.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="session-ref" type="sessionRef"
use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
The reference to a Cassandra Session; default is 'cassandra-session'.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
</xsd:schema>

BIN
spring-cassandra/src/main/resources/org/springframework/cassandra/config/spring-cassandra.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 581 B

33
spring-cassandra/src/test/java/org/springframework/cassandra/test/integration/AbstractEmbeddedCassandraIntegrationTest.java
View File

@@ -7,8 +7,6 @@ import org.apache.cassandra.exceptions.ConfigurationException;
import org.apache.thrift.transport.TTransportException;
import org.cassandraunit.utils.EmbeddedCassandraServerHelper;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.KeyspaceMetadata;
@@ -16,16 +14,24 @@ import com.datastax.driver.core.Session;
public abstract class AbstractEmbeddedCassandraIntegrationTest {
protected final static String CASSANDRA_CONFIG = "cassandra.yaml";
protected final static String CASSANDRA_CONFIG = "spring-cassandra.yaml";
protected final static String CASSANDRA_HOST = "localhost";
protected final static int CASSANDRA_NATIVE_PORT = 9042;
@BeforeClass
public static void beforeClass() throws ConfigurationException, TTransportException, IOException,
public static void startCassandra() throws ConfigurationException, TTransportException, IOException,
InterruptedException {
EmbeddedCassandraServerHelper.startEmbeddedCassandra(CASSANDRA_CONFIG);
}
public AbstractEmbeddedCassandraIntegrationTest() {
try {
startCassandra();
} catch (Exception e) {
throw new RuntimeException(e);
}
connect();
}
/**
* Whether to clear the cluster before the next test.
*/
@@ -47,6 +53,10 @@ public abstract class AbstractEmbeddedCassandraIntegrationTest {
*/
protected Session session;
protected String keyspace() {
return keyspace;
}
/**
* Returns whether we're currently connected to the cluster.
*/
@@ -58,23 +68,22 @@ public abstract class AbstractEmbeddedCassandraIntegrationTest {
return Cluster.builder().addContactPoint(CASSANDRA_HOST).withPort(CASSANDRA_NATIVE_PORT).build();
}
@Before
public void before() {
public void connect() {
if (connect && !connected()) {
cluster = cluster();
if (keyspace == null) {
if (keyspace() == null) {
session = cluster.connect();
} else {
KeyspaceMetadata kmd = cluster.getMetadata().getKeyspace(keyspace);
KeyspaceMetadata kmd = cluster.getMetadata().getKeyspace(keyspace());
if (kmd == null) { // then create keyspace
session = cluster.connect();
session.execute("CREATE KEYSPACE " + keyspace
session.execute("CREATE KEYSPACE " + keyspace()
+ " WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1};");
session.execute("USE " + keyspace + ";");
session.execute("USE " + keyspace() + ";");
} else {// else keyspace already exists
session = cluster.connect(keyspace);
session = cluster.connect(keyspace());
}
}
}

16
spring-cassandra/src/test/java/org/springframework/cassandra/test/integration/config/IntegrationTestUtils.java Normal file
View File

@@ -0,0 +1,16 @@
package org.springframework.cassandra.test.integration.config;
import static org.junit.Assert.assertNotNull;
import com.datastax.driver.core.Session;
public class IntegrationTestUtils {
public static void assertSession(Session session) {
assertNotNull(session);
}
public static void assertKeyspaceExists(String keyspace, Session session) {
assertNotNull(session.getCluster().getMetadata().getKeyspace(keyspace));
}
}

23
spring-cassandra/src/test/java/org/springframework/cassandra/test/integration/config/java/AbstractIntegrationTest.java Normal file
View File

@@ -0,0 +1,23 @@
package org.springframework.cassandra.test.integration.config.java;
import javax.inject.Inject;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.springframework.cassandra.test.integration.AbstractEmbeddedCassandraIntegrationTest;
import org.springframework.cassandra.test.integration.config.IntegrationTestUtils;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.datastax.driver.core.Session;
@RunWith(SpringJUnit4ClassRunner.class)
public abstract class AbstractIntegrationTest extends AbstractEmbeddedCassandraIntegrationTest {
@Inject
public Session session;
@Before
public void assertSession() {
IntegrationTestUtils.assertSession(session);
}
}

20
spring-cassandra/src/test/java/org/springframework/cassandra/test/integration/config/java/AbstractIntegrationTestConfiguration.java Normal file
View File

@@ -0,0 +1,20 @@
package org.springframework.cassandra.test.integration.config.java;
import org.springframework.cassandra.config.java.AbstractCassandraConfiguration;
import org.springframework.context.annotation.Configuration;
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Cluster.Builder;
@Configuration
public abstract class AbstractIntegrationTestConfiguration extends AbstractCassandraConfiguration {
@Override
public Cluster cluster() {
Builder builder = Cluster.builder();
builder.addContactPoint("localhost").withPort(9042);
return builder.build();
}
}

57
spring-cassandra/src/test/java/org/springframework/cassandra/test/integration/config/java/AbstractKeyspaceCreatingConfiguration.java Normal file
View File

@@ -0,0 +1,57 @@
package org.springframework.cassandra.test.integration.config.java;
import org.springframework.cassandra.config.KeyspaceAttributes;
import org.springframework.cassandra.config.PoolingOptionsConfig;
import org.springframework.cassandra.config.SocketOptionsConfig;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;
import com.datastax.driver.core.KeyspaceMetadata;
import com.datastax.driver.core.Session;
@Configuration
public abstract class AbstractKeyspaceCreatingConfiguration extends AbstractIntegrationTestConfiguration {
@Override
public Session session() {
createKeyspaceIfNecessary();
return super.session();
}
protected void createKeyspaceIfNecessary() {
String keyspace = getKeyspaceName();
if (!StringUtils.hasText(keyspace)) {
return;
}
Session system = cluster().connect();
KeyspaceMetadata kmd = system.getCluster().getMetadata().getKeyspace(keyspace);
if (kmd != null) {
return;
}
// TODO: use KeyspaceBuilder to build keyspace with attributes & options
system.execute("CREATE KEYSPACE " + keyspace
+ " WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };");
system.shutdown();
}
protected KeyspaceAttributes getKeyspaceAttributes() {
return null;
}
protected PoolingOptionsConfig getLocalPoolingOptionsConfig() {
return null;
}
protected PoolingOptionsConfig getRemotePoolingOptionsConfig() {
return null;
}
protected SocketOptionsConfig getSocketOptionsConfig() {
return null;
}
}

12
spring-cassandra/src/test/java/org/springframework/cassandra/test/integration/config/java/Config.java Normal file
View File

@@ -0,0 +1,12 @@
package org.springframework.cassandra.test.integration.config.java;
import org.springframework.context.annotation.Configuration;
@Configuration
public class Config extends AbstractIntegrationTestConfiguration {
@Override
protected String getKeyspaceName() {
return null;
}
}

15
spring-cassandra/src/test/java/org/springframework/cassandra/test/integration/config/java/ConfigTest.java Normal file
View File

@@ -0,0 +1,15 @@
package org.springframework.cassandra.test.integration.config.java;
import org.junit.Test;
import org.springframework.test.context.ContextConfiguration;
@ContextConfiguration(classes = Config.class)
public class ConfigTest extends AbstractIntegrationTest {
@Test
public void test() {
session
.execute("CREATE KEYSPACE ConfigTest WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };");
session.execute("USE ConfigTest");
}
}

14
spring-cassandra/src/test/java/org/springframework/cassandra/test/integration/config/java/KeyspaceCreatingConfig.java Normal file
View File

@@ -0,0 +1,14 @@
package org.springframework.cassandra.test.integration.config.java;
import org.springframework.context.annotation.Configuration;
@Configuration
public class KeyspaceCreatingConfig extends AbstractKeyspaceCreatingConfiguration {
public static final String KEYSPACE = "kcc";
@Override
protected String getKeyspaceName() {
return KEYSPACE;
}
}

14
spring-cassandra/src/test/java/org/springframework/cassandra/test/integration/config/java/KeyspaceCreatingConfigTest.java Normal file
View File

@@ -0,0 +1,14 @@
package org.springframework.cassandra.test.integration.config.java;
import org.junit.Test;
import org.springframework.cassandra.test.integration.config.IntegrationTestUtils;
import org.springframework.test.context.ContextConfiguration;
@ContextConfiguration(classes = KeyspaceCreatingConfig.class)
public class KeyspaceCreatingConfigTest extends AbstractIntegrationTest {
@Test
public void test() {
IntegrationTestUtils.assertKeyspaceExists(KeyspaceCreatingConfig.KEYSPACE, session);
}
}

38
spring-cassandra/src/test/java/org/springframework/cassandra/test/integration/config/xml/MinimalXmlConfigTest.java Normal file
View File

@@ -0,0 +1,38 @@
package org.springframework.cassandra.test.integration.config.xml;
import static org.junit.Assert.*;
import javax.inject.Inject;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.cassandra.core.CassandraOperations;
import org.springframework.cassandra.test.integration.AbstractEmbeddedCassandraIntegrationTest;
import org.springframework.cassandra.test.integration.config.IntegrationTestUtils;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.datastax.driver.core.Session;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class MinimalXmlConfigTest extends AbstractEmbeddedCassandraIntegrationTest {
protected String keyspace() {
return "minimalxmlconfigtest";
}
@Inject
Session s;
@Inject
CassandraOperations ops;
@Test
public void test() {
IntegrationTestUtils.assertSession(s);
IntegrationTestUtils.assertKeyspaceExists(keyspace(), s);
assertNotNull(ops);
}
}

30
spring-cassandra/src/test/java/org/springframework/cassandra/test/integration/config/xml/XmlConfigTest.java Normal file
View File

@@ -0,0 +1,30 @@
package org.springframework.cassandra.test.integration.config.xml;
import javax.inject.Inject;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.cassandra.test.integration.AbstractEmbeddedCassandraIntegrationTest;
import org.springframework.cassandra.test.integration.config.IntegrationTestUtils;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.datastax.driver.core.Session;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class XmlConfigTest extends AbstractEmbeddedCassandraIntegrationTest {
protected String keyspace() {
return "xmlconfigtest";
}
@Inject
Session s;
@Test
public void test() {
IntegrationTestUtils.assertSession(s);
IntegrationTestUtils.assertKeyspaceExists(keyspace(), s);
}
}

3
spring-cassandra/src/test/resources/cassandra-keyspace.yaml
View File

@@ -1,3 +0,0 @@
name: test
replicationFactor: 1
strategy: org.apache.cassandra.locator.SimpleStrategy

3
spring-cassandra/src/test/resources/cql-dataload.cql
View File

@@ -1,3 +0,0 @@
create table book (isbn text, title text, author text, pages int, PRIMARY KEY (isbn));
create table book_alt (isbn text, title text, author text, pages int, PRIMARY KEY (isbn));
/*insert into book (isbn, title, author, pages) values ('999999999', 'Book of Nines', 'Nine Nine', 999);*/

6
spring-cassandra/src/test/resources/log4j.properties
View File

@@ -1,6 +0,0 @@
log4j.rootLogger=WARN, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d [%t] %-5p %c - %m%n
log4j.logger.org.springframework.data.cassandra=INFO

0
spring-cassandra/src/test/resources/logback.xml → spring-cassandra/src/test/resources/logback-test.xml
View File

1
spring-cassandra/src/test/resources/logging.properties
View File

@@ -1 +0,0 @@
handlers = org.slf4j.bridge.SLF4JBridgeHandler

14
spring-cassandra/src/test/resources/org/springframework/cassandra/test/integration/config/xml/MinimalXmlConfigTest-context.xml Normal file
View File

@@ -0,0 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cassandra="http://www.springframework.org/schema/cassandra"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/cassandra http://www.springframework.org/schema/cassandra/spring-cassandra-1.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<cassandra:cluster port="9042" />
<cassandra:session keyspace-name="minimalxmlconfigtest" />
<cassandra:template />
</beans>

33
spring-cassandra/src/test/resources/org/springframework/cassandra/test/integration/config/xml/XmlConfigTest-context.xml Normal file
View File

@@ -0,0 +1,33 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cassandra="http://www.springframework.org/schema/cassandra"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/cassandra http://www.springframework.org/schema/cassandra/spring-cassandra-1.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:property-placeholder
location="classpath:/org/springframework/cassandra/test/integration/config/xml/xmlconfigtest.properties" />
<cassandra:cluster id="cassandra-cluster"
contactPoints="${cassandra.contactPoints}" port="${cassandra.port}">
<cassandra:local-pooling-options
min-simultaneous-requests="25" max-simultaneous-requests="100"
core-connections="2" max-connections="8" />
<cassandra:remote-pooling-options
min-simultaneous-requests="25" max-simultaneous-requests="100"
core-connections="1" max-connections="2" />
<cassandra:socket-options
connect-timeout-mls="5000" keep-alive="true" reuse-address="true"
so-linger="60" tcp-no-delay="true" receive-buffer-size="65536"
send-buffer-size="65536" />
</cassandra:cluster>
<cassandra:session id="cassandra-session"
keyspace-name="${cassandra.keyspace}" />
<bean id="cassandraTemplate" class="org.springframework.cassandra.core.CassandraTemplate">
<constructor-arg ref="cassandra-session" />
</bean>
</beans>

6
spring-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/config/cassandra.properties → spring-cassandra/src/test/resources/org/springframework/cassandra/test/integration/config/xml/xmlconfigtest.properties
View File

@@ -1,7 +1,3 @@
cassandra.contactPoints=localhost
cassandra.port=9042
cassandra.keyspace=TestKS123
cassandra.keyspace=xmlconfigtest

55
spring-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/config/CassandraNamespaceTests-context.xml
View File

@@ -1,55 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cassandra="http://www.springframework.org/schema/data/cassandra"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/data/cassandra http://www.springframework.org/schema/data/cassandra/spring-cassandra-1.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:property-placeholder
location="classpath:/org/springframework/data/cassandra/test/integration/config/cassandra.properties" />
<cassandra:cluster id="cassandra-cluster"
contactPoints="${cassandra.contactPoints}" port="${cassandra.port}"
compression="SNAPPY">
<cassandra:local-pooling-options
min-simultaneous-requests="25" max-simultaneous-requests="100"
core-connections="2" max-connections="8" />
<cassandra:remote-pooling-options
min-simultaneous-requests="25" max-simultaneous-requests="100"
core-connections="1" max-connections="2" />
<cassandra:socket-options
connect-timeout-mls="5000" keep-alive="true" reuse-address="true"
so-linger="60" tcp-no-delay="true" receive-buffer-size="65536"
send-buffer-size="65536" />
</cassandra:cluster>
<bean id="cassandra-mapping"
class=" org.springframework.data.cassandra.mapping.CassandraMappingContext" />
<bean id="cassandra-converter"
class=" org.springframework.data.cassandra.convert.MappingCassandraConverter">
<constructor-arg ref="cassandra-mapping" />
</bean>
<cassandra:keyspace id="cassandra-keyspace" name="${cassandra.keyspace}"
cassandra-cluster-ref="cassandra-cluster" cassandra-converter-ref="cassandra-converter">
<cassandra:keyspace-attributes auto="update"
replication-stategy="SimpleStrategy" replication-factor="1"
durable-writes="true">
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.Comment" />
<cassandra:table
entity="org.springframework.data.cassandra.test.integration.table.Notification" />
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.Post" />
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.Timeline" />
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.User" />
</cassandra:keyspace-attributes>
</cassandra:keyspace>
<cassandra:session id="cassandra-session" cassandra-keyspace-ref="cassandra-keyspace"/>
<bean id="cassandraTemplate" class="org.springframework.cassandra.core.CassandraTemplate">
<constructor-arg ref="cassandra-session" />
</bean>
</beans>

2
spring-cassandra/src/test/resources/cassandra.yaml → spring-cassandra/src/test/resources/spring-cassandra.yaml
View File

@@ -339,7 +339,7 @@ native_transport_port: 9042
# transport is used. They are similar to rpc_min_threads and rpc_max_threads,
# though the defaults differ slightly.
# native_transport_min_threads: 16
native_transport_max_threads: 64
#native_transport_max_threads: 48
# Whether to start the thrift rpc server.
start_rpc: true

3
spring-data-cassandra-distribution/pom.xml
View File

@@ -21,6 +21,7 @@
<properties>
<project.root>${basedir}/..</project.root>
<dist.key>SDCASS</dist.key>
<wagon.version>1.0.3</wagon.version>
</properties>
<build>
@@ -28,10 +29,12 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.3</version>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>wagon-maven-plugin</artifactId>
<version>${wagon.version}</version>
</plugin>
</plugins>
</build>

66
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/AbstractCassandraConfiguration.java → spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/AbstractSpringDataCassandraConfiguration.java
View File

@@ -20,7 +20,7 @@ import java.util.Set;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.cassandra.core.CassandraOperations;
import org.springframework.cassandra.config.java.AbstractCassandraConfiguration;
import org.springframework.cassandra.core.CassandraTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
@@ -40,58 +40,20 @@ import org.springframework.data.mapping.context.MappingContext;
import org.springframework.util.ClassUtils;
import org.springframework.util.StringUtils;
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;
/**
* Base class for Spring Data Cassandra configuration using JavaConfig.
*
* @author Alex Shvid
* @author Matthew T. Adams
*/
@Configuration
public abstract class AbstractCassandraConfiguration implements BeanClassLoaderAware {
/**
* Used by CassandraTemplate and CassandraAdminTemplate
*/
public abstract class AbstractSpringDataCassandraConfiguration extends AbstractCassandraConfiguration implements
BeanClassLoaderAware {
private ClassLoader beanClassLoader;
/**
* Return the name of the keyspace to connect to.
*
* @return must not be {@literal null}.
*/
protected abstract String getKeyspaceName();
/**
* Return the {@link Cluster} instance to connect to.
*
* @return
* @throws Exception
*/
@Bean
public abstract Cluster cluster() throws Exception;
/**
* Creates a {@link Session} to be used by the {@link SpringDataKeyspace}. Will use the {@link Cluster} instance
* configured in {@link #cluster()}.
*
* @see #cluster()
* @see #Keyspace()
* @return
* @throws Exception
*/
@Bean
public Session session() throws Exception {
String keyspace = getKeyspaceName();
if (StringUtils.hasText(keyspace)) {
return cluster().connect(keyspace);
} else {
return cluster().connect();
}
}
/**
* Creates a {@link SpringDataKeyspace} to be used by the {@link CassandraTemplate}. Will use the {@link Session}
* instance configured in {@link #session()} and {@link CassandraConverter} configured in {@link #converter()}.
@@ -109,8 +71,8 @@ public abstract class AbstractCassandraConfiguration implements BeanClassLoaderA
/**
* Return the base package to scan for mapped {@link Table}s. Will return the package name of the configuration class'
* (the concrete class, not this one here) by default. So if you have a {@code com.acme.AppConfig} extending
* {@link AbstractCassandraConfiguration} the base package will be considered {@code com.acme} unless the method is
* overriden to implement alternate behaviour.
* {@link AbstractSpringDataCassandraConfiguration} the base package will be considered {@code com.acme} unless the
* method is overriden to implement alternate behaviour.
*
* @return the base package to scan for mapped {@link Table} classes or {@literal null} to not enable scanning for
* entities.
@@ -119,17 +81,6 @@ public abstract class AbstractCassandraConfiguration implements BeanClassLoaderA
return getClass().getPackage().getName();
}
/**
* Creates a {@link CassandraTemplate}.
*
* @return
* @throws Exception
*/
@Bean
public CassandraOperations cassandraTemplate() throws Exception {
return new CassandraTemplate(session());
}
/**
* Creates a {@link CassandraAdminTemplate}.
*
@@ -137,7 +88,7 @@ public abstract class AbstractCassandraConfiguration implements BeanClassLoaderA
* @throws Exception
*/
@Bean
public CassandraAdminOperations cassandraAdminTemplate() throws Exception {
public CassandraAdminOperations adminTemplate() throws Exception {
return new CassandraAdminTemplate(keyspace());
}
@@ -185,7 +136,7 @@ public abstract class AbstractCassandraConfiguration implements BeanClassLoaderA
for (BeanDefinition candidate : componentProvider.findCandidateComponents(basePackage)) {
initialEntitySet.add(ClassUtils.forName(candidate.getBeanClassName(),
AbstractCassandraConfiguration.class.getClassLoader()));
AbstractSpringDataCassandraConfiguration.class.getClassLoader()));
}
}
@@ -199,5 +150,4 @@ public abstract class AbstractCassandraConfiguration implements BeanClassLoaderA
public void setBeanClassLoader(ClassLoader classLoader) {
this.beanClassLoader = classLoader;
}
}

5
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraKeyspaceFactoryBean.java → spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraKeyspaceFactoryBean.java
View File

@@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.cassandra.core;
package org.springframework.data.cassandra.config;
import java.util.List;
import java.util.Map;
@@ -28,10 +28,9 @@ import org.springframework.cassandra.support.CassandraExceptionTranslator;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.dao.support.PersistenceExceptionTranslator;
import org.springframework.data.cassandra.config.KeyspaceAttributes;
import org.springframework.data.cassandra.config.TableAttributes;
import org.springframework.data.cassandra.convert.CassandraConverter;
import org.springframework.data.cassandra.convert.MappingCassandraConverter;
import org.springframework.data.cassandra.core.SpringDataKeyspace;
import org.springframework.data.cassandra.mapping.CassandraMappingContext;
import org.springframework.data.cassandra.mapping.CassandraPersistentEntity;
import org.springframework.data.cassandra.mapping.CassandraPersistentProperty;

3
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraKeyspaceParser.java
View File

@@ -24,7 +24,8 @@ import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.ManagedList;
import org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.data.cassandra.core.CassandraKeyspaceFactoryBean;
import org.springframework.cassandra.config.KeyspaceAttributes;
import org.springframework.cassandra.config.xml.BeanNames;
import org.springframework.data.config.ParsingUtils;
import org.springframework.util.StringUtils;
import org.springframework.util.xml.DomUtils;

6
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraNamespaceHandler.java
View File

@@ -18,7 +18,7 @@ package org.springframework.data.cassandra.config;
import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
/**
* Namespace handler for &lt;cassandra;gt;.
* Namespace handler for &lt;cassandra&gt;.
*
* @author Alex Shvid
*/
@@ -27,10 +27,6 @@ public class CassandraNamespaceHandler extends NamespaceHandlerSupport {
public void init() {
registerBeanDefinitionParser("cluster", new CassandraClusterParser());
registerBeanDefinitionParser("keyspace", new CassandraKeyspaceParser());
registerBeanDefinitionParser("session", new CassandraSessionParser());
}
}

33
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/KeyspaceAttributes.java
View File

@@ -23,11 +23,7 @@ import java.util.Collection;
*
* @author Alex Shvid
*/
public class KeyspaceAttributes {
public static final String DEFAULT_REPLICATION_STRATEGY = "SimpleStrategy";
public static final int DEFAULT_REPLICATION_FACTOR = 1;
public static final boolean DEFAULT_DURABLE_WRITES = true;
public class KeyspaceAttributes extends org.springframework.cassandra.config.KeyspaceAttributes {
/*
* auto possible values:
@@ -42,9 +38,6 @@ public class KeyspaceAttributes {
public static final String AUTO_CREATE_DROP = "create-drop";
private String auto = AUTO_VALIDATE;
private String replicationStrategy = DEFAULT_REPLICATION_STRATEGY;
private int replicationFactor = DEFAULT_REPLICATION_FACTOR;
private boolean durableWrites = DEFAULT_DURABLE_WRITES;
private Collection<TableAttributes> tables;
@@ -72,30 +65,6 @@ public class KeyspaceAttributes {
return AUTO_CREATE_DROP.equals(auto);
}
public String getReplicationStrategy() {
return replicationStrategy;
}
public void setReplicationStrategy(String replicationStrategy) {
this.replicationStrategy = replicationStrategy;
}
public int getReplicationFactor() {
return replicationFactor;
}
public void setReplicationFactor(int replicationFactor) {
this.replicationFactor = replicationFactor;
}
public boolean isDurableWrites() {
return durableWrites;
}
public void setDurableWrites(boolean durableWrites) {
this.durableWrites = durableWrites;
}
public Collection<TableAttributes> getTables() {
return tables;
}

2
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CassandraPropertyValueProvider.java
View File

@@ -73,7 +73,7 @@ public class CassandraPropertyValueProvider implements PropertyValueProvider<Cas
}
DataType columnType = source.getColumnDefinitions().getType(columnName);
log.info(columnType.getName().name());
log.debug(columnType.getName().name());
/*
* Dave Webb - Added handler for text since getBytes was throwing

185
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraDataOperations.java
View File

@@ -16,7 +16,6 @@
package org.springframework.data.cassandra.core;
import java.util.List;
import java.util.Map;
import org.springframework.cassandra.core.QueryOptions;
import org.springframework.data.cassandra.convert.CassandraConverter;
@@ -122,22 +121,6 @@ public interface CassandraDataOperations {
*/
<T> T insert(T entity, QueryOptions options);
/**
* @param entity
* @param tableName
* @param options
* @return
*/
<T> T insert(T entity, Map<String, Object> optionsByName);
/**
* @param entity
* @param tableName
* @param optionsByName
* @return
*/
<T> T insert(T entity, String tableName, Map<String, Object> optionsByName);
/**
* Insert the given list of objects to the table by annotation table name.
*
@@ -163,14 +146,6 @@ public interface CassandraDataOperations {
*/
<T> List<T> insert(List<T> entities, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
* @return
*/
<T> List<T> insert(List<T> entities, Map<String, Object> optionsByName);
/**
* @param entities
* @param tableName
@@ -179,14 +154,6 @@ public interface CassandraDataOperations {
*/
<T> List<T> insert(List<T> entities, String tableName, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
* @return
*/
<T> List<T> insert(List<T> entities, String tableName, Map<String, Object> optionsByName);
/**
* Insert the given object to the table by id.
*
@@ -209,14 +176,6 @@ public interface CassandraDataOperations {
*/
<T> T insertAsynchronously(T entity, QueryOptions options);
/**
* @param entity
* @param tableName
* @param optionsByName
* @return
*/
<T> T insertAsynchronously(T entity, Map<String, Object> optionsByName);
/**
* @param entity
* @param tableName
@@ -225,14 +184,6 @@ public interface CassandraDataOperations {
*/
<T> T insertAsynchronously(T entity, String tableName, QueryOptions options);
/**
* @param entity
* @param tableName
* @param optionsByName
* @return
*/
<T> T insertAsynchronously(T entity, String tableName, Map<String, Object> optionsByName);
/**
* Insert the given object to the table by id.
*
@@ -255,14 +206,6 @@ public interface CassandraDataOperations {
*/
<T> List<T> insertAsynchronously(List<T> entities, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
* @return
*/
<T> List<T> insertAsynchronously(List<T> entities, Map<String, Object> optionsByName);
/**
* @param entities
* @param tableName
@@ -271,14 +214,6 @@ public interface CassandraDataOperations {
*/
<T> List<T> insertAsynchronously(List<T> entities, String tableName, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
* @return
*/
<T> List<T> insertAsynchronously(List<T> entities, String tableName, Map<String, Object> optionsByName);
/**
* Insert the given object to the table by id.
*
@@ -301,14 +236,6 @@ public interface CassandraDataOperations {
*/
<T> T update(T entity, QueryOptions options);
/**
* @param entity
* @param tableName
* @param optionsByName
* @return
*/
<T> T update(T entity, Map<String, Object> optionsByName);
/**
* @param entity
* @param tableName
@@ -317,14 +244,6 @@ public interface CassandraDataOperations {
*/
<T> T update(T entity, String tableName, QueryOptions options);
/**
* @param entity
* @param tableName
* @param optionsByName
* @return
*/
<T> T update(T entity, String tableName, Map<String, Object> optionsByName);
/**
* Insert the given object to the table by id.
*
@@ -347,14 +266,6 @@ public interface CassandraDataOperations {
*/
<T> List<T> update(List<T> entities, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
* @return
*/
<T> List<T> update(List<T> entities, Map<String, Object> optionsByName);
/**
* @param entities
* @param tableName
@@ -363,14 +274,6 @@ public interface CassandraDataOperations {
*/
<T> List<T> update(List<T> entities, String tableName, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
* @return
*/
<T> List<T> update(List<T> entities, String tableName, Map<String, Object> optionsByName);
/**
* Insert the given object to the table by id.
*
@@ -393,14 +296,6 @@ public interface CassandraDataOperations {
*/
<T> T updateAsynchronously(T entity, QueryOptions options);
/**
* @param entity
* @param tableName
* @param optionsByName
* @return
*/
<T> T updateAsynchronously(T entity, Map<String, Object> optionsByName);
/**
* @param entity
* @param tableName
@@ -409,14 +304,6 @@ public interface CassandraDataOperations {
*/
<T> T updateAsynchronously(T entity, String tableName, QueryOptions options);
/**
* @param entity
* @param tableName
* @param optionsByName
* @return
*/
<T> T updateAsynchronously(T entity, String tableName, Map<String, Object> optionsByName);
/**
* Insert the given object to the table by id.
*
@@ -439,14 +326,6 @@ public interface CassandraDataOperations {
*/
<T> List<T> updateAsynchronously(List<T> entities, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
* @return
*/
<T> List<T> updateAsynchronously(List<T> entities, Map<String, Object> optionsByName);
/**
* @param entities
* @param tableName
@@ -455,14 +334,6 @@ public interface CassandraDataOperations {
*/
<T> List<T> updateAsynchronously(List<T> entities, String tableName, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
* @return
*/
<T> List<T> updateAsynchronously(List<T> entities, String tableName, Map<String, Object> optionsByName);
/**
* Remove the given object from the table by id.
*
@@ -485,13 +356,6 @@ public interface CassandraDataOperations {
*/
<T> void delete(T entity, QueryOptions options);
/**
* @param entity
* @param tableName
* @param optionsByName
*/
<T> void delete(T entity, Map<String, Object> optionsByName);
/**
* @param entity
* @param tableName
@@ -499,13 +363,6 @@ public interface CassandraDataOperations {
*/
<T> void delete(T entity, String tableName, QueryOptions options);
/**
* @param entity
* @param tableName
* @param optionsByName
*/
<T> void delete(T entity, String tableName, Map<String, Object> optionsByName);
/**
* Remove the given object from the table by id.
*
@@ -528,13 +385,6 @@ public interface CassandraDataOperations {
*/
<T> void delete(List<T> entities, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
*/
<T> void delete(List<T> entities, Map<String, Object> optionsByName);
/**
* @param entities
* @param tableName
@@ -542,13 +392,6 @@ public interface CassandraDataOperations {
*/
<T> void delete(List<T> entities, String tableName, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
*/
<T> void delete(List<T> entities, String tableName, Map<String, Object> optionsByName);
/**
* Remove the given object from the table by id.
*
@@ -563,13 +406,6 @@ public interface CassandraDataOperations {
*/
<T> void deleteAsynchronously(T entity, QueryOptions options);
/**
* @param entity
* @param tableName
* @param optionsByName
*/
<T> void deleteAsynchronously(T entity, Map<String, Object> optionsByName);
/**
* @param entity
* @param tableName
@@ -577,13 +413,6 @@ public interface CassandraDataOperations {
*/
<T> void deleteAsynchronously(T entity, String tableName, QueryOptions options);
/**
* @param entity
* @param tableName
* @param optionsByName
*/
<T> void deleteAsynchronously(T entity, String tableName, Map<String, Object> optionsByName);
/**
* Removes the given object from the given table.
*
@@ -614,13 +443,6 @@ public interface CassandraDataOperations {
*/
<T> void deleteAsynchronously(List<T> entities, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
*/
<T> void deleteAsynchronously(List<T> entities, Map<String, Object> optionsByName);
/**
* @param entities
* @param tableName
@@ -628,13 +450,6 @@ public interface CassandraDataOperations {
*/
<T> void deleteAsynchronously(List<T> entities, String tableName, QueryOptions options);
/**
* @param entities
* @param tableName
* @param optionsByName
*/
<T> void deleteAsynchronously(List<T> entities, String tableName, Map<String, Object> optionsByName);
/**
* Returns the underlying {@link CassandraConverter}.
*

384
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraDataTemplate.java
View File

@@ -21,7 +21,6 @@ import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.cassandra.core.CassandraTemplate;
@@ -78,8 +77,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
/*
* Required elements for successful Template Operations. These can be set with the Constructor, or wired in
* later.
*
* TODO - DW - Discuss Autowiring these.
*/
private String keyspace;
private CassandraConverter cassandraConverter;
@@ -150,16 +147,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
delete(entities, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#delete(java.util.List, java.util.Map)
*/
@Override
public <T> void delete(List<T> entities, Map<String, Object> optionsByName) {
String tableName = getTableName(entities.get(0).getClass());
Assert.notNull(tableName);
delete(entities, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#delete(java.util.List, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -176,19 +163,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
@Override
public <T> void delete(List<T> entities, String tableName) {
delete(entities, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#delete(java.util.List, java.lang.String, java.util.Map)
*/
@Override
public <T> void delete(List<T> entities, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
Assert.notNull(optionsByName);
doBatchDelete(tableName, entities, optionsByName, false);
delete(entities, tableName, null);
}
/* (non-Javadoc)
@@ -196,7 +171,10 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> void delete(List<T> entities, String tableName, QueryOptions options) {
delete(entities, tableName, options.toMap());
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
doBatchDelete(tableName, entities, options, false);
}
/* (non-Javadoc)
@@ -209,16 +187,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
delete(entity, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#delete(java.lang.Object, java.util.Map)
*/
@Override
public <T> void delete(T entity, Map<String, Object> optionsByName) {
String tableName = getTableName(entity.getClass());
Assert.notNull(tableName);
delete(entity, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#delete(java.lang.Object, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -234,19 +202,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> void delete(T entity, String tableName) {
delete(entity, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#delete(java.lang.Object, java.lang.String, java.util.Map)
*/
@Override
public <T> void delete(T entity, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entity);
Assert.notNull(tableName);
Assert.notNull(optionsByName);
doDelete(tableName, entity, optionsByName, false);
delete(entity, tableName, null);
}
/* (non-Javadoc)
@@ -254,7 +210,9 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> void delete(T entity, String tableName, QueryOptions options) {
delete(entity, tableName, options.toMap());
Assert.notNull(entity);
Assert.notNull(tableName);
doDelete(tableName, entity, options, false);
}
/* (non-Javadoc)
@@ -267,16 +225,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
deleteAsynchronously(entities, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#deleteAsynchronously(java.util.List, java.util.Map)
*/
@Override
public <T> void deleteAsynchronously(List<T> entities, Map<String, Object> optionsByName) {
String tableName = getTableName(entities.get(0).getClass());
Assert.notNull(tableName);
deleteAsynchronously(entities, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#deleteAsynchronously(java.util.List, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -292,20 +240,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> void deleteAsynchronously(List<T> entities, String tableName) {
insertAsynchronously(entities, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#deleteAsynchronously(java.util.List, java.lang.String, java.util.Map)
*/
@Override
public <T> void deleteAsynchronously(List<T> entities, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
Assert.notNull(optionsByName);
doBatchDelete(tableName, entities, optionsByName, true);
deleteAsynchronously(entities, tableName, null);
}
/* (non-Javadoc)
@@ -313,7 +248,10 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> void deleteAsynchronously(List<T> entities, String tableName, QueryOptions options) {
deleteAsynchronously(entities, tableName, options.toMap());
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
doBatchDelete(tableName, entities, options, true);
}
/* (non-Javadoc)
@@ -326,16 +264,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
deleteAsynchronously(entity, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#deleteAsynchronously(java.lang.Object, java.util.Map)
*/
@Override
public <T> void deleteAsynchronously(T entity, Map<String, Object> optionsByName) {
String tableName = getTableName(entity.getClass());
Assert.notNull(tableName);
deleteAsynchronously(entity, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#deleteAsynchronously(java.lang.Object, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -351,19 +279,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> void deleteAsynchronously(T entity, String tableName) {
deleteAsynchronously(entity, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#deleteAsynchronously(java.lang.Object, java.lang.String, java.util.Map)
*/
@Override
public <T> void deleteAsynchronously(T entity, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entity);
Assert.notNull(tableName);
Assert.notNull(optionsByName);
doDelete(tableName, entity, optionsByName, true);
deleteAsynchronously(entity, tableName, null);
}
/* (non-Javadoc)
@@ -371,7 +287,9 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> void deleteAsynchronously(T entity, String tableName, QueryOptions options) {
deleteAsynchronously(entity, tableName, options.toMap());
Assert.notNull(entity);
Assert.notNull(tableName);
doDelete(tableName, entity, options, true);
}
/**
@@ -419,16 +337,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
return insert(entities, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insert(java.util.List, java.util.Map)
*/
@Override
public <T> List<T> insert(List<T> entities, Map<String, Object> optionsByName) {
String tableName = getTableName(entities.get(0).getClass());
Assert.notNull(tableName);
return insert(entities, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insert(java.util.List, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -444,20 +352,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> List<T> insert(List<T> entities, String tableName) {
return insert(entities, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insert(java.util.List, java.lang.String, java.util.Map)
*/
@Override
public <T> List<T> insert(List<T> entities, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
Assert.notNull(optionsByName);
return doBatchInsert(tableName, entities, optionsByName, false);
return insert(entities, tableName, null);
}
/* (non-Javadoc)
@@ -465,7 +360,10 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> List<T> insert(List<T> entities, String tableName, QueryOptions options) {
return insert(entities, tableName, options.toMap());
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
return doBatchInsert(tableName, entities, options, false);
}
/* (non-Javadoc)
@@ -478,16 +376,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
return insert(entity, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insert(java.lang.Object, java.util.Map)
*/
@Override
public <T> T insert(T entity, Map<String, Object> optionsByName) {
String tableName = determineTableName(entity);
Assert.notNull(tableName);
return insert(entity, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insert(java.lang.Object, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -503,19 +391,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> T insert(T entity, String tableName) {
return insert(entity, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insert(java.lang.Object, java.lang.String, java.util.Map)
*/
@Override
public <T> T insert(T entity, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entity);
Assert.notNull(tableName);
ensureNotIterable(entity);
return doInsert(tableName, entity, optionsByName, false);
return insert(entity, tableName, null);
}
/* (non-Javadoc)
@@ -523,7 +399,10 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> T insert(T entity, String tableName, QueryOptions options) {
return insert(entity, tableName, options.toMap());
Assert.notNull(entity);
Assert.notNull(tableName);
ensureNotIterable(entity);
return doInsert(tableName, entity, options, false);
}
/* (non-Javadoc)
@@ -536,16 +415,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
return insertAsynchronously(entities, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insertAsynchronously(java.util.List, java.util.Map)
*/
@Override
public <T> List<T> insertAsynchronously(List<T> entities, Map<String, Object> optionsByName) {
String tableName = getTableName(entities.get(0).getClass());
Assert.notNull(tableName);
return insertAsynchronously(entities, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insertAsynchronously(java.util.List, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -561,20 +430,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> List<T> insertAsynchronously(List<T> entities, String tableName) {
return insertAsynchronously(entities, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insertAsynchronously(java.util.List, java.lang.String, java.util.Map)
*/
@Override
public <T> List<T> insertAsynchronously(List<T> entities, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
Assert.notNull(optionsByName);
return doBatchInsert(tableName, entities, optionsByName, true);
return insertAsynchronously(entities, tableName, null);
}
/* (non-Javadoc)
@@ -582,7 +438,10 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> List<T> insertAsynchronously(List<T> entities, String tableName, QueryOptions options) {
return insertAsynchronously(entities, tableName, options.toMap());
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
return doBatchInsert(tableName, entities, options, true);
}
/* (non-Javadoc)
@@ -595,16 +454,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
return insertAsynchronously(entity, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insertAsynchronously(java.lang.Object, java.util.Map)
*/
@Override
public <T> T insertAsynchronously(T entity, Map<String, Object> optionsByName) {
String tableName = determineTableName(entity);
Assert.notNull(tableName);
return insertAsynchronously(entity, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insertAsynchronously(java.lang.Object, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -620,22 +469,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> T insertAsynchronously(T entity, String tableName) {
return insertAsynchronously(entity, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#insertAsynchronously(java.lang.Object, java.lang.String, java.util.Map)
*/
@Override
public <T> T insertAsynchronously(T entity, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entity);
Assert.notNull(tableName);
Assert.notNull(optionsByName);
ensureNotIterable(entity);
return doInsert(tableName, entity, optionsByName, true);
return insertAsynchronously(entity, tableName, null);
}
/* (non-Javadoc)
@@ -643,7 +477,12 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> T insertAsynchronously(T entity, String tableName, QueryOptions options) {
return insertAsynchronously(entity, tableName, options.toMap());
Assert.notNull(entity);
Assert.notNull(tableName);
ensureNotIterable(entity);
return doInsert(tableName, entity, options, true);
}
/* (non-Javadoc)
@@ -688,16 +527,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
return update(entities, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#update(java.util.List, java.util.Map)
*/
@Override
public <T> List<T> update(List<T> entities, Map<String, Object> optionsByName) {
String tableName = getTableName(entities.get(0).getClass());
Assert.notNull(tableName);
return update(entities, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#update(java.util.List, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -713,20 +542,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> List<T> update(List<T> entities, String tableName) {
return update(entities, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#update(java.util.List, java.lang.String, java.util.Map)
*/
@Override
public <T> List<T> update(List<T> entities, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
Assert.notNull(optionsByName);
return doBatchUpdate(tableName, entities, optionsByName, false);
return update(entities, tableName, null);
}
/* (non-Javadoc)
@@ -734,7 +550,10 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> List<T> update(List<T> entities, String tableName, QueryOptions options) {
return update(entities, tableName, options.toMap());
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
return doBatchUpdate(tableName, entities, options, false);
}
/* (non-Javadoc)
@@ -747,16 +566,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
return update(entity, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#update(java.lang.Object, java.util.Map)
*/
@Override
public <T> T update(T entity, Map<String, Object> optionsByName) {
String tableName = getTableName(entity.getClass());
Assert.notNull(tableName);
return update(entity, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#update(java.lang.Object, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -772,19 +581,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> T update(T entity, String tableName) {
return update(entity, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#update(java.lang.Object, java.lang.String, java.util.Map)
*/
@Override
public <T> T update(T entity, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entity);
Assert.notNull(tableName);
Assert.notNull(optionsByName);
return doUpdate(tableName, entity, optionsByName, false);
return update(entity, tableName, null);
}
/* (non-Javadoc)
@@ -792,7 +589,9 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> T update(T entity, String tableName, QueryOptions options) {
return update(entity, tableName, options.toMap());
Assert.notNull(entity);
Assert.notNull(tableName);
return doUpdate(tableName, entity, options, false);
}
/* (non-Javadoc)
@@ -805,16 +604,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
return updateAsynchronously(entities, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#updateAsynchronously(java.util.List, java.util.Map)
*/
@Override
public <T> List<T> updateAsynchronously(List<T> entities, Map<String, Object> optionsByName) {
String tableName = getTableName(entities.get(0).getClass());
Assert.notNull(tableName);
return updateAsynchronously(entities, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#updateAsynchronously(java.util.List, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -830,20 +619,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> List<T> updateAsynchronously(List<T> entities, String tableName) {
return updateAsynchronously(entities, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#updateAsynchronously(java.util.List, java.lang.String, java.util.Map)
*/
@Override
public <T> List<T> updateAsynchronously(List<T> entities, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
Assert.notNull(optionsByName);
return doBatchUpdate(tableName, entities, optionsByName, true);
return updateAsynchronously(entities, tableName, null);
}
/* (non-Javadoc)
@@ -851,7 +627,10 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> List<T> updateAsynchronously(List<T> entities, String tableName, QueryOptions options) {
return updateAsynchronously(entities, tableName, options.toMap());
Assert.notNull(entities);
Assert.notEmpty(entities);
Assert.notNull(tableName);
return doBatchUpdate(tableName, entities, options, true);
}
/* (non-Javadoc)
@@ -864,16 +643,6 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
return updateAsynchronously(entity, tableName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#updateAsynchronously(java.lang.Object, java.util.Map)
*/
@Override
public <T> T updateAsynchronously(T entity, Map<String, Object> optionsByName) {
String tableName = getTableName(entity.getClass());
Assert.notNull(tableName);
return updateAsynchronously(entity, tableName, optionsByName);
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#updateAsynchronously(java.lang.Object, org.springframework.data.cassandra.core.QueryOptions)
*/
@@ -890,18 +659,7 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
@Override
public <T> T updateAsynchronously(T entity, String tableName) {
return updateAsynchronously(entity, tableName, Collections.<String, Object> emptyMap());
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.core.CassandraOperations#updateAsynchronously(java.lang.Object, java.lang.String, java.util.Map)
*/
@Override
public <T> T updateAsynchronously(T entity, String tableName, Map<String, Object> optionsByName) {
Assert.notNull(entity);
Assert.notNull(tableName);
Assert.notNull(optionsByName);
return doUpdate(tableName, entity, optionsByName, true);
return updateAsynchronously(entity, tableName, null);
}
/* (non-Javadoc)
@@ -909,7 +667,9 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
*/
@Override
public <T> T updateAsynchronously(T entity, String tableName, QueryOptions options) {
return updateAsynchronously(entity, tableName, options.toMap());
Assert.notNull(entity);
Assert.notNull(tableName);
return doUpdate(tableName, entity, options, true);
}
/**
@@ -1026,14 +786,14 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
* @param tableName
* @param objectToRemove
*/
protected <T> void doBatchDelete(final String tableName, final List<T> entities, Map<String, Object> optionsByName,
protected <T> void doBatchDelete(final String tableName, final List<T> entities, final QueryOptions options,
final boolean deleteAsynchronously) {
Assert.notEmpty(entities);
try {
final Batch b = CqlUtils.toDeleteBatchQuery(keyspace, tableName, entities, optionsByName, cassandraConverter);
final Batch b = CqlUtils.toDeleteBatchQuery(keyspace, tableName, entities, options, cassandraConverter);
logger.info(b.toString());
doExecute(new SessionCallback<Object>() {
@@ -1067,14 +827,14 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
* @param insertAsychronously
* @return
*/
protected <T> List<T> doBatchInsert(final String tableName, final List<T> entities,
Map<String, Object> optionsByName, final boolean insertAsychronously) {
protected <T> List<T> doBatchInsert(final String tableName, final List<T> entities, final QueryOptions options,
final boolean insertAsychronously) {
Assert.notEmpty(entities);
try {
final Batch b = CqlUtils.toInsertBatchQuery(keyspace, tableName, entities, optionsByName, cassandraConverter);
final Batch b = CqlUtils.toInsertBatchQuery(keyspace, tableName, entities, options, cassandraConverter);
logger.info(b.getQueryString());
return doExecute(new SessionCallback<List<T>>() {
@@ -1108,14 +868,14 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
* @param updateAsychronously
* @return
*/
protected <T> List<T> doBatchUpdate(final String tableName, final List<T> entities,
Map<String, Object> optionsByName, final boolean updateAsychronously) {
protected <T> List<T> doBatchUpdate(final String tableName, final List<T> entities, final QueryOptions options,
final boolean updateAsychronously) {
Assert.notEmpty(entities);
try {
final Batch b = CqlUtils.toUpdateBatchQuery(keyspace, tableName, entities, optionsByName, cassandraConverter);
final Batch b = CqlUtils.toUpdateBatchQuery(keyspace, tableName, entities, options, cassandraConverter);
logger.info(b.toString());
return doExecute(new SessionCallback<List<T>>() {
@@ -1146,12 +906,12 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
* @param tableName
* @param objectToRemove
*/
protected <T> void doDelete(final String tableName, final T objectToRemove, Map<String, Object> optionsByName,
protected <T> void doDelete(final String tableName, final T objectToRemove, final QueryOptions options,
final boolean deleteAsynchronously) {
try {
final Query q = CqlUtils.toDeleteQuery(keyspace, tableName, objectToRemove, optionsByName, cassandraConverter);
final Query q = CqlUtils.toDeleteQuery(keyspace, tableName, objectToRemove, options, cassandraConverter);
logger.info(q.toString());
doExecute(new SessionCallback<Object>() {
@@ -1201,12 +961,12 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
* @param tableName
* @param entity
*/
protected <T> T doInsert(final String tableName, final T entity, final Map<String, Object> optionsByName,
protected <T> T doInsert(final String tableName, final T entity, final QueryOptions options,
final boolean insertAsychronously) {
try {
final Query q = CqlUtils.toInsertQuery(keyspace, tableName, entity, optionsByName, cassandraConverter);
final Query q = CqlUtils.toInsertQuery(keyspace, tableName, entity, options, cassandraConverter);
logger.info(q.toString());
if (q.getConsistencyLevel() != null) {
@@ -1248,12 +1008,12 @@ public class CassandraDataTemplate extends CassandraTemplate implements Cassandr
* @param updateAsychronously
* @return
*/
protected <T> T doUpdate(final String tableName, final T entity, final Map<String, Object> optionsByName,
protected <T> T doUpdate(final String tableName, final T entity, final QueryOptions options,
final boolean updateAsychronously) {
try {
final Query q = CqlUtils.toUpdateQuery(keyspace, tableName, entity, optionsByName, cassandraConverter);
final Query q = CqlUtils.toUpdateQuery(keyspace, tableName, entity, options, cassandraConverter);
logger.info(q.toString());
return doExecute(new SessionCallback<T>() {

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

@@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.cassandra.core;
package org.springframework.data.cassandra.core;
import com.datastax.driver.core.Session;

1
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/SpringDataKeyspace.java
View File

@@ -1,6 +1,5 @@
package org.springframework.data.cassandra.core;
import org.springframework.cassandra.core.Keyspace;
import org.springframework.data.cassandra.convert.CassandraConverter;
import org.springframework.util.Assert;

78
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/util/CqlUtils.java
View File

@@ -2,15 +2,11 @@ package org.springframework.data.cassandra.util;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cassandra.core.ConsistencyLevel;
import org.springframework.cassandra.core.ConsistencyLevelResolver;
import org.springframework.cassandra.core.CassandraTemplate;
import org.springframework.cassandra.core.QueryOptions;
import org.springframework.cassandra.core.RetryPolicy;
import org.springframework.cassandra.core.RetryPolicyResolver;
import org.springframework.cassandra.core.cql.generator.CreateTableCqlGenerator;
import org.springframework.cassandra.core.keyspace.CreateTableSpecification;
import org.springframework.data.cassandra.convert.CassandraConverter;
@@ -155,7 +151,7 @@ public abstract class CqlUtils {
* @throws EntityWriterException
*/
public static Query toInsertQuery(String keyspaceName, String tableName, final Object objectToSave,
Map<String, Object> optionsByName, EntityWriter<Object, Object> entityWriter) throws EntityWriterException {
QueryOptions options, EntityWriter<Object, Object> entityWriter) throws EntityWriterException {
final Insert q = QueryBuilder.insertInto(keyspaceName, tableName);
@@ -167,13 +163,13 @@ public abstract class CqlUtils {
/*
* Add Query Options
*/
addQueryOptions(q, optionsByName);
CassandraTemplate.addQueryOptions(q, options);
/*
* Add TTL to Insert object
*/
if (optionsByName.get(QueryOptions.QueryOptionMapKeys.TTL) != null) {
q.using(QueryBuilder.ttl((Integer) optionsByName.get(QueryOptions.QueryOptionMapKeys.TTL)));
if (options != null && options.getTtl() != null) {
q.using(QueryBuilder.ttl(options.getTtl()));
}
return q;
@@ -193,7 +189,7 @@ public abstract class CqlUtils {
* @throws EntityWriterException
*/
public static Query toUpdateQuery(String keyspaceName, String tableName, final Object objectToSave,
Map<String, Object> optionsByName, EntityWriter<Object, Object> entityWriter) throws EntityWriterException {
QueryOptions options, EntityWriter<Object, Object> entityWriter) throws EntityWriterException {
final Update q = QueryBuilder.update(keyspaceName, tableName);
@@ -205,13 +201,13 @@ public abstract class CqlUtils {
/*
* Add Query Options
*/
addQueryOptions(q, optionsByName);
CassandraTemplate.addQueryOptions(q, options);
/*
* Add TTL to Insert object
*/
if (optionsByName.get(QueryOptions.QueryOptionMapKeys.TTL) != null) {
q.using(QueryBuilder.ttl((Integer) optionsByName.get(QueryOptions.QueryOptionMapKeys.TTL)));
if (options != null && options.getTtl() != null) {
q.using(QueryBuilder.ttl(options.getTtl()));
}
return q;
@@ -231,7 +227,7 @@ public abstract class CqlUtils {
* @throws EntityWriterException
*/
public static <T> Batch toUpdateBatchQuery(final String keyspaceName, final String tableName,
final List<T> objectsToSave, Map<String, Object> optionsByName, EntityWriter<Object, Object> entityWriter)
final List<T> objectsToSave, QueryOptions options, EntityWriter<Object, Object> entityWriter)
throws EntityWriterException {
/*
@@ -241,11 +237,14 @@ public abstract class CqlUtils {
for (final T objectToSave : objectsToSave) {
b.add((Statement) toUpdateQuery(keyspaceName, tableName, objectToSave, optionsByName, entityWriter));
b.add((Statement) toUpdateQuery(keyspaceName, tableName, objectToSave, options, entityWriter));
}
addQueryOptions(b, optionsByName);
/*
* Add Query Options
*/
CassandraTemplate.addQueryOptions(b, options);
return b;
@@ -264,7 +263,7 @@ public abstract class CqlUtils {
* @throws EntityWriterException
*/
public static <T> Batch toInsertBatchQuery(final String keyspaceName, final String tableName,
final List<T> objectsToSave, Map<String, Object> optionsByName, EntityWriter<Object, Object> entityWriter)
final List<T> objectsToSave, QueryOptions options, EntityWriter<Object, Object> entityWriter)
throws EntityWriterException {
/*
@@ -274,11 +273,14 @@ public abstract class CqlUtils {
for (final T objectToSave : objectsToSave) {
b.add((Statement) toInsertQuery(keyspaceName, tableName, objectToSave, optionsByName, entityWriter));
b.add((Statement) toInsertQuery(keyspaceName, tableName, objectToSave, options, entityWriter));
}
addQueryOptions(b, optionsByName);
/*
* Add Query Options
*/
CassandraTemplate.addQueryOptions(b, options);
return b;
@@ -296,7 +298,7 @@ public abstract class CqlUtils {
* @throws EntityWriterException
*/
public static Query toDeleteQuery(String keyspace, String tableName, final Object objectToRemove,
Map<String, Object> optionsByName, EntityWriter<Object, Object> entityWriter) throws EntityWriterException {
QueryOptions options, EntityWriter<Object, Object> entityWriter) throws EntityWriterException {
final Delete.Selection ds = QueryBuilder.delete();
final Delete q = ds.from(keyspace, tableName);
@@ -307,7 +309,7 @@ public abstract class CqlUtils {
*/
entityWriter.write(objectToRemove, w);
addQueryOptions(q, optionsByName);
CassandraTemplate.addQueryOptions(q, options);
return q;
@@ -353,7 +355,7 @@ public abstract class CqlUtils {
/**
* Create a Batch Query object for multiple deletes.
*
* @param keyspace
* @param keyspaceName
* @param tableName
* @param entities
* @param entity
@@ -363,7 +365,7 @@ public abstract class CqlUtils {
* @throws EntityWriterException
*/
public static <T> Batch toDeleteBatchQuery(String keyspaceName, String tableName, List<T> entities,
Map<String, Object> optionsByName, EntityWriter<Object, Object> entityWriter) throws EntityWriterException {
QueryOptions options, EntityWriter<Object, Object> entityWriter) throws EntityWriterException {
/*
* Return variable is a Batch statement
@@ -372,40 +374,14 @@ public abstract class CqlUtils {
for (final T objectToSave : entities) {
b.add((Statement) toDeleteQuery(keyspaceName, tableName, objectToSave, optionsByName, entityWriter));
b.add((Statement) toDeleteQuery(keyspaceName, tableName, objectToSave, options, entityWriter));
}
addQueryOptions(b, optionsByName);
CassandraTemplate.addQueryOptions(b, options);
return b;
}
/**
* Add common Query options for all types of queries.
*
* @param q
* @param optionsByName
*/
private static void addQueryOptions(Query q, Map<String, Object> optionsByName) {
if (optionsByName == null) {
return;
}
/*
* Add Query Options
*/
if (optionsByName.get(QueryOptions.QueryOptionMapKeys.CONSISTENCY_LEVEL) != null) {
q.setConsistencyLevel(ConsistencyLevelResolver.resolve((ConsistencyLevel) optionsByName
.get(QueryOptions.QueryOptionMapKeys.CONSISTENCY_LEVEL)));
}
if (optionsByName.get(QueryOptions.QueryOptionMapKeys.RETRY_POLICY) != null) {
q.setRetryPolicy(RetryPolicyResolver.resolve((RetryPolicy) optionsByName
.get(QueryOptions.QueryOptionMapKeys.RETRY_POLICY)));
}
}
}

2
spring-data-cassandra/src/main/resources/META-INF/spring.tooling
View File

@@ -1,4 +1,4 @@
# Tooling related information for the cassandra namespace
http\://www.springframework.org/schema/data/cassandra@name=Cassandra Namespace
http\://www.springframework.org/schema/data/cassandra@name=Spring Data Cassandra Namespace
http\://www.springframework.org/schema/data/cassandra@prefix=cassandra
http\://www.springframework.org/schema/data/cassandra@icon=org/springframework/data/cassandra/config/spring-cassandra.gif

418
spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/spring-cassandra-1.0.xsd
View File

@@ -1,244 +1,37 @@
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.springframework.org/schema/data/cassandra"
xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tool="http://www.springframework.org/schema/tool"
xmlns:base="http://www.springframework.org/schema/cassandra" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tool="http://www.springframework.org/schema/tool"
targetNamespace="http://www.springframework.org/schema/data/cassandra"
elementFormDefault="qualified" attributeFormDefault="unqualified">
<xsd:import namespace="http://www.springframework.org/schema/tool"
schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd" />
<xsd:import namespace="http://www.springframework.org/schema/cassandra"
schemaLocation="http://www.springframework.org/schema/cassandra/spring-cassandra.xsd" />
<xsd:annotation>
<xsd:documentation><![CDATA[
Defines the configuration elements for the Spring Data Cassandra support.
Defines the configuration elements for Spring Data Cassandra support.
]]></xsd:documentation>
</xsd:annotation>
<xsd:element name="session" type="sessionType">
<xsd:annotation>
<xsd:documentation
source="org.springframework.cassandra.core.SessionFactoryBean"><![CDATA[
Defines a Cassandra Session instance used for accessing Cassandra Keyspace'.
]]></xsd:documentation>
<xsd:appinfo>
<tool:annotation>
<tool:exports type="com.datastax.driver.core.Session" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
</xsd:element>
<xsd:element name="session" type="base:sessionType" />
<xsd:element name="cluster" type="clusterType">
<xsd:annotation>
<xsd:documentation
source="org.springframework.data.cassandra.core.CassandraClusterFactoryBean"><![CDATA[
Defines a Cassandra Cluster instance used for accessing Cassandra'.
]]></xsd:documentation>
<xsd:appinfo>
<tool:annotation>
<tool:exports type="com.datastax.driver.core.Cluster" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
</xsd:element>
<xsd:element name="cluster" type="base:clusterType" />
<xsd:complexType name="clusterType">
<xsd:sequence>
<xsd:element name="local-pooling-options" type="poolingOptionsType"
maxOccurs="1" minOccurs="0">
</xsd:element>
<xsd:element name="remote-pooling-options" type="poolingOptionsType"
maxOccurs="1" minOccurs="0">
</xsd:element>
<xsd:element name="socket-options" type="socketOptionsType"
maxOccurs="1" minOccurs="0"></xsd:element>
</xsd:sequence>
<xsd:attribute name="id" type="xsd:ID" use="optional">
<xsd:annotation>
<xsd:documentation>
The name of the Cassandra Cluster definition (by
default "cassandra-cluster")
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="contactPoints" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
The comma separated hosts to Cassandra servers. Default is localhost
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="port" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
The port to connect to Cassandra server as native CQL client. Default is 9042
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="compression" default="NONE" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
The protocol options compression. Default is 'none'.
]]></xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="NONE">
<xsd:annotation>
<xsd:documentation><![CDATA[
No compression.
]]></xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="SNAPPY">
<xsd:annotation>
<xsd:documentation><![CDATA[
Uses SNAPPY compression algorithm.
]]></xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="auth-info-provider" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
AuthInfoProvider implementation.
]]></xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to type="com.datastax.driver.core.AuthInfoProvider" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="load-balancing-policy" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
LoadBalancingPolicy implementation.
]]></xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to
type="com.datastax.driver.core.policies.LoadBalancingPolicy" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="reconnection-policy" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
ReconnectionPolicy implementation.
]]></xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to
type="com.datastax.driver.core.policies.ReconnectionPolicy" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="retry-policy" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
RetryPolicy implementation.
]]></xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to
type="com.datastax.driver.core.policies.RetryPolicy" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="keyspace" type="base:keyspaceType" />
<xsd:element name="keyspace" type="keyspaceType">
<xsd:annotation>
<xsd:documentation
source="org.springframework.data.cassandra.core.CassandraKeyspaceFactoryBean"><![CDATA[
Defines a Cassandra Session instance used for accessing Cassandra Keyspace'.
]]></xsd:documentation>
<xsd:appinfo>
<tool:annotation>
<tool:exports type="com.datastax.driver.core.Session" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
</xsd:element>
<xsd:element name="local-pooling-options" type="base:poolingOptionsType" />
<xsd:complexType name="keyspaceType">
<xsd:sequence>
<xsd:element name="keyspace-attributes" type="keyspaceAttributesType"
maxOccurs="1" minOccurs="0"></xsd:element>
</xsd:sequence>
<xsd:attribute name="id" type="xsd:ID" use="optional">
<xsd:annotation>
<xsd:documentation>
The name of the Keyspace definition (by default
"cassandra-keyspace")
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="name" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
The keyspace name of the Cassandra database.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="cassandra-cluster-ref" type="clusterRef"
use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
The reference to a Cassandra Cluster instance. Will default to 'cassandra-cluster'.
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="cassandra-converter-ref" type="converterRef"
use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[
The reference to a CassandraConverter instance. Default is null.
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="remote-pooling-options" type="base:poolingOptionsType" />
<xsd:simpleType name="clusterRef" final="union">
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to type="com.datastax.driver.core.Cluster" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
<xsd:element name="socket-options" type="base:socketOptionsType" />
<xsd:element name="keyspace-attributes" type="base:keyspaceAttributesType" />
<xsd:simpleType name="converterRef">
<xsd:annotation>
<xsd:appinfo>
@@ -251,159 +44,6 @@ The reference to a CassandraConverter instance. Default is null.
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
<xsd:complexType name="poolingOptionsType">
<xsd:attribute name="min-simultaneous-requests" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
if the utilisation of opened connections drops below by this configured threshold, then cassandra drops connections till core-connections.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="max-simultaneous-requests" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
If the utilisation of connections reaches this configurable threshold, then cassandra creates more connections up to max-connections.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="core-connections" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
For each host, the driver keeps a core amount of connections open at all time.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="max-connections" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
More connections are created up to a configurable maximum number of connections.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="socketOptionsType">
<xsd:attribute name="connect-timeout-mls" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets connection timeout for client socket in milliseconds.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="keep-alive" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_KEEPALIVE socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="reuse-address" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_REUSEADDR socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="so-linger" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_LINGER socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="tcp-no-delay" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_TCPNODELAY socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="receive-buffer-size" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_RCVBUF socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="send-buffer-size" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[
Sets the SO_SNDBUF socket option.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="keyspaceAttributesType">
<xsd:sequence>
<xsd:element name="table" type="tableType" maxOccurs="unbounded"
minOccurs="0"></xsd:element>
</xsd:sequence>
<xsd:attribute name="auto" default="validate">
<xsd:annotation>
<xsd:documentation><![CDATA[
The keyspace manipulation operation on startup. Default value is 'validate'.
]]></xsd:documentation>
</xsd:annotation>
<xsd:simpleType>
<xsd:restriction base="xsd:string">
<xsd:enumeration value="validate">
<xsd:annotation>
<xsd:documentation><![CDATA[
Validate the keyspace, makes no changes.
]]></xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="update">
<xsd:annotation>
<xsd:documentation><![CDATA[
Update the keyspace.
]]></xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="create">
<xsd:annotation>
<xsd:documentation><![CDATA[
Creates the keyspace, destroying previous data.
]]></xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
<xsd:enumeration value="create-drop">
<xsd:annotation>
<xsd:documentation><![CDATA[
Creates and then drop the keyspace at the end of the session.
]]></xsd:documentation>
</xsd:annotation>
</xsd:enumeration>
</xsd:restriction>
</xsd:simpleType>
</xsd:attribute>
<xsd:attribute name="replication-stategy" type="xsd:string"
use="optional" default="SimpleStrategy">
<xsd:annotation>
<xsd:documentation><![CDATA[
Replication strategy of the Cassandra keyspace. Default value is 'SimpleStrategy'.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="replication-factor" type="xsd:string"
use="optional" default="1">
<xsd:annotation>
<xsd:documentation><![CDATA[
Replication factor used by the Cassandra keyspace. Default value is '1'.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="durable-writes" type="xsd:string"
use="optional" default="true">
<xsd:annotation>
<xsd:documentation><![CDATA[
Support durable writes in the Cassandra keyspace. Default value is 'true'.
]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="tableType">
<xsd:attribute name="entity" type="xsd:string">
<xsd:annotation>
@@ -421,34 +61,4 @@ Table name override.
</xsd:attribute>
</xsd:complexType>
<xsd:complexType name="sessionType">
<xsd:attribute name="id" type="xsd:ID" use="optional">
<xsd:annotation>
<xsd:documentation>
The name of the Session definition (by default
"cassandra-session")
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="cassandra-keyspace-ref" type="keyspaceRef"
use="required">
<xsd:annotation>
<xsd:documentation><![CDATA[
The reference to a Cassandra Keyspace instance. Will default to 'cassandra-keyspace'.
]]>
</xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:simpleType name="keyspaceRef">
<xsd:annotation>
<xsd:appinfo>
<tool:annotation kind="ref">
<tool:assignable-to type="com.datastax.driver.core.Session" />
</tool:annotation>
</xsd:appinfo>
</xsd:annotation>
<xsd:union memberTypes="xsd:string" />
</xsd:simpleType>
</xsd:schema>

12
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/CassandraNamespaceTests.java
View File

@@ -8,19 +8,15 @@ import org.cassandraunit.utils.EmbeddedCassandraServerHelper;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.cassandra.core.SpringDataKeyspace;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.data.cassandra.core.SpringDataKeyspace;
import org.springframework.util.Assert;
import com.datastax.driver.core.Cluster;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
// @RunWith(SpringJUnit4ClassRunner.class)
// @ContextConfiguration
public class CassandraNamespaceTests {
@Autowired
@@ -32,7 +28,7 @@ public class CassandraNamespaceTests {
EmbeddedCassandraServerHelper.startEmbeddedCassandra("cassandra.yaml");
}
@Test
// @Test
public void testSingleton() throws Exception {
Object cluster = ctx.getBean("cassandra-cluster");
Assert.notNull(cluster);

29
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/TestConfig.java
View File

@@ -1,14 +1,14 @@
package org.springframework.data.cassandra.test.integration.config;
import org.springframework.cassandra.config.CassandraSessionFactoryBean;
import org.springframework.cassandra.core.CassandraOperations;
import org.springframework.cassandra.core.CassandraTemplate;
import org.springframework.cassandra.core.SessionFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.cassandra.config.AbstractCassandraConfiguration;
import org.springframework.data.cassandra.config.AbstractSpringDataCassandraConfiguration;
import org.springframework.data.cassandra.config.CassandraKeyspaceFactoryBean;
import org.springframework.data.cassandra.core.CassandraDataOperations;
import org.springframework.data.cassandra.core.CassandraDataTemplate;
import org.springframework.data.cassandra.core.CassandraKeyspaceFactoryBean;
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Cluster.Builder;
@@ -17,30 +17,24 @@ import com.datastax.driver.core.Cluster.Builder;
* Setup any spring configuration for unit tests
*
* @author David Webb
*
* @author Matthew T. Adams
*/
@Configuration
public class TestConfig extends AbstractCassandraConfiguration {
public class TestConfig extends AbstractSpringDataCassandraConfiguration {
public static final String keyspace = "test";
public static final String keyspaceName = "test";
/* (non-Javadoc)
* @see org.springframework.data.cassandra.config.AbstractCassandraConfiguration#getKeyspaceName()
*/
@Override
protected String getKeyspaceName() {
return keyspace;
return keyspaceName;
}
/* (non-Javadoc)
* @see org.springframework.data.cassandra.config.AbstractCassandraConfiguration#cluster()
*/
@Override
@Bean
public Cluster cluster() {
Builder builder = Cluster.builder();
builder.addContactPoint("127.0.0.1");
builder.addContactPoint("127.0.0.1").withPort(9042);
return builder.build();
}
@@ -52,15 +46,14 @@ public class TestConfig extends AbstractCassandraConfiguration {
bean.setKeyspace("test");
return bean;
}
@Bean
public SessionFactoryBean sessionFactoryBean() {
public CassandraSessionFactoryBean sessionFactoryBean() {
SessionFactoryBean bean = new SessionFactoryBean(keyspaceFactoryBean().getObject());
CassandraSessionFactoryBean bean = new CassandraSessionFactoryBean();
bean.setCluster(cluster());
return bean;
}
@Bean

18
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/repository/UserRepositoryIntegrationTests.java
View File

@@ -32,13 +32,9 @@ import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.cassandra.core.CassandraDataOperations;
import org.springframework.data.cassandra.test.integration.table.User;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.google.common.collect.Lists;
@@ -48,8 +44,8 @@ import com.google.common.collect.Lists;
* @author Alex Shvid
*
*/
@ContextConfiguration
@RunWith(SpringJUnit4ClassRunner.class)
// @ContextConfiguration
// @RunWith(SpringJUnit4ClassRunner.class)
public class UserRepositoryIntegrationTests {
@Autowired
@@ -104,7 +100,7 @@ public class UserRepositoryIntegrationTests {
all = dataOperations.insert(Arrays.asList(tom, bob, alice, scott));
}
@Test
// @Test
public void findsUserById() throws Exception {
User user = repository.findOne(bob.getUsername());
@@ -113,7 +109,7 @@ public class UserRepositoryIntegrationTests {
}
@Test
// @Test
public void findsAll() throws Exception {
List<User> result = Lists.newArrayList(repository.findAll());
assertThat(result.size(), is(all.size()));
@@ -121,7 +117,7 @@ public class UserRepositoryIntegrationTests {
}
@Test
// @Test
public void findsAllWithGivenIds() {
Iterable<User> result = repository.findAll(Arrays.asList(bob.getUsername(), tom.getUsername()));
@@ -129,7 +125,7 @@ public class UserRepositoryIntegrationTests {
assertThat(result, not(hasItems(alice, scott)));
}
@Test
// @Test
public void deletesUserCorrectly() throws Exception {
repository.delete(tom);
@@ -140,7 +136,7 @@ public class UserRepositoryIntegrationTests {
assertThat(result, not(hasItem(tom)));
}
@Test
// @Test
public void deletesUserByIdCorrectly() {
repository.delete(tom.getUsername().toString());

195
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/template/CassandraDataOperationsTest.java
View File

@@ -22,8 +22,6 @@ import java.util.List;
import java.util.Map;
import java.util.UUID;
import junit.framework.Assert;
import org.apache.cassandra.exceptions.ConfigurationException;
import org.apache.thrift.transport.TTransportException;
import org.cassandraunit.CassandraCQLUnit;
@@ -33,6 +31,7 @@ import org.cassandraunit.dataset.yaml.ClassPathYamlDataSet;
import org.cassandraunit.utils.EmbeddedCassandraServerHelper;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
@@ -128,22 +127,6 @@ public class CassandraDataOperationsTest {
cassandraDataTemplate.insert(b3, "book", options);
/*
* Test Single Insert with entity
*/
Book b4 = new Book();
b4.setIsbn("123456-4");
b4.setTitle("Spring Data Cassandra Guide");
b4.setAuthor("Cassandra Guru");
b4.setPages(465);
Map<String, Object> optionsByName = new HashMap<String, Object>();
optionsByName.put(QueryOptions.QueryOptionMapKeys.CONSISTENCY_LEVEL, ConsistencyLevel.ALL);
optionsByName.put(QueryOptions.QueryOptionMapKeys.RETRY_POLICY, RetryPolicy.FALLTHROUGH);
optionsByName.put(QueryOptions.QueryOptionMapKeys.TTL, 30);
cassandraDataTemplate.insert(b4, "book", optionsByName);
/*
* Test Single Insert with entity
*/
@@ -155,17 +138,6 @@ public class CassandraDataOperationsTest {
cassandraDataTemplate.insert(b5, options);
/*
* Test Single Insert with entity
*/
Book b6 = new Book();
b6.setIsbn("123456-6");
b6.setTitle("Spring Data Cassandra Guide");
b6.setAuthor("Cassandra Guru");
b6.setPages(465);
cassandraDataTemplate.insert(b6, optionsByName);
}
@Test
@@ -214,13 +186,6 @@ public class CassandraDataOperationsTest {
b4.setAuthor("Cassandra Guru");
b4.setPages(465);
Map<String, Object> optionsByName = new HashMap<String, Object>();
optionsByName.put(QueryOptions.QueryOptionMapKeys.CONSISTENCY_LEVEL, ConsistencyLevel.ALL);
optionsByName.put(QueryOptions.QueryOptionMapKeys.RETRY_POLICY, RetryPolicy.FALLTHROUGH);
optionsByName.put(QueryOptions.QueryOptionMapKeys.TTL, 30);
cassandraDataTemplate.insertAsynchronously(b4, "book", optionsByName);
/*
* Test Single Insert with entity
*/
@@ -232,17 +197,6 @@ public class CassandraDataOperationsTest {
cassandraDataTemplate.insertAsynchronously(b5, options);
/*
* Test Single Insert with entity
*/
Book b6 = new Book();
b6.setIsbn("123456-6");
b6.setTitle("Spring Data Cassandra Guide");
b6.setAuthor("Cassandra Guru");
b6.setPages(465);
cassandraDataTemplate.insertAsynchronously(b6, optionsByName);
}
@Test
@@ -273,16 +227,8 @@ public class CassandraDataOperationsTest {
books = getBookList(20);
cassandraDataTemplate.insert(books, "book", optionsByName);
books = getBookList(20);
cassandraDataTemplate.insert(books, options);
books = getBookList(20);
cassandraDataTemplate.insert(books, optionsByName);
}
@Test
@@ -313,16 +259,8 @@ public class CassandraDataOperationsTest {
books = getBookList(20);
cassandraDataTemplate.insertAsynchronously(books, "book", optionsByName);
books = getBookList(20);
cassandraDataTemplate.insertAsynchronously(books, options);
books = getBookList(20);
cassandraDataTemplate.insertAsynchronously(books, optionsByName);
}
/**
@@ -389,17 +327,6 @@ public class CassandraDataOperationsTest {
cassandraDataTemplate.update(b3, "book", options);
/*
* Test Single Insert with entity
*/
Book b4 = new Book();
b4.setIsbn("123456-4");
b4.setTitle("Spring Data Cassandra Book");
b4.setAuthor("Cassandra Guru");
b4.setPages(465);
cassandraDataTemplate.update(b4, "book", optionsByName);
/*
* Test Single Insert with entity
*/
@@ -411,17 +338,6 @@ public class CassandraDataOperationsTest {
cassandraDataTemplate.update(b5, options);
/*
* Test Single Insert with entity
*/
Book b6 = new Book();
b6.setIsbn("123456-6");
b6.setTitle("Spring Data Cassandra Book");
b6.setAuthor("Cassandra Guru");
b6.setPages(465);
cassandraDataTemplate.update(b6, optionsByName);
}
@Test
@@ -468,17 +384,6 @@ public class CassandraDataOperationsTest {
cassandraDataTemplate.updateAsynchronously(b3, "book", options);
/*
* Test Single Insert with entity
*/
Book b4 = new Book();
b4.setIsbn("123456-4");
b4.setTitle("Spring Data Cassandra Book");
b4.setAuthor("Cassandra Guru");
b4.setPages(465);
cassandraDataTemplate.updateAsynchronously(b4, "book", optionsByName);
/*
* Test Single Insert with entity
*/
@@ -490,17 +395,6 @@ public class CassandraDataOperationsTest {
cassandraDataTemplate.updateAsynchronously(b5, options);
/*
* Test Single Insert with entity
*/
Book b6 = new Book();
b6.setIsbn("123456-6");
b6.setTitle("Spring Data Cassandra Book");
b6.setAuthor("Cassandra Guru");
b6.setPages(465);
cassandraDataTemplate.updateAsynchronously(b6, optionsByName);
}
@Test
@@ -543,28 +437,12 @@ public class CassandraDataOperationsTest {
books = getBookList(20);
cassandraDataTemplate.insert(books, "book", optionsByName);
alterBooks(books);
cassandraDataTemplate.update(books, "book", optionsByName);
books = getBookList(20);
cassandraDataTemplate.insert(books, options);
alterBooks(books);
cassandraDataTemplate.update(books, options);
books = getBookList(20);
cassandraDataTemplate.insert(books, optionsByName);
alterBooks(books);
cassandraDataTemplate.update(books, optionsByName);
}
@Test
@@ -607,28 +485,12 @@ public class CassandraDataOperationsTest {
books = getBookList(20);
cassandraDataTemplate.insert(books, "book", optionsByName);
alterBooks(books);
cassandraDataTemplate.updateAsynchronously(books, "book", optionsByName);
books = getBookList(20);
cassandraDataTemplate.insert(books, options);
alterBooks(books);
cassandraDataTemplate.updateAsynchronously(books, options);
books = getBookList(20);
cassandraDataTemplate.insert(books, optionsByName);
alterBooks(books);
cassandraDataTemplate.updateAsynchronously(books, optionsByName);
}
/**
@@ -677,14 +539,6 @@ public class CassandraDataOperationsTest {
cassandraDataTemplate.delete(b3, "book", options);
/*
* Test Single Insert with entity
*/
Book b4 = new Book();
b4.setIsbn("123456-4");
cassandraDataTemplate.delete(b4, "book", optionsByName);
/*
* Test Single Insert with entity
*/
@@ -693,14 +547,6 @@ public class CassandraDataOperationsTest {
cassandraDataTemplate.delete(b5, options);
/*
* Test Single Insert with entity
*/
Book b6 = new Book();
b6.setIsbn("123456-6");
cassandraDataTemplate.delete(b6, optionsByName);
}
@Test
@@ -737,14 +583,6 @@ public class CassandraDataOperationsTest {
cassandraDataTemplate.deleteAsynchronously(b3, "book", options);
/*
* Test Single Insert with entity
*/
Book b4 = new Book();
b4.setIsbn("123456-4");
cassandraDataTemplate.deleteAsynchronously(b4, "book", optionsByName);
/*
* Test Single Insert with entity
*/
@@ -753,13 +591,6 @@ public class CassandraDataOperationsTest {
cassandraDataTemplate.deleteAsynchronously(b5, options);
/*
* Test Single Insert with entity
*/
Book b6 = new Book();
b6.setIsbn("123456-6");
cassandraDataTemplate.deleteAsynchronously(b6, optionsByName);
}
@Test
@@ -796,22 +627,10 @@ public class CassandraDataOperationsTest {
books = getBookList(20);
cassandraDataTemplate.insert(books, "book", optionsByName);
cassandraDataTemplate.delete(books, "book", optionsByName);
books = getBookList(20);
cassandraDataTemplate.insert(books, options);
cassandraDataTemplate.delete(books, options);
books = getBookList(20);
cassandraDataTemplate.insert(books, optionsByName);
cassandraDataTemplate.delete(books, optionsByName);
}
@Test
@@ -848,22 +667,10 @@ public class CassandraDataOperationsTest {
books = getBookList(20);
cassandraDataTemplate.insert(books, "book", optionsByName);
cassandraDataTemplate.deleteAsynchronously(books, "book", optionsByName);
books = getBookList(20);
cassandraDataTemplate.insert(books, options);
cassandraDataTemplate.deleteAsynchronously(books, options);
books = getBookList(20);
cassandraDataTemplate.insert(books, optionsByName);
cassandraDataTemplate.deleteAsynchronously(books, optionsByName);
}
@Test

17
spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/config/CassandraNamespaceTests-context.xml
View File

@@ -1,6 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cassandra="http://www.springframework.org/schema/data/cassandra"
xmlns:cassandra-base="http://www.springframework.org/schema/cassandra"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/data/cassandra http://www.springframework.org/schema/data/cassandra/spring-cassandra-1.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
@@ -12,13 +13,13 @@
<cassandra:cluster id="cassandra-cluster"
contactPoints="${cassandra.contactPoints}" port="${cassandra.port}"
compression="SNAPPY">
<cassandra:local-pooling-options
<cassandra-base:local-pooling-options
min-simultaneous-requests="25" max-simultaneous-requests="100"
core-connections="2" max-connections="8" />
<cassandra:remote-pooling-options
<cassandra-base:remote-pooling-options
min-simultaneous-requests="25" max-simultaneous-requests="100"
core-connections="1" max-connections="2" />
<cassandra:socket-options
<cassandra-base:socket-options
connect-timeout-mls="5000" keep-alive="true" reuse-address="true"
so-linger="60" tcp-no-delay="true" receive-buffer-size="65536"
send-buffer-size="65536" />
@@ -34,7 +35,7 @@
<cassandra:keyspace id="cassandra-keyspace" name="${cassandra.keyspace}"
cassandra-cluster-ref="cassandra-cluster" cassandra-converter-ref="cassandra-converter">
<cassandra:keyspace-attributes auto="update"
<cassandra-base:keyspace-attributes auto="update"
replication-stategy="SimpleStrategy" replication-factor="1"
durable-writes="true">
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.Comment" />
@@ -43,13 +44,11 @@
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.Post" />
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.Timeline" />
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.User" />
</cassandra:keyspace-attributes>
</cassandra-base:keyspace-attributes>
</cassandra:keyspace>
<cassandra:session id="cassandra-session" cassandra-keyspace-ref="cassandra-keyspace"/>
<cassandra:session id="cassandra-session" keyspace-name="${cassandra.keyspace}"/>
<bean id="cassandraTemplate" class="org.springframework.cassandra.core.CassandraTemplate">
<constructor-arg ref="cassandra-session" />
</bean>
<cassandra:template session-ref="cassandra-session"/>
</beans>

11
spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/repository/UserRepositoryIntegrationTests-context.xml
View File

@@ -1,6 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cassandra="http://www.springframework.org/schema/data/cassandra"
xmlns:cassandra-base="http://www.springframework.org/schema/cassandra"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/data/cassandra http://www.springframework.org/schema/data/cassandra/spring-cassandra-1.0.xsd
@@ -14,13 +15,13 @@
<cassandra:cluster id="cassandra-cluster"
contactPoints="${cassandra.contactPoints}" port="${cassandra.port}"
compression="SNAPPY">
<cassandra:local-pooling-options
<cassandra-base:local-pooling-options
min-simultaneous-requests="25" max-simultaneous-requests="100"
core-connections="2" max-connections="8" />
<cassandra:remote-pooling-options
<cassandra-base:remote-pooling-options
min-simultaneous-requests="25" max-simultaneous-requests="100"
core-connections="1" max-connections="2" />
<cassandra:socket-options
<cassandra-base:socket-options
connect-timeout-mls="5000" keep-alive="true" reuse-address="true"
so-linger="60" tcp-no-delay="true" receive-buffer-size="65536"
send-buffer-size="65536" />
@@ -36,7 +37,7 @@
<cassandra:keyspace id="cassandra-keyspace" name="${cassandra.keyspace}"
cassandra-cluster-ref="cassandra-cluster" cassandra-converter-ref="cassandra-converter">
<cassandra:keyspace-attributes auto="update"
<cassandra-base:keyspace-attributes auto="update"
replication-stategy="SimpleStrategy" replication-factor="1"
durable-writes="true">
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.Comment" />
@@ -45,7 +46,7 @@
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.Post" />
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.Timeline" />
<cassandra:table entity="org.springframework.data.cassandra.test.integration.table.User" />
</cassandra:keyspace-attributes>
</cassandra-base:keyspace-attributes>
</cassandra:keyspace>
<cassandra:session id="cassandra-session" cassandra-keyspace-ref="cassandra-keyspace"/>