From b793c94eed89aa602bc9b55a2cb057b9844c3949 Mon Sep 17 00:00:00 2001 From: Mark Paluch Date: Mon, 17 Apr 2023 12:11:23 +0200 Subject: [PATCH] Do not sort properties by their column name. We now no longer sort properties by their column name. Instead, we consider only primary keys, ordinals and tuple element ordinals in the order of: Partitioning primary keys (can be ordered with ordinals), partition primary keys (can be ordered with ordinals), all other columns. Tuples: Elements by their ordinal. Closes #1369 --- ...CassandraPersistentPropertyComparator.java | 22 +++--- ...aPrimaryKeyColumnAnnotationComparator.java | 2 - .../core/AsyncCassandraTemplateUnitTests.java | 8 +- ...ersistentEntitySchemaCreatorUnitTests.java | 37 +++++++++ .../core/CassandraTemplateUnitTests.java | 14 ++-- .../ReactiveCassandraTemplateUnitTests.java | 6 +- .../core/StatementFactoryUnitTests.java | 6 +- ...MappingCassandraConverterUDTUnitTests.java | 22 ++---- .../core/convert/SchemaFactoryUnitTests.java | 41 +++++++--- ...aredStatementCreatorIntegrationTests.java} | 4 +- .../AsyncCassandraTemplateUnitTests.java | 6 +- ...PersistentPropertyComparatorUnitTests.java | 78 ++++--------------- ...eyColumnAnnotationComparatorUnitTests.java | 59 ++++++++++++-- 13 files changed, 173 insertions(+), 132 deletions(-) rename spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/cql/support/{CachedPreparedStatementCreatorIntegrationTest.java => CachedPreparedStatementCreatorIntegrationTests.java} (91%) 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; } }