spring-projects#282 - Add support of 'BETWEEN' operator

Author: rchigvintsev

Diff for: src/main/java/org/springframework/data/r2dbc/repository/query/ConditionFactory.java

@@ -15,6 +15,7 @@
  */
 package org.springframework.data.r2dbc.repository.query;
 
+import org.jetbrains.annotations.NotNull;
 import org.springframework.data.mapping.PropertyPath;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.r2dbc.repository.query.ParameterMetadataProvider.ParameterMetadata;
@@ -56,31 +57,43 @@ class ConditionFactory {
     public Condition createCondition(Part part) {
         Part.Type type = part.getType();
         switch (type) {
-            case SIMPLE_PROPERTY: {
-                PropertyPath propertyPath = part.getProperty();
-                @SuppressWarnings("unchecked")
-                RelationalPersistentEntity<?> persistentEntity
-                        = mappingContext.getRequiredPersistentEntity(propertyPath.getOwningType());
-                RelationalPersistentProperty persistentProperty
-                        = persistentEntity.getRequiredPersistentProperty(propertyPath.getSegment());
-
-                Table table = SQL.table(persistentEntity.getTableName());
-                Column column = SQL.column(persistentProperty.getColumnName(), table);
+            case BETWEEN: {
+                Expression pathExpression = createPropertyPathExpression(part.getProperty());
+                BindMarker firstBindMarker = createBindMarker(parameterMetadataProvider.next(part));
+                BindMarker secondBindMarker = createBindMarker(parameterMetadataProvider.next(part));
 
+                // TODO: why do not we have BETWEEN condition?
+                return Conditions.isGreaterOrEqualTo(pathExpression, firstBindMarker)
+                        .and(Conditions.isLessOrEqualTo(pathExpression, secondBindMarker));
+            }
+            case SIMPLE_PROPERTY: {
+                Expression pathExpression = createPropertyPathExpression(part.getProperty());
                 ParameterMetadata parameterMetadata = parameterMetadataProvider.next(part);
                 if (parameterMetadata.isIsNullParameter()) {
-                    return IsNull.create(column);
-                }
-
-                BindMarker bindMarker;
-                if (parameterMetadata.getName() != null) {
-                    bindMarker = SQL.bindMarker(parameterMetadata.getName());
-                } else {
-                    bindMarker = SQL.bindMarker();
+                    return Conditions.isNull(pathExpression);
                 }
-                return Conditions.isEqual(column, bindMarker);
+                return Conditions.isEqual(pathExpression, createBindMarker(parameterMetadata));
             }
         }
         throw new UnsupportedOperationException("Creating conditions for type " + type + " is unsupported");
     }
+
+    @NotNull
+    private Expression createPropertyPathExpression(PropertyPath propertyPath) {
+        @SuppressWarnings("unchecked")
+        RelationalPersistentEntity<?> persistentEntity
+                = mappingContext.getRequiredPersistentEntity(propertyPath.getOwningType());
+        RelationalPersistentProperty persistentProperty
+                = persistentEntity.getRequiredPersistentProperty(propertyPath.getSegment());
+        Table table = SQL.table(persistentEntity.getTableName());
+        return SQL.column(persistentProperty.getColumnName(), table);
+    }
+
+    @NotNull
+    private BindMarker createBindMarker(ParameterMetadata parameterMetadata) {
+        if (parameterMetadata.getName() != null) {
+            return SQL.bindMarker(parameterMetadata.getName());
+        }
+        return SQL.bindMarker();
+    }
 }

Diff for: src/test/java/org/springframework/data/r2dbc/repository/query/PartTreeR2dbcQueryIntegrationTests.java

@@ -41,6 +41,7 @@
 import reactor.core.publisher.Mono;
 
 import java.lang.reflect.Method;
+import java.util.Date;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.*;
@@ -51,7 +52,10 @@
 @RunWith(MockitoJUnitRunner.class)
 public class PartTreeR2dbcQueryIntegrationTests {
     private static final String TABLE = "users";
-    private static final String ALL_FIELDS = TABLE + ".id, " + TABLE + ".first_name, " + TABLE + ".last_name";
+    private static final String ALL_FIELDS = TABLE + ".id, "
+            + TABLE + ".first_name, "
+            + TABLE + ".last_name, "
+            + TABLE + ".date_of_birth";
 
     @Mock
     private ConnectionFactory connectionFactory;
@@ -112,7 +116,7 @@ public void createsQueryWithLimitForExistsProjection() throws Exception {
 
     @Test
     public void createsQueryToFindAllEntitiesByTwoStringAttributes() throws Exception {
-        R2dbcQueryMethod queryMethod = getQueryMethod("findByLastNameAndFirstName", String.class, String.class);
+        R2dbcQueryMethod queryMethod = getQueryMethod("findAllByLastNameAndFirstName", String.class, String.class);
         PartTreeR2dbcQuery r2dbcQuery = new PartTreeR2dbcQuery(queryMethod, databaseClient, r2dbcConverter,
                 dataAccessStrategy);
         BindableQuery bindableQuery = r2dbcQuery.createQuery(getAccessor(queryMethod, new Object[]{"Doe", "John"}));
@@ -123,7 +127,7 @@ public void createsQueryToFindAllEntitiesByTwoStringAttributes() throws Exceptio
 
     @Test
     public void createsQueryToFindAllEntitiesByOneOfTwoStringAttributes() throws Exception {
-        R2dbcQueryMethod queryMethod = getQueryMethod("findByLastNameOrFirstName", String.class, String.class);
+        R2dbcQueryMethod queryMethod = getQueryMethod("findAllByLastNameOrFirstName", String.class, String.class);
         PartTreeR2dbcQuery r2dbcQuery = new PartTreeR2dbcQuery(queryMethod, databaseClient, r2dbcConverter,
                 dataAccessStrategy);
         BindableQuery bindableQuery = r2dbcQuery.createQuery(getAccessor(queryMethod, new Object[]{"Doe", "John"}));
@@ -132,6 +136,18 @@ public void createsQueryToFindAllEntitiesByOneOfTwoStringAttributes() throws Exc
         assertThat(bindableQuery.get()).isEqualTo(expectedSql);
     }
 
+    @Test
+    public void createsQueryToFindAllEntitiesByDateAttributeBetween() throws Exception {
+        R2dbcQueryMethod queryMethod = getQueryMethod("findAllByDateOfBirthBetween", Date.class, Date.class);
+        PartTreeR2dbcQuery r2dbcQuery = new PartTreeR2dbcQuery(queryMethod, databaseClient, r2dbcConverter,
+                dataAccessStrategy);
+        RelationalParametersParameterAccessor accessor = getAccessor(queryMethod, new Object[]{null, new Date()});
+        BindableQuery bindableQuery = r2dbcQuery.createQuery(accessor);
+        String expectedSql = "SELECT " + ALL_FIELDS + " FROM " + TABLE
+                + " WHERE " + TABLE + ".date_of_birth >= ? AND " + TABLE + ".date_of_birth <= ?";
+        assertThat(bindableQuery.get()).isEqualTo(expectedSql);
+    }
+
     private R2dbcQueryMethod getQueryMethod(String methodName, Class<?>... parameterTypes) throws Exception {
         Method method = UserRepository.class.getMethod(methodName, parameterTypes);
         return new R2dbcQueryMethod(method, new DefaultRepositoryMetadata(UserRepository.class),
@@ -145,11 +161,13 @@ private RelationalParametersParameterAccessor getAccessor(R2dbcQueryMethod query
     private interface UserRepository extends Repository<User, Long> {
         Flux<User> findAllByFirstName(String firstName);
 
-        Flux<User> findByLastNameAndFirstName(String lastName, String firstName);
+        Flux<User> findAllByLastNameAndFirstName(String lastName, String firstName);
 
-        Flux<User> findByLastNameOrFirstName(String lastName, String firstName);
+        Flux<User> findAllByLastNameOrFirstName(String lastName, String firstName);
 
         Mono<Boolean> existsByFirstName(String firstName);
+
+        Flux<User> findAllByDateOfBirthBetween(Date from, Date to);
     }
 
     @Table("users")
@@ -159,5 +177,6 @@ private static class User {
         private Long id;
         private String firstName;
         private String lastName;
+        private Date dateOfBirth;
     }
 }