diff --git a/spring-cassandra/src/main/java/org/springframework/cassandra/config/CassandraSessionFactoryBean.java b/spring-cassandra/src/main/java/org/springframework/cassandra/config/CassandraSessionFactoryBean.java index ecc900e2e..dbd4970a7 100644 --- a/spring-cassandra/src/main/java/org/springframework/cassandra/config/CassandraSessionFactoryBean.java +++ b/spring-cassandra/src/main/java/org/springframework/cassandra/config/CassandraSessionFactoryBean.java @@ -27,7 +27,6 @@ import org.springframework.cassandra.core.CassandraTemplate; import org.springframework.cassandra.support.CassandraExceptionTranslator; import org.springframework.dao.DataAccessException; import org.springframework.dao.support.PersistenceExceptionTranslator; -import org.springframework.util.Assert; import org.springframework.util.StringUtils; import com.datastax.driver.core.Cluster; @@ -46,12 +45,12 @@ public class CassandraSessionFactoryBean implements FactoryBean, Initia private static final Logger log = LoggerFactory.getLogger(CassandraSessionFactoryBean.class); - private Cluster cluster; - private Session session; - private String keyspaceName; - private List startupScripts = new ArrayList(); - private List shutdownScripts = new ArrayList(); - private final PersistenceExceptionTranslator exceptionTranslator = new CassandraExceptionTranslator(); + protected Cluster cluster; + protected Session session; + protected String keyspaceName; + protected List startupScripts = new ArrayList(); + protected List shutdownScripts = new ArrayList(); + protected final PersistenceExceptionTranslator exceptionTranslator = new CassandraExceptionTranslator(); @Override public Session getObject() { diff --git a/spring-cassandra/src/main/java/org/springframework/cassandra/config/xml/CassandraSessionParser.java b/spring-cassandra/src/main/java/org/springframework/cassandra/config/xml/CassandraSessionParser.java index aa73c1b77..9a34ce24f 100644 --- a/spring-cassandra/src/main/java/org/springframework/cassandra/config/xml/CassandraSessionParser.java +++ b/spring-cassandra/src/main/java/org/springframework/cassandra/config/xml/CassandraSessionParser.java @@ -25,6 +25,7 @@ import org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser; import org.springframework.beans.factory.xml.ParserContext; import org.springframework.cassandra.config.CassandraSessionFactoryBean; import org.springframework.util.StringUtils; +import org.springframework.util.xml.DomUtils; import org.w3c.dom.Element; import org.w3c.dom.NodeList; @@ -53,39 +54,45 @@ public class CassandraSessionParser extends AbstractSimpleBeanDefinitionParser { @Override protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { - String keyspaceName = element.getAttribute("keyspace-name"); - if (!StringUtils.hasText(keyspaceName)) { - keyspaceName = null; - } - builder.addPropertyValue("keyspaceName", keyspaceName); + parseKeyspaceName(element, builder); + parseClusterRef(element, builder); + parseScripts(element, builder, "startup-cql", "startupScript"); + parseScripts(element, builder, "shutdown-cql", "shutdownScript"); + } + + protected void parseScripts(Element element, BeanDefinitionBuilder builder, String elementName, String propertyName) { + + List scripts = parseScripts(element, elementName); + builder.addPropertyValue(propertyName, scripts); + } + + protected void parseClusterRef(Element element, BeanDefinitionBuilder builder) { String clusterRef = element.getAttribute("cluster-ref"); if (!StringUtils.hasText(clusterRef)) { clusterRef = BeanNames.CASSANDRA_CLUSTER; } builder.addPropertyReference("cluster", clusterRef); - - parseChildElements(element, builder); } - protected void parseChildElements(Element element, BeanDefinitionBuilder builder) { + protected void parseKeyspaceName(Element element, BeanDefinitionBuilder builder) { - List scripts = parseScripts(element, "startup-cql"); - builder.addPropertyValue("startupScripts", scripts); - - scripts = parseScripts(element, "shutdown-cql"); - builder.addPropertyValue("shutdownScripts", scripts); + String keyspaceName = element.getAttribute("keyspace-name"); + if (!StringUtils.hasText(keyspaceName)) { + keyspaceName = null; + } + builder.addPropertyValue("keyspaceName", keyspaceName); } protected List parseScripts(Element element, String elementName) { - NodeList nodes = element.getElementsByTagName("startup-cql"); + NodeList nodes = element.getElementsByTagName(elementName); int length = nodes.getLength(); List scripts = new ArrayList(length); for (int i = 0; i < length; i++) { Element script = (Element) nodes.item(i); - scripts.add(script.getTextContent()); + scripts.add(DomUtils.getTextValue(script)); } return scripts; diff --git a/spring-cassandra/src/main/resources/org/springframework/cassandra/config/spring-cassandra-1.0.xsd b/spring-cassandra/src/main/resources/org/springframework/cassandra/config/spring-cassandra-1.0.xsd index c0b1ab354..9e31eb010 100644 --- a/spring-cassandra/src/main/resources/org/springframework/cassandra/config/spring-cassandra-1.0.xsd +++ b/spring-cassandra/src/main/resources/org/springframework/cassandra/config/spring-cassandra-1.0.xsd @@ -357,7 +357,7 @@ Arbitrary CQL script to be executed against the session's keyspace during bean d - + > entities = converter.getMappingContext().getPersistentEntities(); + + for (CassandraPersistentEntity entity : entities) { + admin.createTable(false, entity.getTableName(), entity.getType(), null /* TODO */); + } + } + + public SchemaAction getSchemaAction() { + return schemaAction; + } + + public void setSchemaAction(SchemaAction schemaAction) { + Assert.notNull(schemaAction); + this.schemaAction = schemaAction; + } + + public CassandraConverter getConverter() { + return converter; + } + + public void setConverter(CassandraConverter converter) { + Assert.notNull(converter); + this.converter = converter; + this.mappingContext = converter.getCassandraMappingContext(); + } +} diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/KeyspaceAttributes.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/KeyspaceAttributes.java index 0d4d3d1df..d0f3d5ebb 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/KeyspaceAttributes.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/KeyspaceAttributes.java @@ -17,54 +17,10 @@ package org.springframework.data.cassandra.config; import java.util.Collection; -/** - * Keyspace attributes are used for manipulation around keyspace at the startup. Auto property defines the way how to do - * this. Other attributes used to ensure or update keyspace settings. - * - * @author Alex Shvid - */ public class KeyspaceAttributes extends org.springframework.cassandra.config.KeyspaceAttributes { - /* - * auto possible values: - * validate: validate the keyspace, makes no changes. - * update: update the keyspace. - * create: creates the keyspace, destroying previous data. - * create-drop: drop the keyspace at the end of the session. - */ - public static final String AUTO_VALIDATE = "validate"; - public static final String AUTO_UPDATE = "update"; - public static final String AUTO_CREATE = "create"; - public static final String AUTO_CREATE_DROP = "create-drop"; - - private String auto = AUTO_VALIDATE; - private Collection tables; - public String getAuto() { - return auto; - } - - public void setAuto(String auto) { - this.auto = auto; - } - - public boolean isValidate() { - return AUTO_VALIDATE.equals(auto); - } - - public boolean isUpdate() { - return AUTO_UPDATE.equals(auto); - } - - public boolean isCreate() { - return AUTO_CREATE.equals(auto); - } - - public boolean isCreateDrop() { - return AUTO_CREATE_DROP.equals(auto); - } - public Collection getTables() { return tables; } @@ -72,5 +28,4 @@ public class KeyspaceAttributes extends org.springframework.cassandra.config.Key public void setTables(Collection tables) { this.tables = tables; } - } diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/SchemaAction.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/SchemaAction.java new file mode 100644 index 000000000..990ec77e4 --- /dev/null +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/SchemaAction.java @@ -0,0 +1,45 @@ +package org.springframework.data.cassandra.config; + +/** + * Enum identifying any schema actions to take at startup. + * + * @author Matthew T. Adams + */ +public enum SchemaAction { + + /** + * Take no schema actions. + */ + NONE, + + /** + * Create each table as necessary. Fail if a table already exists. + */ + CREATE, + + /** + * Create each table as necessary, dropping the table first if it exists. + */ + RECREATE, + + /** + * Drop all tables in the keyspace, then create each table as necessary. + */ + RECREATE_DROP_UNUSED; + + // TODO: + // /** + // * Validate that each required table and column exists. Fail if any required table or column does not exists. + // */ + // VALIDATE("VALIDATE"), + // + // /** + // * Alter or create each table and column as necessary, leaving unused tables and columns untouched. + // */ + // UPDATE("UPDATE"), + // + // /** + // * Alter or create each table and column as necessary, removing unused tables and columns. + // */ + // UPDATE_DROP_UNUNSED("UPDATE_DROP_UNUSED"); +} diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/java/AbstractSpringDataCassandraConfiguration.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/java/AbstractSpringDataCassandraConfiguration.java index ad6c84044..973f7d625 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/java/AbstractSpringDataCassandraConfiguration.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/java/AbstractSpringDataCassandraConfiguration.java @@ -31,8 +31,7 @@ import org.springframework.data.cassandra.convert.MappingCassandraConverter; import org.springframework.data.cassandra.core.CassandraAdminOperations; import org.springframework.data.cassandra.core.CassandraAdminTemplate; import org.springframework.data.cassandra.mapping.CassandraMappingContext; -import org.springframework.data.cassandra.mapping.CassandraPersistentEntity; -import org.springframework.data.cassandra.mapping.CassandraPersistentProperty; +import org.springframework.data.cassandra.mapping.DefaultCassandraMappingContext; import org.springframework.data.cassandra.mapping.Table; import org.springframework.data.mapping.context.MappingContext; import org.springframework.util.ClassUtils; @@ -74,9 +73,8 @@ public abstract class AbstractSpringDataCassandraConfiguration extends AbstractC * @throws ClassNotFoundException */ @Bean - public MappingContext, CassandraPersistentProperty> cassandraMappingContext() - throws ClassNotFoundException { - CassandraMappingContext context = new CassandraMappingContext(); + public CassandraMappingContext cassandraMappingContext() throws ClassNotFoundException { + DefaultCassandraMappingContext context = new DefaultCassandraMappingContext(); context.setInitialEntitySet(getInitialEntitySet()); return context; } diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraNamespaceHandler.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/xml/CassandraNamespaceHandler.java similarity index 72% rename from spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraNamespaceHandler.java rename to spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/xml/CassandraNamespaceHandler.java index 310bb5a7b..20e6f54fd 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/CassandraNamespaceHandler.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/config/xml/CassandraNamespaceHandler.java @@ -13,9 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.springframework.data.cassandra.config; - -import org.springframework.beans.factory.xml.NamespaceHandlerSupport; +package org.springframework.data.cassandra.config.xml; /** * Namespace handler for <cassandra>. @@ -23,10 +21,10 @@ import org.springframework.beans.factory.xml.NamespaceHandlerSupport; * @author Alex Shvid */ -public class CassandraNamespaceHandler extends NamespaceHandlerSupport { +public class CassandraNamespaceHandler extends org.springframework.cassandra.config.xml.CassandraNamespaceHandler { + @Override public void init() { - - // registerBeanDefinitionParser("keyspace", new CassandraKeyspaceParser()); + super.init(); } } diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CassandraConverter.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CassandraConverter.java index ac07a2f98..5d6d6f079 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CassandraConverter.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/convert/CassandraConverter.java @@ -15,7 +15,7 @@ */ package org.springframework.data.cassandra.convert; -import org.springframework.cassandra.core.keyspace.CreateTableSpecification; +import org.springframework.data.cassandra.mapping.CassandraMappingContext; import org.springframework.data.cassandra.mapping.CassandraPersistentEntity; import org.springframework.data.cassandra.mapping.CassandraPersistentProperty; import org.springframework.data.convert.EntityConverter; @@ -24,10 +24,10 @@ import org.springframework.data.convert.EntityConverter; * Central Cassandra specific converter interface from Object to Row. * * @author Alex Shvid + * @author Matthew T. Adams */ public interface CassandraConverter extends EntityConverter, CassandraPersistentProperty, Object, Object> { - // TODO: move this method to a more appropriate location - CreateTableSpecification getCreateTableSpecification(CassandraPersistentEntity entity); + CassandraMappingContext getCassandraMappingContext(); } 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 c4164084e..7ced0ddbc 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 @@ -23,6 +23,7 @@ import org.springframework.cassandra.core.keyspace.CreateTableSpecification; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.core.convert.support.DefaultConversionService; +import org.springframework.data.cassandra.mapping.CassandraMappingContext; import org.springframework.data.cassandra.mapping.CassandraPersistentEntity; import org.springframework.data.cassandra.mapping.CassandraPersistentProperty; import org.springframework.data.convert.EntityInstantiator; @@ -49,13 +50,14 @@ import com.datastax.driver.core.querybuilder.Update; * {@link Row}. * * @author Alex Shvid + * @author Matthew T. Adams */ public class MappingCassandraConverter extends AbstractCassandraConverter implements CassandraConverter, ApplicationContextAware, BeanClassLoaderAware { protected static final Logger log = LoggerFactory.getLogger(MappingCassandraConverter.class); - protected final MappingContext, CassandraPersistentProperty> mappingContext; + protected final CassandraMappingContext mappingContext; protected ApplicationContext applicationContext; private SpELContext spELContext; private boolean useFieldAccessOnly = true; @@ -63,12 +65,11 @@ public class MappingCassandraConverter extends AbstractCassandraConverter implem private ClassLoader beanClassLoader; /** - * Creates a new {@link MappingCassandraConverter} given the new {@link MappingContext}. + * Creates a new {@link MappingCassandraConverter} with the given {@link CassandraMappingContext}. * * @param mappingContext must not be {@literal null}. */ - public MappingCassandraConverter( - MappingContext, CassandraPersistentProperty> mappingContext) { + public MappingCassandraConverter(CassandraMappingContext mappingContext) { super(new DefaultConversionService()); this.mappingContext = mappingContext; this.spELContext = new SpELContext(RowReaderPropertyAccessor.INSTANCE); @@ -80,7 +81,6 @@ public class MappingCassandraConverter extends AbstractCassandraConverter implem Class beanClassLoaderClass = transformClassToBeanClassLoaderClass(clazz); TypeInformation type = ClassTypeInformation.from(beanClassLoaderClass); - // TypeInformation typeToUse = typeMapper.readType(row, type); TypeInformation typeToUse = type; Class rawType = typeToUse.getType(); @@ -108,12 +108,13 @@ public class MappingCassandraConverter extends AbstractCassandraConverter implem this.spELContext = new SpELContext(this.spELContext, applicationContext); } - protected S readEntityFromRow(final CassandraPersistentEntity entity, final Row row) { + protected S readEntityFromRow(final CassandraPersistentEntity entity, final Row row) { final DefaultSpELExpressionEvaluator evaluator = new DefaultSpELExpressionEvaluator(row, spELContext); final PropertyValueProvider propertyProvider = new CassandraPropertyValueProvider(row, evaluator); + PersistentEntityParameterValueProvider parameterProvider = new PersistentEntityParameterValueProvider( entity, propertyProvider, null); @@ -144,7 +145,8 @@ public class MappingCassandraConverter extends AbstractCassandraConverter implem } if (prop.isCompositePrimaryKey()) { - // TODO: handle composite primary key properties via recursion into this method + // handle composite primary key properties via recursion into this method + throw new UnsupportedOperationException("composite primary keys are TODO"); } boolean hasValueForProperty = row.getColumnDefinitions().contains(prop.getColumnName()); @@ -268,55 +270,6 @@ public class MappingCassandraConverter extends AbstractCassandraConverter implem } - @Override - public CreateTableSpecification getCreateTableSpecification(CassandraPersistentEntity entity) { - - final CreateTableSpecification spec = new CreateTableSpecification(); - - spec.name(entity.getTableName()); - - entity.doWithProperties(new PropertyHandler() { - @Override - public void doWithPersistentProperty(CassandraPersistentProperty prop) { - - if (prop.isCompositePrimaryKey()) { - - CassandraPersistentEntity pkEntity = mappingContext.getPersistentEntity(prop.getRawType()); - - pkEntity.doWithProperties(new PropertyHandler() { - @Override - public void doWithPersistentProperty(CassandraPersistentProperty pkProp) { - - if (pkProp.isPartitionKeyColumn()) { - spec.partitionKeyColumn(pkProp.getColumnName(), pkProp.getDataType()); - } else { - spec.clusteredKeyColumn(pkProp.getColumnName(), pkProp.getDataType(), pkProp.getPrimaryKeyOrdering()); - } - - } - }); - - } else { - - if (prop.isIdProperty()) { - spec.partitionKeyColumn(prop.getColumnName(), prop.getDataType()); - } else { - spec.column(prop.getColumnName(), prop.getDataType()); - } - - } - } - - }); - - if (spec.getPartitionKeyColumns().isEmpty()) { - throw new MappingException("not found partition key in the entity " + entity.getType()); - } - - return spec; - - } - @SuppressWarnings("unchecked") private Class transformClassToBeanClassLoaderClass(Class entity) { try { @@ -334,4 +287,8 @@ public class MappingCassandraConverter extends AbstractCassandraConverter implem } + @Override + public CassandraMappingContext getCassandraMappingContext() { + return mappingContext; + } } 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 f5d888b95..f02a7d884 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 @@ -6,6 +6,8 @@ import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.cassandra.core.SessionCallback; +import org.springframework.cassandra.core.cql.generator.CreateTableCqlGenerator; +import org.springframework.cassandra.core.keyspace.CreateTableSpecification; import org.springframework.cassandra.support.CassandraAccessor; import org.springframework.cassandra.support.CassandraExceptionTranslator; import org.springframework.cassandra.support.exception.CassandraTableExistsException; @@ -13,10 +15,9 @@ import org.springframework.dao.DataAccessException; import org.springframework.dao.InvalidDataAccessApiUsageException; import org.springframework.dao.support.PersistenceExceptionTranslator; import org.springframework.data.cassandra.convert.CassandraConverter; +import org.springframework.data.cassandra.mapping.CassandraMappingContext; import org.springframework.data.cassandra.mapping.CassandraPersistentEntity; -import org.springframework.data.cassandra.mapping.CassandraPersistentProperty; import org.springframework.data.cassandra.util.CqlUtils; -import org.springframework.data.mapping.context.MappingContext; import org.springframework.util.Assert; import com.datastax.driver.core.ResultSet; @@ -32,7 +33,7 @@ public class CassandraAdminTemplate extends CassandraAccessor implements Cassand private Session session; private CassandraConverter converter; - private MappingContext, CassandraPersistentProperty> mappingContext; + private CassandraMappingContext mappingContext; private final PersistenceExceptionTranslator exceptionTranslator = new CassandraExceptionTranslator(); @@ -45,34 +46,32 @@ public class CassandraAdminTemplate extends CassandraAccessor implements Cassand setSession(session); } - protected CassandraAdminTemplate setCassandraConverter(CassandraConverter converter) { + public void setCassandraConverter(CassandraConverter converter) { Assert.notNull(converter); this.converter = converter; - return setMappingContext(converter.getMappingContext()); + setMappingContext(converter.getCassandraMappingContext()); } - protected CassandraAdminTemplate setMappingContext( - MappingContext, CassandraPersistentProperty> mappingContext) { + protected void setMappingContext(CassandraMappingContext mappingContext) { Assert.notNull(mappingContext); - return this; + this.mappingContext = mappingContext; } - /* (non-Javadoc) - * @see org.springframework.data.cassandra.core.CassandraAdminOperations#createTable(boolean, java.lang.String, java.lang.Class, java.util.Map) - */ @Override public boolean createTable(boolean ifNotExists, final String tableName, Class entityClass, Map optionsByName) { try { - final CassandraPersistentEntity entity = mappingContext.getPersistentEntity(entityClass); execute(new SessionCallback() { + @Override public Object doInSession(Session s) throws DataAccessException { - String cql = CqlUtils.createTable(tableName, entity, converter); + String cql = new CreateTableCqlGenerator(mappingContext.getCreateTableSpecificationFor(entity)).toCql(); + log.info("CREATE TABLE CQL -> " + cql); + s.execute(cql); return null; } @@ -120,6 +119,7 @@ public class CassandraAdminTemplate extends CassandraAccessor implements Cassand execute(new SessionCallback() { + @Override public Object doInSession(Session s) throws DataAccessException { for (String q : queryList) { @@ -179,6 +179,7 @@ public class CassandraAdminTemplate extends CassandraAccessor implements Cassand return execute(new SessionCallback() { + @Override public TableMetadata doInSession(Session s) throws DataAccessException { return s.getCluster().getMetadata().getKeyspace(keyspace).getTable(tableName); diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntity.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntity.java index 2b8be6e6b..3e97477dc 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntity.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/BasicCassandraPersistentEntity.java @@ -39,9 +39,10 @@ import org.springframework.util.StringUtils; public class BasicCassandraPersistentEntity extends BasicPersistentEntity implements CassandraPersistentEntity, ApplicationContextAware { - private final String table; - private final SpelExpressionParser parser; - private final StandardEvaluationContext context; + private String table; + private final SpelExpressionParser spelParser; + private final StandardEvaluationContext spelContext; + private final Class type; /** * Creates a new {@link BasicCassandraPersistentEntity} with the given {@link TypeInformation}. Will default the table @@ -53,25 +54,32 @@ public class BasicCassandraPersistentEntity extends BasicPersistentEntity rawType = typeInformation.getType(); - Table anno = rawType.getAnnotation(Table.class); + this.type = typeInformation.getType(); + + determineTableName(); + } + + protected void determineTableName() { + Table anno = type.getAnnotation(Table.class); this.table = anno != null && StringUtils.hasText(anno.value()) ? anno.value() : CassandraNamingUtils - .getPreferredTableName(rawType); + .getPreferredTableName(type); } + @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { - context.addPropertyAccessor(new BeanFactoryAccessor()); - context.setBeanResolver(new BeanFactoryResolver(applicationContext)); - context.setRootObject(applicationContext); + spelContext.addPropertyAccessor(new BeanFactoryAccessor()); + spelContext.setBeanResolver(new BeanFactoryResolver(applicationContext)); + spelContext.setRootObject(applicationContext); } + @Override public String getTableName() { - Expression expression = parser.parseExpression(table, ParserContext.TEMPLATE_EXPRESSION); - return expression.getValue(context, String.class); + Expression expression = spelParser.parseExpression(table, ParserContext.TEMPLATE_EXPRESSION); + return expression.getValue(spelContext, String.class); } } 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 6513b7fe1..651ab572b 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 @@ -52,16 +52,6 @@ public class BasicCassandraPersistentProperty extends AnnotationBasedPersistentP super(field, propertyDescriptor, owner, simpleTypeHolder); } - @Override - public boolean isIdProperty() { - - if (super.isIdProperty()) { - return true; - } - - return isAnnotationPresent(PrimaryKey.class); - } - @Override public boolean isCompositePrimaryKey() { return getField().getType().isAnnotationPresent(PrimaryKeyClass.class); diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/CassandraMappingContext.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/CassandraMappingContext.java index dfe546e93..b0e996964 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/CassandraMappingContext.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/CassandraMappingContext.java @@ -1,76 +1,29 @@ -/* - * 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.data.cassandra.mapping; -import java.beans.PropertyDescriptor; -import java.lang.reflect.Field; - -import org.springframework.beans.BeansException; -import org.springframework.context.ApplicationContext; -import org.springframework.context.ApplicationContextAware; -import org.springframework.data.mapping.context.AbstractMappingContext; +import org.springframework.cassandra.core.keyspace.CreateTableSpecification; import org.springframework.data.mapping.context.MappingContext; -import org.springframework.data.mapping.model.SimpleTypeHolder; -import org.springframework.data.util.TypeInformation; + +import com.datastax.driver.core.TableMetadata; /** - * Default implementation of a {@link MappingContext} for Cassandra using {@link CassandraPersistentEntity} and - * {@link CassandraPersistentProperty} as primary abstractions. + * A {@link MappingContext} for Cassandra. * - * @author Alex Shvid * @author Matthew T. Adams */ -public class CassandraMappingContext extends - AbstractMappingContext, CassandraPersistentProperty> implements - ApplicationContextAware { - - private ApplicationContext context; +public interface CassandraMappingContext extends + MappingContext, CassandraPersistentProperty> { /** - * Creates a new {@link CassandraMappingContext}. + * Returns a {@link CreateTableSpecification} for the given entity, including all mapping information. + * + * @param The entity. May not be null. */ - public CassandraMappingContext() { - setSimpleTypeHolder(new CassandraSimpleTypeHolder()); - } + CreateTableSpecification getCreateTableSpecificationFor(CassandraPersistentEntity entity); - @Override - public CassandraPersistentProperty createPersistentProperty(Field field, PropertyDescriptor descriptor, - CassandraPersistentEntity owner, SimpleTypeHolder simpleTypeHolder) { - return createPersistentProperty(field, descriptor, owner, (CassandraSimpleTypeHolder) simpleTypeHolder); - } - - public CassandraPersistentProperty createPersistentProperty(Field field, PropertyDescriptor descriptor, - CassandraPersistentEntity owner, CassandraSimpleTypeHolder simpleTypeHolder) { - return new CachingCassandraPersistentProperty(field, descriptor, owner, simpleTypeHolder); - } - - @Override - protected CassandraPersistentEntity createPersistentEntity(TypeInformation typeInformation) { - - BasicCassandraPersistentEntity entity = new BasicCassandraPersistentEntity(typeInformation); - - if (context != null) { - entity.setApplicationContext(context); - } - - return entity; - } - - @Override - public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { - this.context = applicationContext; - } + /** + * Returns whether this mapping context has any entities mapped to the given table. + * + * @param table May not be null. + */ + boolean usesTable(TableMetadata table); } diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/DefaultCassandraMappingContext.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/DefaultCassandraMappingContext.java new file mode 100644 index 000000000..359b30143 --- /dev/null +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/DefaultCassandraMappingContext.java @@ -0,0 +1,151 @@ +/* + * 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.data.cassandra.mapping; + +import java.beans.PropertyDescriptor; +import java.lang.reflect.Field; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +import org.springframework.beans.BeansException; +import org.springframework.cassandra.core.keyspace.CreateTableSpecification; +import org.springframework.context.ApplicationContext; +import org.springframework.context.ApplicationContextAware; +import org.springframework.data.mapping.PropertyHandler; +import org.springframework.data.mapping.context.AbstractMappingContext; +import org.springframework.data.mapping.context.MappingContext; +import org.springframework.data.mapping.model.MappingException; +import org.springframework.data.mapping.model.SimpleTypeHolder; +import org.springframework.data.util.TypeInformation; +import org.springframework.util.Assert; + +import com.datastax.driver.core.TableMetadata; + +/** + * Default implementation of a {@link MappingContext} for Cassandra using {@link CassandraPersistentEntity} and + * {@link CassandraPersistentProperty} as primary abstractions. + * + * @author Alex Shvid + * @author Matthew T. Adams + */ +public class DefaultCassandraMappingContext extends + AbstractMappingContext, CassandraPersistentProperty> implements + CassandraMappingContext, ApplicationContextAware { + + protected ApplicationContext context; + protected Map>> entitySetsByTableName = new HashMap>>(); + + /** + * Creates a new {@link DefaultCassandraMappingContext}. + */ + public DefaultCassandraMappingContext() { + setSimpleTypeHolder(new CassandraSimpleTypeHolder()); + } + + @Override + public CassandraPersistentProperty createPersistentProperty(Field field, PropertyDescriptor descriptor, + CassandraPersistentEntity owner, SimpleTypeHolder simpleTypeHolder) { + + return createPersistentProperty(field, descriptor, owner, (CassandraSimpleTypeHolder) simpleTypeHolder); + } + + public CassandraPersistentProperty createPersistentProperty(Field field, PropertyDescriptor descriptor, + CassandraPersistentEntity owner, CassandraSimpleTypeHolder simpleTypeHolder) { + + return new CachingCassandraPersistentProperty(field, descriptor, owner, simpleTypeHolder); + } + + @Override + protected CassandraPersistentEntity createPersistentEntity(TypeInformation typeInformation) { + + BasicCassandraPersistentEntity entity = new BasicCassandraPersistentEntity(typeInformation); + + if (context != null) { + entity.setApplicationContext(context); + } + + Set> entities = entitySetsByTableName.get(entity.getTableName()); + if (entities == null) { + entities = new HashSet>(); + } + entities.add(entity); + entitySetsByTableName.put(entity.getTableName(), entities); + + return entity; + } + + @Override + public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { + this.context = applicationContext; + } + + @Override + public boolean usesTable(TableMetadata table) { + return entitySetsByTableName.containsKey(table.getName()); + } + + @Override + public CreateTableSpecification getCreateTableSpecificationFor(CassandraPersistentEntity entity) { + + Assert.notNull(entity); + + final CreateTableSpecification spec = new CreateTableSpecification(); + + spec.name(entity.getTableName()); + + entity.doWithProperties(new PropertyHandler() { + + @Override + public void doWithPersistentProperty(CassandraPersistentProperty prop) { + + if (prop.isCompositePrimaryKey()) { + + CassandraPersistentEntity pkEntity = getPersistentEntity(prop.getRawType()); + + pkEntity.doWithProperties(new PropertyHandler() { + + @Override + public void doWithPersistentProperty(CassandraPersistentProperty pkProp) { + + if (pkProp.isPartitionKeyColumn()) { + spec.partitionKeyColumn(pkProp.getColumnName(), pkProp.getDataType()); + } else { + spec.clusteredKeyColumn(pkProp.getColumnName(), pkProp.getDataType(), pkProp.getPrimaryKeyOrdering()); + } + } + }); + + } else { + + if (prop.isIdProperty()) { + spec.partitionKeyColumn(prop.getColumnName(), prop.getDataType()); + } else { + spec.column(prop.getColumnName(), prop.getDataType()); + } + } + } + + }); + + if (spec.getPartitionKeyColumns().isEmpty()) { + throw new MappingException("no partition key columns found in the entity " + entity.getType()); + } + + return spec; + } +} diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMapping.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMapping.java new file mode 100644 index 000000000..821a705c1 --- /dev/null +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMapping.java @@ -0,0 +1,51 @@ +package org.springframework.data.cassandra.mapping; + +import java.util.Set; + +import javax.validation.constraints.NotNull; + +/** + * Interface that stores information about the mapping between a table and the entity or the entities that are mapped to + * it. + * + * @author Matthew T. Adams + */ +public interface TableMapping { + + /** + * Convenience method to return the only member of the set of entity classes. This method can be used when the caller + * knows that there is only one entity class in this mapping. If there are multiple and this method is called, an + * {@link IllegalStateException} is thrown. + */ + @NotNull + Class getEntityClass(); + + /** + * Convenience method to set this mapping to use a single entity class. + * + * @param entityClass The class; may not be null. + */ + void setEntityClass(@NotNull Class entityClass); + + /** + * Sets the set of entity classes of this mapping. + */ + void setEntityClasses(Set> entityClasses); + + /** + * Returns the set of entity classes of this mapping. Never returns null. + */ + @NotNull + Set> getEntityClasses(); + + /** + * Returns the name of this mapping. Never returns null. + */ + @NotNull + String getTableName(); + + /** + * Sets the table name of this mapping. + */ + void setTableName(@NotNull String tableName); +} diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMappingImpl.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMappingImpl.java new file mode 100644 index 000000000..b3a6e81f1 --- /dev/null +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMappingImpl.java @@ -0,0 +1,97 @@ +package org.springframework.data.cassandra.mapping; + +import java.util.HashSet; +import java.util.Set; + +import org.springframework.util.Assert; + +/** + * Default implementation of {@link TableMapping}. + * + * @author Matthew T. Adams + */ +public class TableMappingImpl implements TableMapping { + + private Set> entityClasses = new HashSet>(); + private String tableName; + + public TableMappingImpl(Class entityClass, String tableName) { + this(tableName); + setEntityClass(entityClass); + } + + public TableMappingImpl(Set> entityClasses, String tableName) { + this(tableName); + setEntityClasses(entityClasses); + } + + protected TableMappingImpl(String tableName) { + setTableName(tableName); + } + + @Override + public Class getEntityClass() { + if (entityClasses.size() != 1) { + throw new IllegalStateException("more than one entity class exists in this TableMapping"); + } + return entityClasses.iterator().next(); + } + + @Override + public Set> getEntityClasses() { + return entityClasses; + } + + @Override + public void setEntityClasses(Set> entityClasses) { + this.entityClasses = entityClasses == null ? new HashSet>() : new HashSet>(entityClasses); + } + + @Override + public String getTableName() { + return tableName; + } + + @Override + public void setTableName(String tableName) { + Assert.notNull(tableName); + this.tableName = tableName; + } + + @Override + public void setEntityClass(Class entityClass) { + if (entityClass == null) { + throw new IllegalArgumentException("entity class required"); + } + + entityClasses.clear(); + entityClasses.add(entityClass); + } + + @Override + public boolean equals(Object that) { + + if (this == that) { + return true; + } + if (that == null) { + return false; + } + if (!(that instanceof TableMapping)) { + return false; + } + + TableMapping thatMapping = (TableMapping) that; + + if (!this.tableName.equals(thatMapping.getTableName())) { + return false; + } + + return this.entityClasses.equals(thatMapping.getEntityClasses()); + } + + @Override + public int hashCode() { + return tableName.hashCode() ^ entityClasses.hashCode(); + } +} diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMappings.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMappings.java new file mode 100644 index 000000000..c0467c488 --- /dev/null +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMappings.java @@ -0,0 +1,8 @@ +package org.springframework.data.cassandra.mapping; + +public interface TableMappings { + + TableMapping getTableMappingByClass(Class entityClass); + + TableMapping getTableMappingByTableName(String tableName); +} diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMappingsImpl.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMappingsImpl.java new file mode 100644 index 000000000..a9f381c0e --- /dev/null +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/mapping/TableMappingsImpl.java @@ -0,0 +1,48 @@ +package org.springframework.data.cassandra.mapping; + +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +public class TableMappingsImpl implements TableMappings { + + private Map, TableMapping> mappingsByClass = new HashMap, TableMapping>(); + private Map mappingsByTable = new HashMap(); + + public TableMappingsImpl(Set mappings) { + setMappings(mappings); + } + + public void setMappings(Set mappings) { + + mappingsByClass.clear(); + mappingsByTable.clear(); + + if (mappings == null || mappings.size() == 0) { + return; + } + + for (TableMapping mapping : mappings) { + + if (mapping == null) { + continue; + } + + mappingsByTable.put(mapping.getTableName(), mapping); + + for (Class entityClass : mapping.getEntityClasses()) { + mappingsByClass.put(entityClass, mapping); + } + } + } + + @Override + public TableMapping getTableMappingByClass(Class entityClass) { + return mappingsByClass.get(entityClass); + } + + @Override + public TableMapping getTableMappingByTableName(String tableName) { + return mappingsByTable.get(tableName); + } +} diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/util/CqlUtils.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/util/CqlUtils.java index 8be12f30c..153ca1770 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/util/CqlUtils.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/util/CqlUtils.java @@ -39,24 +39,6 @@ public abstract class CqlUtils { private static Logger log = LoggerFactory.getLogger(CqlUtils.class); - /** - * Generates the CQL String to create a table in Cassandra - * - * @param tableName - * @param entity - * @return The CQL that can be passed to session.execute() - */ - public static String createTable(String tableName, final CassandraPersistentEntity entity, - CassandraConverter cassandraConverter) { - - CreateTableSpecification spec = cassandraConverter.getCreateTableSpecification(entity); - spec.name(tableName); - - CreateTableCqlGenerator generator = new CreateTableCqlGenerator(spec); - - return generator.toCql(); - } - /** * Create the List of CQL for the indexes required for Cassandra mapped Table. * @@ -68,6 +50,7 @@ public abstract class CqlUtils { final List result = new ArrayList(); entity.doWithProperties(new PropertyHandler() { + @Override public void doWithPersistentProperty(CassandraPersistentProperty prop) { if (prop.isIndexed()) { @@ -101,6 +84,7 @@ public abstract class CqlUtils { final List result = new ArrayList(); entity.doWithProperties(new PropertyHandler() { + @Override public void doWithPersistentProperty(CassandraPersistentProperty prop) { String columnName = prop.getColumnName(); diff --git a/spring-data-cassandra/src/main/resources/META-INF/spring.handlers b/spring-data-cassandra/src/main/resources/META-INF/spring.handlers index 8a812d6ba..35ee66654 100644 --- a/spring-data-cassandra/src/main/resources/META-INF/spring.handlers +++ b/spring-data-cassandra/src/main/resources/META-INF/spring.handlers @@ -1 +1 @@ -http\://www.springframework.org/schema/data/cassandra=org.springframework.data.cassandra.config.CassandraNamespaceHandler +http\://www.springframework.org/schema/data/cassandra=org.springframework.data.cassandra.config.xml.CassandraNamespaceHandler diff --git a/spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/ext-spring-cassandra-1.0.xsd b/spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/ext-spring-cassandra-1.0.xsd new file mode 100644 index 000000000..46577c250 --- /dev/null +++ b/spring-data-cassandra/src/main/resources/org/springframework/data/cassandra/config/ext-spring-cassandra-1.0.xsd @@ -0,0 +1,166 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file 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 44daecc74..1c49cd4cb 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,38 +1,259 @@ - - +Defines the configuration elements for Spring Cassandra support. + ]]> - + + + + + + + + + + - + + + + + + + + + + - + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + + + + + + + - + + + + + + + + + + - - - + @@ -44,21 +265,319 @@ Defines the configuration elements for Spring Data Cassandra support. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/CassandraNamespaceTests.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/CassandraNamespaceTests.java index e27eda166..7eb3f69ed 100644 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/CassandraNamespaceTests.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/CassandraNamespaceTests.java @@ -6,13 +6,17 @@ import org.apache.cassandra.exceptions.ConfigurationException; import org.apache.thrift.transport.TTransportException; 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.context.ApplicationContext; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import org.springframework.util.Assert; -// @RunWith(SpringJUnit4ClassRunner.class) -// @ContextConfiguration +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration public class CassandraNamespaceTests { @Autowired @@ -29,9 +33,8 @@ public class CassandraNamespaceTests { EmbeddedCassandraServerHelper.cleanEmbeddedCassandra(); } - @AfterClass - public static void stopCassandra() { - EmbeddedCassandraServerHelper.stopEmbeddedCassandra(); + @Test + public void test() { + Assert.notNull(ctx); } - } diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/DriverTests.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/DriverTests.java index 7ccbdf563..df4ef09e6 100644 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/DriverTests.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/DriverTests.java @@ -6,7 +6,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.AfterClass; import org.junit.BeforeClass; import org.junit.Test; @@ -42,9 +41,4 @@ public class DriverTests { public void clearCassandra() { EmbeddedCassandraServerHelper.cleanEmbeddedCassandra(); } - - @AfterClass - public static void stopCassandra() { - EmbeddedCassandraServerHelper.stopEmbeddedCassandra(); - } } diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/TestConfig.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/TestConfig.java index 5cd565bfd..44f657d4b 100644 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/TestConfig.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/test/integration/config/TestConfig.java @@ -7,7 +7,7 @@ import org.springframework.data.cassandra.convert.CassandraConverter; import org.springframework.data.cassandra.convert.MappingCassandraConverter; import org.springframework.data.cassandra.core.CassandraDataOperations; import org.springframework.data.cassandra.core.CassandraDataTemplate; -import org.springframework.data.cassandra.mapping.CassandraMappingContext; +import org.springframework.data.cassandra.mapping.DefaultCassandraMappingContext; /** * Setup any spring configuration for unit tests @@ -27,7 +27,7 @@ public class TestConfig extends AbstractSpringDataCassandraConfiguration { @Bean public CassandraConverter cassandraConverter() { - return new MappingCassandraConverter(new CassandraMappingContext()); + return new MappingCassandraConverter(new DefaultCassandraMappingContext()); } @Bean diff --git a/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/config/CassandraNamespaceTests-context.xml b/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/config/CassandraNamespaceTests-context.xml index 56723073e..b3fd33498 100644 --- a/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/config/CassandraNamespaceTests-context.xml +++ b/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/config/CassandraNamespaceTests-context.xml @@ -1,54 +1,46 @@ + 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/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"> - - + - - - + + + + + class="org.springframework.data.cassandra.mapping.DefaultCassandraMappingContext"/> + + class="org.springframework.data.cassandra.convert.MappingCassandraConverter"> - - - - - - - - - - - - - + + + + diff --git a/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/config/cassandra.properties b/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/config/cassandra.properties index 6a0dd3197..f60144610 100644 --- a/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/config/cassandra.properties +++ b/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/config/cassandra.properties @@ -1,7 +1,3 @@ cassandra.contactPoints=localhost cassandra.port=9042 cassandra.keyspace=TestKS123 - - - - diff --git a/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/repository/UserRepositoryIntegrationTests-context.xml b/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/repository/UserRepositoryIntegrationTests-context.xml index 3601a030b..543fe6614 100644 --- a/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/repository/UserRepositoryIntegrationTests-context.xml +++ b/spring-data-cassandra/src/test/resources/org/springframework/data/cassandra/test/integration/repository/UserRepositoryIntegrationTests-context.xml @@ -28,7 +28,7 @@ + class=" org.springframework.data.cassandra.mapping.DefaultCassandraMappingContext" />