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

Do not sort properties by their column name.

Browse Source 
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
This commit is contained in:
Mark Paluch
2023-04-17 12:11:23 +02:00
parent 800b6b93e8
commit b793c94eed
13 changed files with 173 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/mapping/CassandraPersistentPropertyComparator.java
View File

@@ -45,16 +45,6 @@ public enum CassandraPersistentPropertyComparator implements Comparator<Cassandr
@Override
public int compare(CassandraPersistentProperty left, CassandraPersistentProperty right) {
if (left == null && right == null) {
return 0;
} else if (left != null && right == null) {
return 1;
} else if (left == null) {
return -1;
} else if (left.equals(right)) {
return 0;
}
boolean leftIsCompositePrimaryKey = left.isCompositePrimaryKey();
boolean rightIsCompositePrimaryKey = right.isCompositePrimaryKey();
@@ -86,7 +76,15 @@ public enum CassandraPersistentPropertyComparator implements Comparator<Cassandr
return 1;
}
// else, neither property is a composite primary key nor a primary key; compare @Column annotations
return left.getRequiredColumnName().toString().compareTo(right.getRequiredColumnName().toString());
Element leftAnnotation = left.findAnnotation(Element.class);
Element rightAnnotation = right.findAnnotation(Element.class);
if (leftAnnotation != null && rightAnnotation != null) {
return Integer.compare(leftAnnotation.value(), rightAnnotation.value());
}
// else, neither property is a composite primary key nor a primary key; there is nothing more so from that
// perspective, columns are equal.
return 0;
}
}

2
spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/mapping/CassandraPrimaryKeyColumnAnnotationComparator.java
View File

@@ -44,8 +44,6 @@ public enum CassandraPrimaryKeyColumnAnnotationComparator implements Comparator<
int comparison = left.type().compareTo(right.type());
comparison = (comparison != 0 ? comparison : Integer.compare(left.ordinal(), right.ordinal()));
comparison = (comparison != 0 ? comparison : left.name().compareTo(right.name()));
comparison = (comparison != 0 ? comparison : left.ordering().compareTo(right.ordering()));
return comparison;
}

8
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/AsyncCassandraTemplateUnitTests.java
View File

@@ -319,7 +319,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);
}
@@ -341,7 +341,7 @@ class AsyncCassandraTemplateUnitTests {
assertThat(getUninterruptibly(future)).isNotSameAs(user);
verify(session).executeAsync(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
@@ -357,7 +357,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);
}
@@ -412,7 +412,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);
}

37
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/CassandraPersistentEntitySchemaCreatorUnitTests.java
View File

@@ -19,6 +19,7 @@ import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@@ -36,10 +37,15 @@ import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import org.springframework.data.cassandra.core.convert.SchemaFactory;
import org.springframework.data.cassandra.core.cql.CqlOperations;
import org.springframework.data.cassandra.core.cql.PrimaryKeyType;
import org.springframework.data.cassandra.core.cql.keyspace.CreateUserTypeSpecification;
import org.springframework.data.cassandra.core.cql.keyspace.UserTypeNameSpecification;
import org.springframework.data.cassandra.core.mapping.CassandraMappingContext;
import org.springframework.data.cassandra.core.mapping.CassandraPersistentEntity;
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.convert.CustomConversions;
@@ -182,6 +188,19 @@ class CassandraPersistentEntitySchemaCreatorUnitTests extends CassandraPersisten
verify(operations).execute("CREATE INDEX ON indexedentity (firstname);");
}
@Test // DATACASS-213
void foo() {
context.getPersistentEntity(Person.class);
CassandraPersistentEntitySchemaCreator schemaCreator = new CassandraPersistentEntitySchemaCreator(context,
adminOperations);
schemaCreator.createTables(false);
// verify(operations).execute("CREATE INDEX ON indexedentity (firstname);");
}
private void verifyTypesGetCreatedInOrderFor(String... typenames) {
ArgumentCaptor<String> 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;
}
}

14
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/CassandraTemplateUnitTests.java
View File

@@ -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);
}

6
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/ReactiveCassandraTemplateUnitTests.java
View File

@@ -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);
}

6
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/StatementFactoryUnitTests.java
View File

@@ -317,7 +317,7 @@ class StatementFactoryUnitTests {
StatementBuilder<RegularInsert> 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

22
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/convert/MappingCassandraConverterUDTUnitTests.java
View File

@@ -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

41
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/convert/SchemaFactoryUnitTests.java
View File

@@ -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;
}
}

4
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/cql/support/CachedPreparedStatementCreatorIntegrationTest.java → spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/cql/support/CachedPreparedStatementCreatorIntegrationTests.java
View File

@@ -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();
}
}

6
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/legacy/AsyncCassandraTemplateUnitTests.java
View File

@@ -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);
}

78
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/mapping/CassandraPersistentPropertyComparatorUnitTests.java
View File

@@ -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;
}
}

59
spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/mapping/CassandraPrimaryKeyColumnAnnotationComparatorUnitTests.java
View File

@@ -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;
}
}