diff --git a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/mapping/CassandraPersistentPropertyComparator.java b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/mapping/CassandraPersistentPropertyComparator.java index 0c9a7e879..009a6efa2 100644 --- a/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/mapping/CassandraPersistentPropertyComparator.java +++ b/spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/mapping/CassandraPersistentPropertyComparator.java @@ -45,16 +45,6 @@ public enum CassandraPersistentPropertyComparator implements Comparator cql = ArgumentCaptor.forClass(String.class); @@ -216,4 +235,22 @@ class CassandraPersistentEntitySchemaCreatorUnitTests extends CassandraPersisten private Udt1 u1; } + + @PrimaryKeyClass + public static class PersonKey implements Serializable { + @PrimaryKeyColumn(name = "firstname", type = PrimaryKeyType.PARTITIONED) private String firstName; + + @PrimaryKeyColumn(name = "aname", type = PrimaryKeyType.PARTITIONED) private String aName; + + @PrimaryKeyColumn(name = "lastname", type = PrimaryKeyType.CLUSTERED) private String lastName; + + @PrimaryKeyColumn(name = "bname", type = PrimaryKeyType.CLUSTERED) private String bName; + } + + @Table + public static class Person { + @PrimaryKey PersonKey key; + + int age; + } } diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/CassandraTemplateUnitTests.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/CassandraTemplateUnitTests.java index f0fa25e63..0a10cac81 100644 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/CassandraTemplateUnitTests.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/CassandraTemplateUnitTests.java @@ -301,7 +301,7 @@ class CassandraTemplateUnitTests { verify(session).execute(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())) - .isEqualTo("INSERT INTO users (firstname,id,lastname) VALUES ('Walter','heisenberg','White')"); + .isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('heisenberg','Walter','White')"); assertThat(beforeConvert).isSameAs(user); assertThat(beforeSave).isSameAs(user); } @@ -322,7 +322,7 @@ class CassandraTemplateUnitTests { verify(session).execute(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())) - .isEqualTo("INSERT INTO users (firstname,id,lastname) VALUES ('Walter','ww','White')"); + .isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('ww','Walter','White')"); } @Test @@ -337,7 +337,7 @@ class CassandraTemplateUnitTests { verify(session).execute(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())).isEqualTo( - "INSERT INTO vusers (firstname,id,lastname,version) VALUES ('Walter','heisenberg','White',0) IF NOT EXISTS"); + "INSERT INTO vusers (id,version,firstname,lastname) VALUES ('heisenberg',0,'Walter','White') IF NOT EXISTS"); assertThat(beforeConvert).isSameAs(user); assertThat(beforeSave).isSameAs(user); } @@ -358,7 +358,7 @@ class CassandraTemplateUnitTests { verify(session).execute(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())).isEqualTo( - "INSERT INTO vusers (firstname,id,lastname,version) VALUES ('Walter','ww','White',0) IF NOT EXISTS"); + "INSERT INTO vusers (id,version,firstname,lastname) VALUES ('ww',0,'Walter','White') IF NOT EXISTS"); } @Test @@ -375,7 +375,7 @@ class CassandraTemplateUnitTests { verify(session).execute(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())) - .isEqualTo("INSERT INTO users (firstname,id,lastname) VALUES ('Walter','heisenberg','White') IF NOT EXISTS"); + .isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('heisenberg','Walter','White') IF NOT EXISTS"); } @Test // DATACASS-560 @@ -391,7 +391,7 @@ class CassandraTemplateUnitTests { verify(session).execute(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())) - .isEqualTo("INSERT INTO users (firstname,id,lastname) VALUES (NULL,'heisenberg',NULL)"); + .isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('heisenberg',NULL,NULL)"); } @Test // DATACASS-292 @@ -449,7 +449,7 @@ class CassandraTemplateUnitTests { verify(session).execute(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())).isEqualTo( - "UPDATE vusers SET firstname='Walter', lastname='White', version=1 WHERE id='heisenberg' IF version=0"); + "UPDATE vusers SET version=1, firstname='Walter', lastname='White' WHERE id='heisenberg' IF version=0"); assertThat(beforeConvert).isSameAs(user); assertThat(beforeSave).isSameAs(user); } diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/ReactiveCassandraTemplateUnitTests.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/ReactiveCassandraTemplateUnitTests.java index 3d7256046..d27e1afff 100644 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/ReactiveCassandraTemplateUnitTests.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/ReactiveCassandraTemplateUnitTests.java @@ -291,7 +291,7 @@ class ReactiveCassandraTemplateUnitTests { verify(session).execute(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())) - .isEqualTo("INSERT INTO users (firstname,id,lastname) VALUES ('Walter','heisenberg','White')"); + .isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('heisenberg','Walter','White')"); assertThat(beforeConvert).isSameAs(user); assertThat(beforeSave).isSameAs(user); } @@ -307,7 +307,7 @@ class ReactiveCassandraTemplateUnitTests { verify(session).execute(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())).isEqualTo( - "INSERT INTO vusers (firstname,id,lastname,version) VALUES ('Walter','heisenberg','White',0) IF NOT EXISTS"); + "INSERT INTO vusers (id,version,firstname,lastname) VALUES ('heisenberg',0,'Walter','White') IF NOT EXISTS"); assertThat(beforeConvert).isSameAs(user); assertThat(beforeSave).isSameAs(user); } @@ -355,7 +355,7 @@ class ReactiveCassandraTemplateUnitTests { verify(session).execute(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())).isEqualTo( - "UPDATE vusers SET firstname='Walter', lastname='White', version=1 WHERE id='heisenberg' IF version=0"); + "UPDATE vusers SET version=1, firstname='Walter', lastname='White' WHERE id='heisenberg' IF version=0"); assertThat(beforeConvert).isSameAs(user); assertThat(beforeSave).isSameAs(user); } diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/StatementFactoryUnitTests.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/StatementFactoryUnitTests.java index 4ecb9fc91..c153ec133 100644 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/StatementFactoryUnitTests.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/StatementFactoryUnitTests.java @@ -317,7 +317,7 @@ class StatementFactoryUnitTests { StatementBuilder insert = statementFactory.insert(person, options); assertThat(insert.build(ParameterHandling.INLINE).getQuery()).isEqualTo( - "INSERT INTO person (first_name,id,list,map,number,set_col) VALUES (NULL,'foo',NULL,NULL,NULL,NULL)"); + "INSERT INTO person (id,number,list,map,set_col,first_name) VALUES ('foo',NULL,NULL,NULL,NULL,NULL)"); } @Test // DATACASS-656 @@ -596,7 +596,7 @@ class StatementFactoryUnitTests { WriteOptions.empty()); assertThat(update.build(ParameterHandling.INLINE).getQuery()) - .isEqualTo("UPDATE person SET first_name='bar', list=NULL, map=NULL, number=NULL, set_col=NULL WHERE id='foo'"); + .isEqualTo("UPDATE person SET number=NULL, list=NULL, map=NULL, set_col=NULL, first_name='bar' WHERE id='foo'"); } @Test // DATACASS-656 @@ -665,7 +665,7 @@ class StatementFactoryUnitTests { WriteOptions.empty()); assertThat(update.build(ParameterHandling.INLINE).getQuery()) - .isEqualTo("UPDATE person SET first_name=NULL, list=[], map=NULL, number=NULL, set_col={} WHERE id='foo'"); + .isEqualTo("UPDATE person SET number=NULL, list=[], map=NULL, set_col={}, first_name=NULL WHERE id='foo'"); } @Test // DATACASS-708 diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/convert/MappingCassandraConverterUDTUnitTests.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/convert/MappingCassandraConverterUDTUnitTests.java index 0d4e122a9..d9cbd4e24 100755 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/convert/MappingCassandraConverterUDTUnitTests.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/convert/MappingCassandraConverterUDTUnitTests.java @@ -44,17 +44,7 @@ import org.springframework.data.cassandra.core.StatementFactory; import org.springframework.data.cassandra.core.cql.PrimaryKeyType; import org.springframework.data.cassandra.core.cql.WriteOptions; import org.springframework.data.cassandra.core.cql.util.StatementBuilder; -import org.springframework.data.cassandra.core.mapping.CassandraMappingContext; -import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity; -import org.springframework.data.cassandra.core.mapping.CassandraType; -import org.springframework.data.cassandra.core.mapping.Embedded; -import org.springframework.data.cassandra.core.mapping.Frozen; -import org.springframework.data.cassandra.core.mapping.PrimaryKey; -import org.springframework.data.cassandra.core.mapping.PrimaryKeyClass; -import org.springframework.data.cassandra.core.mapping.PrimaryKeyColumn; -import org.springframework.data.cassandra.core.mapping.Table; -import org.springframework.data.cassandra.core.mapping.UserDefinedType; -import org.springframework.data.cassandra.core.mapping.UserTypeResolver; +import org.springframework.data.cassandra.core.mapping.*; import org.springframework.data.cassandra.support.UserDefinedTypeBuilder; import org.springframework.data.cassandra.test.util.RowMockUtil; @@ -139,8 +129,8 @@ class MappingCassandraConverterUDTUnitTests { SimpleStatement statement = new StatementFactory(converter).insert(addressBook, WriteOptions.empty()) .build(StatementBuilder.ParameterHandling.INLINE); - assertThat(statement.getQuery()).isEqualTo("INSERT INTO addressbook (currentaddress,id) " - + "VALUES ({zip:'69469',city:'Weinheim',streetlines:['Heckenpfad','14']},'1')"); + assertThat(statement.getQuery()).isEqualTo("INSERT INTO addressbook (id,currentaddress) " + + "VALUES ('1',{zip:'69469',city:'Weinheim',streetlines:['Heckenpfad','14']})"); } @Test // DATACASS-172 @@ -178,8 +168,8 @@ class MappingCassandraConverterUDTUnitTests { SimpleStatement statement = new StatementFactory(converter).insert(addressBook, WriteOptions.empty()) .build(StatementBuilder.ParameterHandling.INLINE); - assertThat(statement.getQuery()).isEqualTo("INSERT INTO addressbook (alternate,id) " - + "VALUES ({zip:'69469',city:'Weinheim',streetlines:['Heckenpfad','14']},'1')"); + assertThat(statement.getQuery()).isEqualTo("INSERT INTO addressbook (id,alternate) " + + "VALUES ('1',{zip:'69469',city:'Weinheim',streetlines:['Heckenpfad','14']})"); } @Test // DATACASS-172 @@ -484,7 +474,7 @@ class MappingCassandraConverterUDTUnitTests { .build(StatementBuilder.ParameterHandling.INLINE); assertThat(statement.getQuery()) - .isEqualTo("INSERT INTO car (engine,id) VALUES ({manufacturer:{name:'a good one',displayname:NULL}},'1')"); + .isEqualTo("INSERT INTO car (id,engine) VALUES ('1',{manufacturer:{name:'a good one',displayname:NULL}})"); } @Test // #1098 diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/convert/SchemaFactoryUnitTests.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/convert/SchemaFactoryUnitTests.java index 9990737d1..9896acf94 100755 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/convert/SchemaFactoryUnitTests.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/convert/SchemaFactoryUnitTests.java @@ -43,18 +43,7 @@ import org.springframework.data.cassandra.core.cql.keyspace.ColumnSpecification; import org.springframework.data.cassandra.core.cql.keyspace.CreateIndexSpecification; import org.springframework.data.cassandra.core.cql.keyspace.CreateIndexSpecification.ColumnFunction; import org.springframework.data.cassandra.core.cql.keyspace.CreateTableSpecification; -import org.springframework.data.cassandra.core.mapping.CassandraMappingContext; -import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity; -import org.springframework.data.cassandra.core.mapping.CassandraType; -import org.springframework.data.cassandra.core.mapping.Column; -import org.springframework.data.cassandra.core.mapping.Element; -import org.springframework.data.cassandra.core.mapping.Embedded; -import org.springframework.data.cassandra.core.mapping.Indexed; -import org.springframework.data.cassandra.core.mapping.PrimaryKey; -import org.springframework.data.cassandra.core.mapping.PrimaryKeyClass; -import org.springframework.data.cassandra.core.mapping.PrimaryKeyColumn; -import org.springframework.data.cassandra.core.mapping.Table; -import org.springframework.data.cassandra.core.mapping.Tuple; +import org.springframework.data.cassandra.core.mapping.*; import org.springframework.data.cassandra.domain.AllPossibleTypes; import org.springframework.data.cassandra.support.UserDefinedTypeBuilder; import org.springframework.data.mapping.MappingException; @@ -910,4 +899,32 @@ public class SchemaFactoryUnitTests { assertThat(name.getName().toString()).isEqualTo("address"); assertThat(name.isStatic()).isTrue(); } + + @Test // GH-978 + void aaa() { + + CassandraPersistentEntity persistentEntity = mappingContext.getRequiredPersistentEntity(Person.class); + + CreateTableSpecification tableSpecification = schemaFactory.getCreateTableSpecificationFor(persistentEntity); + + System.out.println(tableSpecification); + } + + @PrimaryKeyClass + public static class PersonKey implements Serializable { + @PrimaryKeyColumn(name = "firstname", type = PrimaryKeyType.PARTITIONED, ordinal = 1) private String firstName; + + @PrimaryKeyColumn(name = "aname", type = PrimaryKeyType.PARTITIONED, ordinal = 0) private String aName; + + @PrimaryKeyColumn(name = "lastname", type = PrimaryKeyType.CLUSTERED, ordinal = 3) private String lastName; + + @PrimaryKeyColumn(name = "bname", type = PrimaryKeyType.CLUSTERED, ordinal = 4) private String bName; + } + + @Table + public static class Person { + @PrimaryKey PersonKey key; + + int age; + } } diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/cql/support/CachedPreparedStatementCreatorIntegrationTest.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/cql/support/CachedPreparedStatementCreatorIntegrationTests.java similarity index 91% rename from spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/cql/support/CachedPreparedStatementCreatorIntegrationTest.java rename to spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/cql/support/CachedPreparedStatementCreatorIntegrationTests.java index 151eadb51..14df4e2a2 100644 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/cql/support/CachedPreparedStatementCreatorIntegrationTest.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/cql/support/CachedPreparedStatementCreatorIntegrationTests.java @@ -32,7 +32,7 @@ import com.datastax.oss.driver.api.querybuilder.QueryBuilder; * * @author Mark Paluch */ -class CachedPreparedStatementCreatorIntegrationTest extends AbstractKeyspaceCreatingIntegrationTests { +class CachedPreparedStatementCreatorIntegrationTests extends AbstractKeyspaceCreatingIntegrationTests { private static final AtomicBoolean initialized = new AtomicBoolean(); @@ -59,6 +59,6 @@ class CachedPreparedStatementCreatorIntegrationTest extends AbstractKeyspaceCrea PreparedStatement preparedStatement = CachedPreparedStatementCreator.of(cache, insert) .createPreparedStatement(session); - assertThat(preparedStatement.bind(1, 2).isIdempotent()).isTrue(); + assertThat(preparedStatement.bind("id", "foo").isIdempotent()).isTrue(); } } diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/legacy/AsyncCassandraTemplateUnitTests.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/legacy/AsyncCassandraTemplateUnitTests.java index 7721993ac..f27042df9 100644 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/legacy/AsyncCassandraTemplateUnitTests.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/legacy/AsyncCassandraTemplateUnitTests.java @@ -322,7 +322,7 @@ class AsyncCassandraTemplateUnitTests { assertThat(getUninterruptibly(future)).isEqualTo(user); verify(session).executeAsync(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())) - .isEqualTo("INSERT INTO users (firstname,id,lastname) VALUES ('Walter','heisenberg','White')"); + .isEqualTo("INSERT INTO users (id,firstname,lastname) VALUES ('heisenberg','Walter','White')"); assertThat(beforeConvert).isSameAs(user); assertThat(beforeSave).isSameAs(user); } @@ -339,7 +339,7 @@ class AsyncCassandraTemplateUnitTests { assertThat(getUninterruptibly(future)).isEqualTo(user); verify(session).executeAsync(statementCaptor.capture()); assertThat(render(statementCaptor.getValue())).isEqualTo( - "INSERT INTO vusers (firstname,id,lastname,version) VALUES ('Walter','heisenberg','White',0) IF NOT EXISTS"); + "INSERT INTO vusers (id,version,firstname,lastname) VALUES ('heisenberg',0,'Walter','White') IF NOT EXISTS"); assertThat(beforeConvert).isSameAs(user); assertThat(beforeSave).isSameAs(user); } @@ -394,7 +394,7 @@ class AsyncCassandraTemplateUnitTests { verify(session).executeAsync(statementCaptor.capture()); SimpleStatement value = statementCaptor.getValue(); assertThat(render(value)).isEqualTo( - "UPDATE vusers SET firstname='Walter', lastname='White', version=1 WHERE id='heisenberg' IF version=0"); + "UPDATE vusers SET version=1, firstname='Walter', lastname='White' WHERE id='heisenberg' IF version=0"); assertThat(beforeConvert).isSameAs(user); assertThat(beforeSave).isSameAs(user); } diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/mapping/CassandraPersistentPropertyComparatorUnitTests.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/mapping/CassandraPersistentPropertyComparatorUnitTests.java index ed9e9e3d5..eb9ea24ea 100755 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/mapping/CassandraPersistentPropertyComparatorUnitTests.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/mapping/CassandraPersistentPropertyComparatorUnitTests.java @@ -24,8 +24,6 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import com.datastax.oss.driver.api.core.CqlIdentifier; - /** * The CassandraPersistentPropertyComparatorUnitTests class is a test suite of test cases testing the contract and * functionality of the {@link CassandraPersistentPropertyComparator} class. @@ -41,41 +39,11 @@ class CassandraPersistentPropertyComparatorUnitTests { @Mock CassandraPersistentProperty right; - @Test // DATACASS-248 - void leftAndRightAreNullReturnsZero() { - - assertThat(INSTANCE.compare(null, null)).isEqualTo(0); - - verifyNoInteractions(left); - verifyNoInteractions(right); - } - - @Test // DATACASS-248 - void leftIsNotNullAndRightIsNullReturnsOne() { - - assertThat(INSTANCE.compare(left, null)).isEqualTo(1); - - verifyNoInteractions(left); - verifyNoInteractions(right); - } - - @Test // DATACASS-248 - void leftIsNullAndRightIsNotNullReturnsMinusOne() { - - assertThat(INSTANCE.compare(null, right)).isEqualTo(-1); - - verifyNoInteractions(left); - verifyNoInteractions(right); - } - @Test // DATACASS-248 void leftAndRightAreEqualReturnsZero() { assertThat(INSTANCE.compare(left, left)).isEqualTo(0); assertThat(INSTANCE.compare(right, right)).isEqualTo(0); - - verifyNoInteractions(left); - verifyNoInteractions(right); } @Test // DATACASS-248 @@ -154,39 +122,19 @@ class CassandraPersistentPropertyComparatorUnitTests { verify(right, times(1)).isPrimaryKeyColumn(); } - @Test // DATACASS-248 - void compareLeftAndRightNamesReturnsNegativeValue() { - - when(left.isCompositePrimaryKey()).thenReturn(false); - when(left.isPrimaryKeyColumn()).thenReturn(true); - when(right.isCompositePrimaryKey()).thenReturn(true); - when(right.isPrimaryKeyColumn()).thenReturn(false); - when(left.getRequiredColumnName()).thenReturn(CqlIdentifier.fromCql("left")); - when(right.getRequiredColumnName()).thenReturn(CqlIdentifier.fromCql("right")); - - assertThat(INSTANCE.compare(left, right)).isLessThan(0); - - verify(left, times(1)).isCompositePrimaryKey(); - verify(left, times(1)).isPrimaryKeyColumn(); - verify(left, times(1)).getRequiredColumnName(); - verify(right, times(1)).isCompositePrimaryKey(); - verify(right, times(1)).isPrimaryKeyColumn(); - verify(right, times(1)).getRequiredColumnName(); - } - - @Test // DATACASS-352 - void columnNameComparisonShouldHonorContract() throws Exception { + @Test // GH-1369 + void tupleShouldOrderElementsByOrdinal() { CassandraMappingContext context = new CassandraMappingContext(); - CassandraPersistentEntity persistentEntity = context.getRequiredPersistentEntity(TwoColumns.class); + CassandraPersistentEntity persistentEntity = context.getRequiredPersistentEntity(Tuples.class); - CassandraPersistentProperty annotated = persistentEntity.getRequiredPersistentProperty("annotated"); - CassandraPersistentProperty another = persistentEntity.getRequiredPersistentProperty("anotherAnnotated"); - CassandraPersistentProperty plain = persistentEntity.getRequiredPersistentProperty("plain"); + CassandraPersistentProperty one = persistentEntity.getRequiredPersistentProperty("one"); + CassandraPersistentProperty zero = persistentEntity.getRequiredPersistentProperty("zero"); - assertThat(INSTANCE.compare(annotated, plain)).isLessThanOrEqualTo(-1); - assertThat(INSTANCE.compare(plain, annotated)).isGreaterThanOrEqualTo(1); - assertThat(INSTANCE.compare(another, another)).isEqualTo(0); + assertThat(INSTANCE.compare(one, zero)).isGreaterThanOrEqualTo(0); + assertThat(INSTANCE.compare(one, one)).isEqualTo(0); + assertThat(INSTANCE.compare(zero, one)).isLessThan(0); + assertThat(INSTANCE.compare(zero, zero)).isEqualTo(0); } private static class TwoColumns { @@ -197,4 +145,12 @@ class CassandraPersistentPropertyComparatorUnitTests { String plain; } + + @Tuple + private static class Tuples { + + @Element(1) String one; + + @Element(0) String zero; + } } diff --git a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/mapping/CassandraPrimaryKeyColumnAnnotationComparatorUnitTests.java b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/mapping/CassandraPrimaryKeyColumnAnnotationComparatorUnitTests.java index 8270a1fd5..a69ff5134 100755 --- a/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/mapping/CassandraPrimaryKeyColumnAnnotationComparatorUnitTests.java +++ b/spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/mapping/CassandraPrimaryKeyColumnAnnotationComparatorUnitTests.java @@ -25,6 +25,7 @@ import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; import org.springframework.data.cassandra.core.cql.Ordering; import org.springframework.data.cassandra.core.cql.PrimaryKeyType; +import org.springframework.data.mapping.PersistentProperty; /** * The CassandraPrimaryKeyColumnAnnotationComparatorUnitTests class is a test suite of test cases testing the contract @@ -44,7 +45,7 @@ class CassandraPrimaryKeyColumnAnnotationComparatorUnitTests { @BeforeAll static void setup() throws Exception { - entityOne = EntityOne.class.getDeclaredField("id").getAnnotation(PrimaryKeyColumn.class); + entityOne = EntityOne.class.getDeclaredField("a").getAnnotation(PrimaryKeyColumn.class); entityTwo = EntityTwo.class.getDeclaredField("id").getAnnotation(PrimaryKeyColumn.class); entityThree = EntityThree.class.getDeclaredField("id").getAnnotation(PrimaryKeyColumn.class); entityFour = EntityFour.class.getDeclaredField("id").getAnnotation(PrimaryKeyColumn.class); @@ -67,12 +68,12 @@ class CassandraPrimaryKeyColumnAnnotationComparatorUnitTests { assertThat(INSTANCE.compare(entityThree, entityOne)).isEqualTo(1); } - @Test // DATACASS-248 + @Test // DATACASS-248, GH-1369 void compareName() { - assertThat(INSTANCE.compare(entityOne, entityFour)).isEqualTo(-1); - assertThat(INSTANCE.compare(entityFour, entityFour)).isEqualTo(0); - assertThat(INSTANCE.compare(entityFour, entityOne)).isEqualTo(1); + assertThat(INSTANCE.compare(entityOne, entityFour)).isZero(); + assertThat(INSTANCE.compare(entityFour, entityFour)).isZero(); + assertThat(INSTANCE.compare(entityFour, entityOne)).isZero(); } @Test // DATACASS-248 @@ -83,9 +84,53 @@ class CassandraPrimaryKeyColumnAnnotationComparatorUnitTests { assertThat(INSTANCE.compare(entityFive, entityOne)).isEqualTo(1); } + @Test // GH-1369 + void compareNatural() { + + CassandraMappingContext context = new CassandraMappingContext(); + BasicCassandraPersistentEntity entity = context.getRequiredPersistentEntity(NaturalOrder.class); + + assertThat(entity).extracting(PersistentProperty::getName).containsSequence("partOne", "partTwo", "clustered", + "regular"); + } + + @Test // GH-1369 + void compareOrdinal() { + + CassandraMappingContext context = new CassandraMappingContext(); + BasicCassandraPersistentEntity entity = context.getRequiredPersistentEntity(WithOrdinals.class); + + assertThat(entity).extracting(PersistentProperty::getName).containsSequence("partOne", "partTwo", "clustered"); + } + private static class EntityOne { @PrimaryKeyColumn(type = PrimaryKeyType.CLUSTERED, ordinal = 1, name = "A", - ordering = Ordering.ASCENDING) private Integer id; + ordering = Ordering.ASCENDING) private Integer a; + + @PrimaryKeyColumn(type = PrimaryKeyType.CLUSTERED, ordinal = 2, name = "B", + ordering = Ordering.ASCENDING) private Integer b; + } + + private static class NaturalOrder { + + private Integer regular; + + @PrimaryKeyColumn(type = PrimaryKeyType.CLUSTERED) private Integer clustered; + + @PrimaryKeyColumn(type = PrimaryKeyType.PARTITIONED) private Integer partOne; + + @PrimaryKeyColumn(type = PrimaryKeyType.PARTITIONED) private Integer partTwo; + + } + + private static class WithOrdinals { + + @PrimaryKeyColumn(type = PrimaryKeyType.PARTITIONED, ordinal = 0) private Integer partOne; + + @PrimaryKeyColumn(type = PrimaryKeyType.PARTITIONED, ordinal = 2) private Integer partTwo; + + @PrimaryKeyColumn(type = PrimaryKeyType.CLUSTERED, ordinal = 1) private Integer clustered; + } private static class EntityTwo { @@ -104,7 +149,7 @@ class CassandraPrimaryKeyColumnAnnotationComparatorUnitTests { } private static class EntityFive { - @PrimaryKeyColumn(type = PrimaryKeyType.CLUSTERED, ordinal = 1, name = "A", + @PrimaryKeyColumn(type = PrimaryKeyType.CLUSTERED, ordinal = 5, name = "A", ordering = Ordering.DESCENDING) private UUID id; } }