diff --git a/spring-cql/src/main/java/org/springframework/cassandra/core/cql/generator/AlterUserTypeCqlGenerator.java b/spring-cql/src/main/java/org/springframework/cassandra/core/cql/generator/AlterUserTypeCqlGenerator.java index 2784e4335..c535f10d8 100644 --- a/spring-cql/src/main/java/org/springframework/cassandra/core/cql/generator/AlterUserTypeCqlGenerator.java +++ b/spring-cql/src/main/java/org/springframework/cassandra/core/cql/generator/AlterUserTypeCqlGenerator.java @@ -15,7 +15,7 @@ */ package org.springframework.cassandra.core.cql.generator; -import static org.springframework.cassandra.core.cql.CqlStringUtils.*; +import static org.springframework.cassandra.core.cql.CqlStringUtils.noNull; import org.springframework.cassandra.core.keyspace.AddColumnSpecification; import org.springframework.cassandra.core.keyspace.AlterColumnSpecification; @@ -43,14 +43,14 @@ public class AlterUserTypeCqlGenerator extends UserTypeNameCqlGenerator * A {@link FieldSpecification} consists of a name and a {@link DataType}. - * + * * @author Mark Paluch * @since 1.5 * @see CqlIdentifier @@ -58,12 +58,13 @@ public class FieldSpecification { Assert.notNull(name, "CqlIdentifier must not be null"); this.name = name; + return this; } /** * Sets the column's type. - * + * * @param type The data type of the field, must not be {@literal null}. * @return {@code this} {@link FieldSpecification}. */ @@ -72,6 +73,7 @@ public class FieldSpecification { Assert.notNull(type, "DataType must not be null"); this.type = type; + return this; } @@ -83,7 +85,7 @@ public class FieldSpecification { return noNull(cql).append(name).append(" ").append(type); } - /* + /* * (non-Javadoc) * @see java.lang.Object#toString() */ diff --git a/spring-cql/src/main/java/org/springframework/cassandra/core/keyspace/UserTypeNameSpecification.java b/spring-cql/src/main/java/org/springframework/cassandra/core/keyspace/UserTypeNameSpecification.java index e39071a1d..cf16ca97f 100644 --- a/spring-cql/src/main/java/org/springframework/cassandra/core/keyspace/UserTypeNameSpecification.java +++ b/spring-cql/src/main/java/org/springframework/cassandra/core/keyspace/UserTypeNameSpecification.java @@ -33,7 +33,7 @@ public abstract class UserTypeNameSpecification> extends U /** * Adds the given field to the type. - * + * * @param name must not be empty or {@literal null}. * @param type The data type of the field. * @return {@code this} specification. @@ -60,6 +60,7 @@ public class UserTypeSpecification> extends U public T field(CqlIdentifier name, DataType type) { fields.add(new FieldSpecification().name(name).type(type)); + return (T) this; } diff --git a/spring-cql/src/main/resources/org/springframework/cassandra/config/spring-cql-1.0.xsd b/spring-cql/src/main/resources/org/springframework/cassandra/config/spring-cql-1.0.xsd index 21222888d..8c5ad68e3 100644 --- a/spring-cql/src/main/resources/org/springframework/cassandra/config/spring-cql-1.0.xsd +++ b/spring-cql/src/main/resources/org/springframework/cassandra/config/spring-cql-1.0.xsd @@ -2,12 +2,11 @@ + schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd" /> - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + @@ -51,6 +68,28 @@ Defines a Cassandra cluster. + + + + + + + + + + + + + + + + + + + + + + @@ -433,105 +472,6 @@ When Authentication is enabled, the username to use when connecting to the Clust - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -713,4 +695,21 @@ The replication factor; default is 1. + + + + + + + + + + + + + diff --git a/spring-cql/src/main/resources/org/springframework/cassandra/config/spring-cql-1.5.xsd b/spring-cql/src/main/resources/org/springframework/cassandra/config/spring-cql-1.5.xsd index 9ff0bceb8..b89f0a674 100644 --- a/spring-cql/src/main/resources/org/springframework/cassandra/config/spring-cql-1.5.xsd +++ b/spring-cql/src/main/resources/org/springframework/cassandra/config/spring-cql-1.5.xsd @@ -29,17 +29,6 @@ Defines the configuration elements in the XML namespace for Spring Cassandra. ]]> - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + @@ -65,6 +83,28 @@ Defines a Cassandra cluster. + + + + + + + + + + + + + + + + + + + + + + @@ -447,105 +487,6 @@ When Authentication is enabled, the username to use when connecting to the Clust - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -727,4 +710,21 @@ The replication factor; default is 1. + + + + + + + + + + + + + diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraSessionFactoryBean.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraSessionFactoryBean.java index 60c85472f..3ae3c0029 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraSessionFactoryBean.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraSessionFactoryBean.java @@ -1,12 +1,12 @@ /* * Copyright 2013-2016 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. @@ -68,10 +68,10 @@ public class CassandraSessionFactoryBean extends CassandraCqlSessionFactoryBean /* (non-Javadoc) */ protected void performSchemaAction() { + boolean create = false; boolean drop = DEFAULT_DROP_TABLES; boolean dropUnused = DEFAULT_DROP_UNUSED_TABLES; boolean ifNotExists = DEFAULT_CREATE_IF_NOT_EXISTS; - boolean create = false; switch (schemaAction) { case RECREATE_DROP_UNUSED: diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/xml/CassandraMappingContextParser.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/xml/CassandraMappingContextParser.java index e26d638d7..a1c2726af 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/xml/CassandraMappingContextParser.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/xml/CassandraMappingContextParser.java @@ -1,12 +1,12 @@ /* * Copyright 2013-2016 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. @@ -35,13 +35,14 @@ import org.springframework.data.cassandra.mapping.EntityMapping; import org.springframework.data.cassandra.mapping.Mapping; import org.springframework.data.cassandra.mapping.PropertyMapping; import org.springframework.data.cassandra.mapping.SimpleUserTypeResolver; +import org.springframework.util.Assert; import org.springframework.util.StringUtils; import org.springframework.util.xml.DomUtils; import org.w3c.dom.Element; /** * Spring Data Cassandra XML namespace parser for the <mapping> element. - * + * * @author Matthew T. Adams */ public class CassandraMappingContextParser extends AbstractSingleBeanDefinitionParser { @@ -56,7 +57,8 @@ public class CassandraMappingContextParser extends AbstractSingleBeanDefinitionP throws BeanDefinitionStoreException { String id = super.resolveId(element, definition, parserContext); - return StringUtils.hasText(id) ? id : DefaultBeanNames.CONTEXT; + + return (StringUtils.hasText(id) ? id : DefaultBeanNames.CONTEXT); } @Override @@ -70,14 +72,17 @@ public class CassandraMappingContextParser extends AbstractSingleBeanDefinitionP protected void parseMapping(Element element, BeanDefinitionBuilder builder) { String packages = element.getAttribute("entity-base-packages"); + if (StringUtils.hasText(packages)) { try { - Set> entityClasses = CassandraEntityClassScanner - .scan(StringUtils.commaDelimitedListToStringArray(packages)); + Set> entityClasses = CassandraEntityClassScanner.scan( + StringUtils.commaDelimitedListToStringArray(packages)); + builder.addPropertyValue("initialEntitySet", entityClasses); } catch (Exception x) { throw new IllegalArgumentException( - String.format("encountered exception while scanning for entity classes in package(s) [%s]", packages), x); + String.format("encountered exception while scanning for entity classes in package(s) [%s]", + packages), x); } } @@ -94,15 +99,13 @@ public class CassandraMappingContextParser extends AbstractSingleBeanDefinitionP List userTypeResolvers = DomUtils.getChildElementsByTagName(element, "user-type-resolver"); String userTypeResolverRef = element.getAttribute("user-type-resolver-ref"); + if (StringUtils.hasText(userTypeResolverRef)) { - if (!userTypeResolvers.isEmpty()) { - throw new IllegalArgumentException("Must not define user-type-resolver and user-type-resolver-ref"); - } + Assert.isTrue(userTypeResolvers.isEmpty(), "Must not define user-type-resolver and user-type-resolver-ref"); builder.addPropertyReference("userTypeResolver", userTypeResolverRef); } - if(!userTypeResolvers.isEmpty()){ - + if (!userTypeResolvers.isEmpty()){ BeanDefinition userTypeResolver = parseUserTypeResolver(userTypeResolvers.get(0)); builder.addPropertyValue("userTypeResolver", userTypeResolver); } @@ -116,23 +119,18 @@ public class CassandraMappingContextParser extends AbstractSingleBeanDefinitionP protected EntityMapping parseEntity(Element entity) { String className = entity.getAttribute("class"); - if (!StringUtils.hasText(className)) { - throw new IllegalStateException("class attribute must not be empty"); - } + + Assert.state(StringUtils.hasText(className), "class attribute must not be empty"); + + Element table = DomUtils.getChildElementByTagName(entity, "table"); String tableName = ""; String forceQuote = ""; - Element table = DomUtils.getChildElementByTagName(entity, "table"); + if (table != null) { tableName = table.getAttribute("name"); - if (!StringUtils.hasText(tableName)) { - tableName = ""; - } - - forceQuote = table.getAttribute("force-quote"); - if (!StringUtils.hasText(forceQuote)) { - forceQuote = Boolean.FALSE.toString(); - } + tableName = (StringUtils.hasText(tableName) ? tableName : ""); + forceQuote = String.valueOf(Boolean.parseBoolean(table.getAttribute("force-quote"))); } // TODO: parse future entity mappings here, like table options @@ -148,9 +146,8 @@ public class CassandraMappingContextParser extends AbstractSingleBeanDefinitionP protected BeanDefinition parseUserTypeResolver(Element entity) { String keyspaceName = entity.getAttribute("keyspace-name"); - if (!StringUtils.hasText(keyspaceName)) { - throw new IllegalStateException("keyspace-name attribute must not be null or empty"); - } + + Assert.state(StringUtils.hasText(keyspaceName), "keyspace-name attribute must not be null or empty"); String clusterRef = entity.getAttribute("cluster-ref"); @@ -163,29 +160,31 @@ public class CassandraMappingContextParser extends AbstractSingleBeanDefinitionP protected Map parsePropertyMappings(Element entity) { - Map pms = new HashMap(); + Map propertyMappings = new HashMap(); for (Element property : DomUtils.getChildElementsByTagName(entity, "property")) { String value = property.getAttribute("name"); - if (!StringUtils.hasText(value)) { - throw new IllegalStateException("name attribute must not be empty"); - } - PropertyMapping pm = new PropertyMapping(value); + + Assert.state(StringUtils.hasText(value), "name attribute must not be empty"); + + PropertyMapping propertyMapping = new PropertyMapping(value); value = property.getAttribute("column-name"); + if (StringUtils.hasText(value)) { - pm.setColumnName(value); + propertyMapping.setColumnName(value); } value = property.getAttribute("force-quote"); + if (StringUtils.hasText(value)) { - pm.setForceQuote(value); + propertyMapping.setForceQuote(value); } - pms.put(pm.getPropertyName(), pm); + propertyMappings.put(propertyMapping.getPropertyName(), propertyMapping); } - return pms; + return propertyMappings; } } diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CassandraUDTValueProvider.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CassandraUDTValueProvider.java index 1dbacc69f..6fb2e99d5 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CassandraUDTValueProvider.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CassandraUDTValueProvider.java @@ -17,7 +17,6 @@ package org.springframework.data.cassandra.convert; import org.springframework.data.cassandra.mapping.CassandraPersistentProperty; import org.springframework.data.mapping.model.DefaultSpELExpressionEvaluator; -import org.springframework.data.mapping.model.PropertyValueProvider; import org.springframework.data.mapping.model.SpELExpressionEvaluator; import org.springframework.util.Assert; @@ -27,7 +26,7 @@ import com.datastax.driver.core.UDTValue; /** * {@link CassandraValueProvider} to read property values from a {@link UDTValue}. - * + * * @author Mark Paluch * @since 1.5 */ @@ -40,7 +39,7 @@ public class CassandraUDTValueProvider implements CassandraValueProvider { /** * Creates a new {@link CassandraUDTValueProvider} with the given {@link UDTValue} and * {@link DefaultSpELExpressionEvaluator}. - * + * * @param udtValue must not be {@literal null}. * @param codecRegistry must not be {@literal null}. * @param evaluator must not be {@literal null}. @@ -64,6 +63,7 @@ public class CassandraUDTValueProvider implements CassandraValueProvider { public Object getPropertyValue(CassandraPersistentProperty property) { String expression = property.getSpelExpression(); + if (expression != null) { return evaluator.evaluate(expression); } diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CustomConversions.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CustomConversions.java index c46f5d507..1de8ee3a0 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CustomConversions.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CustomConversions.java @@ -137,11 +137,7 @@ public class CustomConversions { public boolean isSimpleType(Class type) { // Enums have no native Cassandra support - if (type.isEnum()) { - return false; - } - - return simpleTypeHolder.isSimpleType(type); + return (!type.isEnum() && simpleTypeHolder.isSimpleType(type)); } /** diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/MappingCassandraConverter.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/MappingCassandraConverter.java index f9a470893..275640007 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/MappingCassandraConverter.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/MappingCassandraConverter.java @@ -15,7 +15,8 @@ */ package org.springframework.data.cassandra.convert; -import static org.springframework.data.cassandra.repository.support.BasicMapId.*; +import static org.springframework.data.cassandra.repository.support.BasicMapId.Entry; +import static org.springframework.data.cassandra.repository.support.BasicMapId.id; import java.io.Serializable; import java.util.ArrayList; @@ -133,11 +134,11 @@ public class MappingCassandraConverter extends AbstractCassandraConverter return conversionService.convert(row, type); } - CassandraPersistentEntity persistentEntity = (CassandraPersistentEntity) mappingContext - .getPersistentEntity(typeInfo); + CassandraPersistentEntity persistentEntity = (CassandraPersistentEntity) + mappingContext.getPersistentEntity(typeInfo); if (persistentEntity == null) { - throw new MappingException("No mapping metadata found for " + rawType.getName()); + throw new MappingException(String.format("No mapping metadata found for %s", rawType.getName())); } return readEntityFromRow(persistentEntity, row); @@ -157,8 +158,8 @@ public class MappingCassandraConverter extends AbstractCassandraConverter DefaultSpELExpressionEvaluator expressionEvaluator = new DefaultSpELExpressionEvaluator(row, spELContext); BasicCassandraRowValueProvider rowValueProvider = new BasicCassandraRowValueProvider(row, expressionEvaluator); - CassandraPersistentEntityParameterValueProvider parameterProvider = new CassandraPersistentEntityParameterValueProvider( - entity, rowValueProvider, null); + CassandraPersistentEntityParameterValueProvider parameterProvider = + new CassandraPersistentEntityParameterValueProvider(entity, rowValueProvider, null); EntityInstantiator instantiator = instantiators.getInstantiatorFor(entity); S instance = instantiator.createInstance(entity, parameterProvider); @@ -171,11 +172,12 @@ public class MappingCassandraConverter extends AbstractCassandraConverter protected S readEntityFromUdt(CassandraPersistentEntity entity, UDTValue udtValue) { DefaultSpELExpressionEvaluator expressionEvaluator = new DefaultSpELExpressionEvaluator(udtValue, spELContext); - CassandraUDTValueProvider valueProvider = new CassandraUDTValueProvider(udtValue, CodecRegistry.DEFAULT_INSTANCE, - expressionEvaluator); - CassandraPersistentEntityParameterValueProvider parameterProvider = new CassandraPersistentEntityParameterValueProvider( - entity, valueProvider, null); + CassandraUDTValueProvider valueProvider = new CassandraUDTValueProvider( + udtValue, CodecRegistry.DEFAULT_INSTANCE, expressionEvaluator); + + CassandraPersistentEntityParameterValueProvider parameterProvider = + new CassandraPersistentEntityParameterValueProvider(entity, valueProvider, null); EntityInstantiator instantiator = instantiators.getInstantiatorFor(entity); S instance = instantiator.createInstance(entity, parameterProvider); @@ -185,8 +187,9 @@ public class MappingCassandraConverter extends AbstractCassandraConverter return instance; } - protected void readPropertiesFromRow(final CassandraPersistentEntity entity, final CassandraRowValueProvider row, - final PersistentPropertyAccessor propertyAccessor) { + protected void readPropertiesFromRow(CassandraPersistentEntity entity, CassandraRowValueProvider row, + PersistentPropertyAccessor propertyAccessor) { + readProperties(entity, row, propertyAccessor); } @@ -203,16 +206,13 @@ public class MappingCassandraConverter extends AbstractCassandraConverter } /** - * @param entity - * @param property - * @param valueProvider - * @param propertyAccessor * @deprecated Use * {@link #readProperty(CassandraPersistentEntity, CassandraPersistentProperty, CassandraValueProvider, PersistentPropertyAccessor)} */ @Deprecated protected void readPropertyFromRow(CassandraPersistentEntity entity, CassandraPersistentProperty property, CassandraRowValueProvider valueProvider, PersistentPropertyAccessor propertyAccessor) { + readProperty(entity, property, valueProvider, propertyAccessor); } @@ -225,7 +225,6 @@ public class MappingCassandraConverter extends AbstractCassandraConverter } if (property.isCompositePrimaryKey()) { - CassandraPersistentProperty keyProperty = entity.getIdProperty(); CassandraPersistentEntity keyEntity = keyProperty.getCompositePrimaryKeyEntity(); @@ -326,7 +325,8 @@ public class MappingCassandraConverter extends AbstractCassandraConverter Object value = getWriteValue(property, accessor); if (log.isDebugEnabled()) { - log.debug("doWithProperties Property.type {}, Property.value {}", property.getType().getName(), value); + log.debug("doWithProperties Property.type {}, Property.value {}", + property.getType().getName(), value); } if (property.isCompositePrimaryKey()) { @@ -334,8 +334,8 @@ public class MappingCassandraConverter extends AbstractCassandraConverter log.debug("Property is a compositeKey"); } - writeInsertFromWrapper(getConvertingAccessor(value, property.getCompositePrimaryKeyEntity()), insert, - property.getCompositePrimaryKeyEntity()); + writeInsertFromWrapper(getConvertingAccessor(value, property.getCompositePrimaryKeyEntity()), + insert, property.getCompositePrimaryKeyEntity()); return; } @@ -432,10 +432,7 @@ public class MappingCassandraConverter extends AbstractCassandraConverter Object id = extractId(source, entity); - if (id == null) { - String message = String.format("No Id value found in object %s", source); - throw new IllegalArgumentException(message); - } + Assert.notNull(id, String.format("No Id value found in object %s", source)); if (id instanceof MapId) { return getWhereClauses((MapId) id, idProperty != null && idProperty.isCompositePrimaryKey() @@ -459,9 +456,10 @@ public class MappingCassandraConverter extends AbstractCassandraConverter } Class targetType = getTargetType(idProperty); + if (conversionService.canConvert(id.getClass(), targetType)) { - return Collections - .singleton(QueryBuilder.eq(idProperty.getColumnName().toCql(), conversionService.convert(id, targetType))); + return Collections.singleton(QueryBuilder.eq(idProperty.getColumnName().toCql(), + conversionService.convert(id, targetType))); } return Collections.singleton(QueryBuilder.eq(idProperty.getColumnName().toCql(), id)); @@ -477,6 +475,7 @@ public class MappingCassandraConverter extends AbstractCassandraConverter } else if (source instanceof MapIdentifiable) { return ((MapIdentifiable) source).getMapId(); } + return source; } @@ -487,10 +486,11 @@ public class MappingCassandraConverter extends AbstractCassandraConverter String.format("Entity [%s] is not a composite primary key", entity.getName())); final Collection clauses = new ArrayList(); + entity.doWithProperties(new PropertyHandler() { + @Override public void doWithPersistentProperty(CassandraPersistentProperty property) { - TypeCodec codec = getCodec(property); Object value = accessor.getProperty(property, codec.getJavaType().getRawType()); clauses.add(QueryBuilder.eq(property.getColumnName().toCql(), value)); @@ -508,10 +508,10 @@ public class MappingCassandraConverter extends AbstractCassandraConverter for (Entry entry : id.entrySet()) { CassandraPersistentProperty persistentProperty = entity.getPersistentProperty(entry.getKey()); - if (persistentProperty == null) { - throw new IllegalArgumentException(String.format( - "MapId contains references [%s] that is an unknown property of [%s]", entry.getKey(), entity.getName())); - } + + Assert.notNull(persistentProperty, + String.format("MapId contains references [%s] that is an unknown property of [%s]", + entry.getKey(), entity.getName())); clauses.add(QueryBuilder.eq(persistentProperty.getColumnName().toCql(), getWriteValue(persistentProperty, entry.getValue()))); @@ -529,11 +529,9 @@ public class MappingCassandraConverter extends AbstractCassandraConverter final ConvertingPropertyAccessor accessor = getConvertingAccessor(object, entity); - if (!entity.getType().isAssignableFrom(object.getClass())) { - throw new IllegalArgumentException( - String.format("Given instance of type [%s] is not of compatible expected type [%s]", - object.getClass().getName(), entity.getType().getName())); - } + Assert.isTrue(entity.getType().isAssignableFrom(object.getClass()), + String.format("Given instance of type [%s] is not of compatible expected type [%s]", + object.getClass().getName(), entity.getType().getName())); if (object instanceof MapIdentifiable) { return ((MapIdentifiable) object).getMapId(); @@ -628,11 +626,13 @@ public class MappingCassandraConverter extends AbstractCassandraConverter } DataType dataType = mappingContext.getDataType(property); + if (dataType instanceof UserType) { return property.getType(); } TypeCodec codec = CodecRegistry.DEFAULT_INSTANCE.codecFor(mappingContext.getDataType(property)); + return codec.getJavaType().getRawType(); } @@ -679,6 +679,7 @@ public class MappingCassandraConverter extends AbstractCassandraConverter } CassandraPersistentEntity persistentEntity = getMappingContext().getPersistentEntity(property.getActualType()); + if (persistentEntity != null && persistentEntity.isUserDefinedType()) { if (property.isCollectionLike() && value instanceof Collection) { @@ -740,6 +741,7 @@ public class MappingCassandraConverter extends AbstractCassandraConverter } CassandraPersistentEntity persistentEntity = getMappingContext().getPersistentEntity(property.getActualType()); + if (persistentEntity != null && persistentEntity.isUserDefinedType()) { if (property.isCollectionLike() && obj instanceof Collection) { @@ -752,6 +754,7 @@ public class MappingCassandraConverter extends AbstractCassandraConverter converted.add(readEntityFromUdt(persistentEntity, (UDTValue) element)); } } + return converted; } else if (obj instanceof UDTValue) { return readEntityFromUdt(persistentEntity, (UDTValue) obj); diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraAdminTemplate.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraAdminTemplate.java index 3be6de66d..bd5d155fd 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraAdminTemplate.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraAdminTemplate.java @@ -57,7 +57,7 @@ public class CassandraAdminTemplate extends CassandraTemplate implements Cassand super(session, converter); } - /* + /* * (non-Javadoc) * @see org.springframework.data.cassandra.core.CassandraAdminOperations#createTable(boolean, org.springframework.cassandra.core.cql.CqlIdentifier, java.lang.Class, java.util.Map) */ @@ -82,7 +82,7 @@ public class CassandraAdminTemplate extends CassandraTemplate implements Cassand }); } - /* + /* * (non-Javadoc) * @see org.springframework.data.cassandra.core.CassandraAdminOperations#alterTable(org.springframework.cassandra.core.cql.CqlIdentifier, java.lang.Class, boolean) */ @@ -91,7 +91,7 @@ public class CassandraAdminTemplate extends CassandraTemplate implements Cassand throw new UnsupportedOperationException("not yet implemented"); } - /* + /* * (non-Javadoc) * @see org.springframework.data.cassandra.core.CassandraAdminOperations#replaceTable(org.springframework.cassandra.core.cql.CqlIdentifier, java.lang.Class, java.util.Map) */ @@ -143,7 +143,7 @@ public class CassandraAdminTemplate extends CassandraTemplate implements Cassand @Override public void dropTable(CqlIdentifier tableName) { - Assert.notNull(tableName, "Type name must not be null"); + Assert.notNull(tableName, "Table name must not be null"); log.info("Dropping table => " + tableName); @@ -164,7 +164,7 @@ public class CassandraAdminTemplate extends CassandraTemplate implements Cassand execute(DropUserTypeCqlGenerator.toCql(DropUserTypeSpecification.dropType(typeName))); } - /* + /* * (non-Javadoc) * @see org.springframework.data.cassandra.core.CassandraAdminOperations#getTableMetadata(java.lang.String, org.springframework.cassandra.core.cql.CqlIdentifier) */ @@ -190,6 +190,7 @@ public class CassandraAdminTemplate extends CassandraTemplate implements Cassand public KeyspaceMetadata getKeyspaceMetadata() { return execute(new SessionCallback() { + @Override public KeyspaceMetadata doInSession(Session s) throws DataAccessException { diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraPersistentEntitySchemaCreator.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraPersistentEntitySchemaCreator.java index ebe1ac757..c57c69f0c 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraPersistentEntitySchemaCreator.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/CassandraPersistentEntitySchemaCreator.java @@ -43,7 +43,7 @@ import com.datastax.driver.core.UserType; /** * Schema creation support for Cassandra based on {@link CassandraMappingContext} and {@link CassandraPersistentEntity}. * This class generates CQL to drop, recreate and create user types (UDT) and tables. - * + * * @author Mark Paluch * @since 1.5 * @see org.springframework.data.cassandra.mapping.Table @@ -58,7 +58,7 @@ public class CassandraPersistentEntitySchemaCreator { /** * Creates a new {@link CassandraPersistentEntitySchemaCreator} for the given {@link CassandraMappingContext} and * {@link CassandraAdminOperations}. - * + * * @param mappingContext must not be {@literal null}. * @param cassandraAdminOperations must not be {@literal null}. */ @@ -74,7 +74,7 @@ public class CassandraPersistentEntitySchemaCreator { /** * Create user types. Can drop types and drop unused types. - * + * * @param dropUserTypes {@literal true} to drop types before creation. * @param dropUnused {@literal true} to drop unused types before creation. Type usage is determined from existing * mapped {@link org.springframework.data.cassandra.mapping.UserDefinedType}s and UDT names on field @@ -129,6 +129,7 @@ public class CassandraPersistentEntitySchemaCreator { List specifications = new ArrayList(); Set created = new HashSet(); + for (CassandraPersistentEntity entity : entities) { Set seen = new LinkedHashSet(); @@ -141,8 +142,8 @@ public class CassandraPersistentEntitySchemaCreator { for (CqlIdentifier identifier : ordered) { if (created.add(identifier)) { - specifications - .add(mappingContext.getCreateUserTypeSpecificationFor(byName.get(identifier)).ifNotExists(ifNotExists)); + specifications.add(mappingContext.getCreateUserTypeSpecificationFor( + byName.get(identifier)).ifNotExists(ifNotExists)); } } } @@ -158,12 +159,14 @@ public class CassandraPersistentEntitySchemaCreator { for (CassandraPersistentEntity entity : entities) { specifications.add(mappingContext.getCreateTableSpecificationFor(entity).ifNotExists(ifNotExists)); } + return specifications; } private void visitUserTypes(CassandraPersistentEntity entity, final Set seen) { entity.doWithProperties(new PropertyHandler() { + @Override public void doWithPersistentProperty(CassandraPersistentProperty persistentProperty) { diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraMappingContext.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraMappingContext.java index 5f79d5882..75aef8cb4 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraMappingContext.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraMappingContext.java @@ -15,9 +15,9 @@ */ package org.springframework.data.cassandra.mapping; -import static org.springframework.cassandra.core.cql.CqlIdentifier.*; -import static org.springframework.cassandra.core.keyspace.CreateTableSpecification.*; -import static org.springframework.data.cassandra.mapping.CassandraSimpleTypeHolder.*; +import static org.springframework.cassandra.core.cql.CqlIdentifier.cqlId; +import static org.springframework.cassandra.core.keyspace.CreateTableSpecification.createTable; +import static org.springframework.data.cassandra.mapping.CassandraSimpleTypeHolder.getDataTypeFor; import java.beans.PropertyDescriptor; import java.lang.reflect.Field; @@ -84,6 +84,7 @@ public class BasicCassandraMappingContext protected Set> userDefinedTypes = new HashSet>(); private CustomConversions customConversions; + private UserTypeResolver userTypeResolver; /** @@ -109,7 +110,7 @@ public class BasicCassandraMappingContext /** * Sets the {@link UserTypeResolver}. - * + * * @param userTypeResolver must not be {@literal null}. * @since 1.5 */ @@ -146,7 +147,7 @@ public class BasicCassandraMappingContext return Collections.unmodifiableSet(userDefinedTypes); } - /* + /* * (non-Javadoc) * @see org.springframework.data.cassandra.mapping.CassandraMappingContext#getPersistentEntities(boolean) */ @@ -242,7 +243,7 @@ public class BasicCassandraMappingContext CqlIdentifier identifier = CqlIdentifier.cqlId(userType.getTypeName()); - return hasMappedUserType(identifier) || hasReferencedUserType(identifier); + return (hasMappedUserType(identifier) || hasReferencedUserType(identifier)); } private boolean hasReferencedUserType(final CqlIdentifier identifier) { @@ -257,6 +258,7 @@ public class BasicCassandraMappingContext public void doWithPersistentProperty(CassandraPersistentProperty persistentProperty) { CassandraType cassandraType = persistentProperty.findAnnotation(CassandraType.class); + if (cassandraType == null) { return; } @@ -429,8 +431,8 @@ public class BasicCassandraMappingContext */ @Override public DataType getDataType(Class type) { - return customConversions.hasCustomWriteTarget(type) - ? getDataTypeFor(customConversions.getCustomWriteTarget(type)) : getDataTypeFor(type); + return (customConversions.hasCustomWriteTarget(type) + ? getDataTypeFor(customConversions.getCustomWriteTarget(type)) : getDataTypeFor(type)); } public void setMapping(Mapping mapping) { @@ -451,15 +453,16 @@ public class BasicCassandraMappingContext if (entityMapping == null) { continue; } + String entityClassName = entityMapping.getEntityClassName(); try { - Class entityClass = ClassUtils.forName(entityClassName, beanClassLoader); CassandraPersistentEntity entity = getPersistentEntity(entityClass); - Assert.state(entity != null, String.format("Unknown persistent entity class name [%s]", entityClassName)); + Assert.state(entity != null, + String.format("Unknown persistent entity class name [%s]", entityClassName)); String tableName = entityMapping.getTableName(); @@ -470,7 +473,8 @@ public class BasicCassandraMappingContext processMappingOverrides(entity, entityMapping); } catch (ClassNotFoundException e) { - throw new IllegalStateException(String.format("Unknown persistent entity name [%s]", entityClassName), e); + throw new IllegalStateException( + String.format("Unknown persistent entity name [%s]", entityClassName), e); } } } @@ -485,10 +489,8 @@ public class BasicCassandraMappingContext CassandraPersistentProperty property = entity.getPersistentProperty(mapping.getPropertyName()); - if (property == null) { - throw new IllegalArgumentException(String.format("Entity class [%s] has no persistent property named [%s]", - entity.getType().getName(), mapping.getPropertyName())); - } + Assert.notNull(property, String.format("Entity class [%s] has no persistent property named [%s]", + entity.getType().getName(), mapping.getPropertyName())); boolean forceQuote = false; @@ -514,11 +516,9 @@ public class BasicCassandraMappingContext CassandraPersistentEntity entity = entitiesByType.get(type); - if (entity != null) { - return entity; - } + Assert.notNull(entity, String.format("Unknown persistent type [%s]", type.getName())); - throw new IllegalArgumentException(String.format("Unknown persistent type [%s]", type.getName())); + return entity; } @Override diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentProperty.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentProperty.java index 11795ecdb..68dbfca7f 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentProperty.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentProperty.java @@ -15,7 +15,7 @@ */ package org.springframework.data.cassandra.mapping; -import static org.springframework.cassandra.core.cql.CqlIdentifier.*; +import static org.springframework.cassandra.core.cql.CqlIdentifier.cqlId; import java.beans.PropertyDescriptor; import java.lang.reflect.Field; @@ -62,8 +62,6 @@ import com.datastax.driver.core.UserType; public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentProperty implements CassandraPersistentProperty, ApplicationContextAware { - private final UserTypeResolver userTypeResolver; - protected ApplicationContext context; /** @@ -83,6 +81,8 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP protected StandardEvaluationContext spelContext; + private final UserTypeResolver userTypeResolver; + /** * Creates a new {@link BasicCassandraPersistentProperty}. * @@ -111,6 +111,7 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP UserTypeResolver userTypeResolver) { super(field, propertyDescriptor, owner, simpleTypeHolder); + this.userTypeResolver = userTypeResolver; if (owner.getApplicationContext() != null) { @@ -154,9 +155,7 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP List columnNames = getColumnNames(); - if (columnNames.size() != 1) { - throw new IllegalStateException(String.format("Property [%s] has no single column mapping", getName())); - } + Assert.state(columnNames.size() == 1, String.format("Property [%s] has no single column mapping", getName())); return columnNames.get(0); } @@ -298,7 +297,7 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP if (dataType == null) { throw new InvalidDataAccessApiUsageException(String.format( "Only primitive types are allowed inside Collections for property [%1$s] of type [%2$s] in entity [%3$s]", - getName(), getType(), getOwner().getName())); + getName(), getType(), getOwner().getName())); } return dataType; @@ -307,6 +306,7 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP protected DataType getDataTypeFor(Class javaType) { CassandraPersistentEntity persistentEntity = getOwner().getMappingContext().getPersistentEntity(javaType); + if (persistentEntity != null && persistentEntity.isUserDefinedType()) { return persistentEntity.getUserType(); } @@ -316,7 +316,7 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP if (dataType == null) { throw new InvalidDataAccessApiUsageException(String.format( "Only primitive types are allowed inside Collections for property [%1$s] of type ['%2$s'] in entity [%3$s]", - getName(), getType(), getOwner().getName())); + getName(), getType(), getOwner().getName())); } return dataType; @@ -387,6 +387,7 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP final List columnNames) { compositePrimaryKeyEntity.doWithProperties(new PropertyHandler() { + @Override public void doWithPersistentProperty(CassandraPersistentProperty property) { if (property.isCompositePrimaryKey()) { @@ -402,6 +403,7 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP public void setColumnName(CqlIdentifier columnName) { Assert.notNull(columnName, "columnName must not be null"); + setColumnNames(Collections.singletonList(columnName)); } @@ -413,15 +415,13 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP // force calculation of columnNames if not known yet getColumnNames(); - if (this.columnNames.size() != columnNames.size()) { - throw new IllegalStateException(String.format( - "Property [%s] of entity [%s] is mapped to [%s] column%s, but given column name list has size [%s]", + Assert.state(this.columnNames.size() == columnNames.size(), String.format( + "Property [%s] of entity [%s] is mapped to [%s] column%s, but given column name list has size [%s]", getName(), getOwner().getType().getName(), this.columnNames.size(), this.columnNames.size() == 1 ? "" : "s", - columnNames.size())); - } + columnNames.size())); - this.columnNames = this.explicitColumnNames = Collections - .unmodifiableList(new ArrayList(columnNames)); + this.columnNames = this.explicitColumnNames = + Collections.unmodifiableList(new ArrayList(columnNames)); } @Override @@ -446,10 +446,8 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP @Override public List getCompositePrimaryKeyProperties() { - if (!isCompositePrimaryKey()) { - throw new IllegalStateException( - String.format("[%s] does not represent a composite primary key property", getName())); - } + Assert.state(isCompositePrimaryKey(), + String.format("[%s] does not represent a composite primary key property", getName())); return getCompositePrimaryKeyEntity().getCompositePrimaryKeyProperties(); } @@ -459,9 +457,7 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP CassandraMappingContext mappingContext = getOwner().getMappingContext(); - if (mappingContext == null) { - throw new IllegalStateException("CassandraMappingContext needed"); - } + Assert.state(mappingContext != null, "CassandraMappingContext needed"); return mappingContext.getPersistentEntity(getCompositePrimaryKeyTypeInformation()); } diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/SimpleUserTypeResolver.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/SimpleUserTypeResolver.java index f1de4fe80..7014215e4 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/SimpleUserTypeResolver.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/SimpleUserTypeResolver.java @@ -25,7 +25,7 @@ import com.datastax.driver.core.UserType; /** * Default implementation of {@link UserTypeResolver} that resolves {@link UserType} by their name from * {@link Cluster#getMetadata()}. - * + * * @author Mark Paluch * @since 1.5 */ @@ -56,6 +56,7 @@ public class SimpleUserTypeResolver implements UserTypeResolver { public UserType resolveType(CqlIdentifier typeName) { KeyspaceMetadata keyspace = cluster.getMetadata().getKeyspace(keyspaceName); + return keyspace.getUserType(typeName.toCql()); } } diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/ConvertingParameterAccessor.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/ConvertingParameterAccessor.java index f2e5460f2..91cc70ac5 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/ConvertingParameterAccessor.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/ConvertingParameterAccessor.java @@ -155,6 +155,7 @@ class ConvertingParameterAccessor implements CassandraParameterAccessor { // TODO: Polishing necessary DataType parameterType = getDataType(index, property); + if (parameterType != null) { if (property != null && getCustomConversions().hasCustomWriteTarget(property.getActualType()) @@ -176,23 +177,26 @@ class ConvertingParameterAccessor implements CassandraParameterAccessor { } if (property != null) { - CassandraPersistentEntity persistentEntity = converter.getMappingContext() - .getPersistentEntity(property.getActualType()); + CassandraPersistentEntity persistentEntity = + converter.getMappingContext().getPersistentEntity(property.getActualType()); + if (persistentEntity != null && persistentEntity.isUserDefinedType()) { return toUDTValue(bindableValue, persistentEntity); } } TypeCodec cassandraType = CodecRegistry.DEFAULT_INSTANCE.codecFor(parameterType); + if (cassandraType.getJavaType().getRawType().isAssignableFrom(bindableValue.getClass())) { return bindableValue; } - return converter.getConversionService().convert(bindableValue, cassandraType.getJavaType().getRawType()); - } + return converter.getConversionService().convert(bindableValue, cassandraType.getJavaType().getRawType()); + } + + CassandraPersistentEntity persistentEntity = + converter.getMappingContext().getPersistentEntity(bindableValue.getClass()); - CassandraPersistentEntity persistentEntity = converter.getMappingContext() - .getPersistentEntity(bindableValue.getClass()); if (persistentEntity != null && persistentEntity.isUserDefinedType()) { return toUDTValue(bindableValue, persistentEntity); } @@ -207,6 +211,7 @@ class ConvertingParameterAccessor implements CassandraParameterAccessor { } UDTValue udtValue = persistentEntity.getUserType().newValue(); + converter.write(bindableValue, udtValue, persistentEntity); return udtValue; diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/StringBasedCassandraQuery.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/StringBasedCassandraQuery.java index a540c4db9..86b7e3f1c 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/StringBasedCassandraQuery.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/repository/query/StringBasedCassandraQuery.java @@ -117,7 +117,7 @@ public class StringBasedCassandraQuery extends AbstractCassandraQuery { } return boundQuery; - } catch (RuntimeException e) { e.printStackTrace(); + } catch (RuntimeException e) { throw QueryCreationException.create(getQueryMethod(), e); } } diff --git a/spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/spring-cassandra-1.0.xsd b/spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/spring-cassandra-1.0.xsd index 2abc498bb..4f43e7ead 100644 --- a/spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/spring-cassandra-1.0.xsd +++ b/spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/spring-cassandra-1.0.xsd @@ -1,22 +1,19 @@ + schemaLocation="http://www.springframework.org/schema/beans/spring-beans.xsd" /> + schemaLocation="http://www.springframework.org/schema/tool/spring-tool.xsd" /> + schemaLocation="http://www.springframework.org/schema/context/spring-context.xsd" /> + schemaLocation="http://www.springframework.org/schema/data/repository/spring-repository.xsd" /> - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + @@ -60,6 +75,28 @@ Defines a Cassandra cluster. + + + + + + + + + + + + + + + + + + + + + + @@ -308,7 +345,7 @@ Sets the maximum time to wait for schema agreement before returning from a DDL q + default="true"> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -712,37 +716,40 @@ Sets the SO_TCPNODELAY socket option. - - - - - - - - - - - - + + - + + + + + + + + + + + + + + @@ -754,16 +761,6 @@ The replication factor; default is 1. - - - - - - - - @@ -776,6 +773,28 @@ The reference to a cassandraTemplate. Will default to 'cassandraTemplate'. + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -823,23 +853,6 @@ The reference to a UserTypeResolver. UserTypeResolver is required when working w - - - - - - - - - - - - - @@ -896,37 +909,21 @@ Table name override. - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + diff --git a/spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/spring-cassandra-1.5.xsd b/spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/spring-cassandra-1.5.xsd index 2260f6e54..3388f4c8a 100644 --- a/spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/spring-cassandra-1.5.xsd +++ b/spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/spring-cassandra-1.5.xsd @@ -36,17 +36,6 @@ Defines the configuration elements in the XML namespace for Spring Data Cassandr ]]> - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + @@ -72,6 +90,28 @@ Defines a Cassandra cluster. + + + + + + + + + + + + + + + + + + + + + + @@ -320,7 +360,7 @@ Sets the maximum time to wait for schema agreement before returning from a DDL q + default="true"> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -724,37 +731,40 @@ Sets the SO_TCPNODELAY socket option. - - - - - - - - - - - - + + - + + + + + + + + + + + + + + @@ -766,16 +776,6 @@ The replication factor; default is 1. - - - - - - - - @@ -788,6 +788,28 @@ The reference to a cassandraTemplate. Will default to 'cassandraTemplate'. + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -835,23 +868,6 @@ The reference to a UserTypeResolver. UserTypeResolver is required when working w - - - - - - - - - - - - - @@ -908,37 +924,21 @@ Table name override. - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + +