spring-projects#282 - Generate simplest SQL without condition in R2dbcQueryCreator

Author: rchigvintsev

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

@@ -10,7 +10,6 @@
 import org.springframework.data.repository.query.parser.Part;
 import org.springframework.data.repository.query.parser.PartTree;
 import org.springframework.data.util.Streamable;
-import org.springframework.util.Assert;
 
 /**
  * An {@link AbstractR2dbcQuery} implementation based on a {@link PartTree}.
@@ -21,7 +20,6 @@
  * @author Roman Chigvintsev
  */
 public class PartTreeR2dbcQuery extends AbstractR2dbcQuery {
-    private final ReactiveDataAccessStrategy dataAccessStrategy;
     private final RelationalParameters parameters;
     private final PartTree tree;
     private final R2dbcQueryCreator queryCreator;
@@ -39,16 +37,14 @@ public PartTreeR2dbcQuery(R2dbcQueryMethod method,
                               R2dbcConverter converter,
                               ReactiveDataAccessStrategy dataAccessStrategy) {
         super(method, databaseClient, converter);
-        Assert.notNull(dataAccessStrategy, "Data access strategy must not be null");
-        this.dataAccessStrategy = dataAccessStrategy;
         this.parameters = method.getParameters();
 
         RelationalEntityMetadata<?> entityMetadata = method.getEntityInformation();
 
         try {
             this.tree = new PartTree(method.getName(), entityMetadata.getJavaType());
             validate(tree, parameters, method.getName());
-            this.queryCreator = new R2dbcQueryCreator(tree);
+            this.queryCreator = new R2dbcQueryCreator(tree, entityMetadata, dataAccessStrategy);
         } catch (Exception e) {
             String message = String.format("Failed to create query for method %s! %s", method, e.getMessage());
             throw new IllegalArgumentException(message, e);

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

@@ -1,11 +1,21 @@
 package org.springframework.data.r2dbc.repository.query;
 
 import org.springframework.data.domain.Sort;
+import org.springframework.data.r2dbc.core.DatabaseClient;
+import org.springframework.data.r2dbc.core.ReactiveDataAccessStrategy;
+import org.springframework.data.relational.core.sql.Column;
+import org.springframework.data.relational.core.sql.SelectBuilder.SelectFromAndJoin;
+import org.springframework.data.relational.core.sql.StatementBuilder;
+import org.springframework.data.relational.core.sql.Table;
+import org.springframework.data.relational.core.sql.render.SqlRenderer;
+import org.springframework.data.relational.repository.query.RelationalEntityMetadata;
 import org.springframework.data.repository.query.parser.AbstractQueryCreator;
 import org.springframework.data.repository.query.parser.Part;
 import org.springframework.data.repository.query.parser.PartTree;
+import org.springframework.util.Assert;
 
 import java.util.Iterator;
+import java.util.List;
 import java.util.concurrent.locks.Condition;
 
 /**
@@ -14,13 +24,29 @@
  * @author Roman Chigvintsev
  */
 class R2dbcQueryCreator extends AbstractQueryCreator<BindableQuery, Condition> {
+    private final PartTree tree;
+    private final RelationalEntityMetadata<?> entityMetadata;
+    private final ReactiveDataAccessStrategy dataAccessStrategy;
+
     /**
-     * Creates new instance of this class with the given {@link PartTree}.
+     * Creates new instance of this class with the given {@link PartTree}, {@link RelationalEntityMetadata} and
+     * {@link ReactiveDataAccessStrategy}.
      *
      * @param tree part tree (must not be {@literal null})
+     * @param entityMetadata relational entity metadata (must not be {@literal null})
+     * @param dataAccessStrategy data access strategy (must not be {@literal null})
      */
-    public R2dbcQueryCreator(PartTree tree) {
+    public R2dbcQueryCreator(PartTree tree,
+                             RelationalEntityMetadata<?> entityMetadata,
+                             ReactiveDataAccessStrategy dataAccessStrategy) {
         super(tree);
+        this.tree = tree;
+
+        Assert.notNull(entityMetadata, "Relational entity metadata must not be null");
+        Assert.notNull(dataAccessStrategy, "Data access strategy must not be null");
+
+        this.entityMetadata = entityMetadata;
+        this.dataAccessStrategy = dataAccessStrategy;
     }
 
     @Override
@@ -38,8 +64,36 @@ protected Condition or(Condition condition, Condition s1) {
         throw new UnsupportedOperationException();
     }
 
+    /**
+     * Creates {@link BindableQuery} applying the given {@link Condition} and {@link Sort} definition.
+     *
+     * @param condition condition to be applied to query
+     * @param sort sort option to be applied to query (must not be {@literal null})
+     * @return new instance of {@link BindableQuery}
+     */
     @Override
     protected BindableQuery complete(Condition condition, Sort sort) {
-        throw new UnsupportedOperationException();
+        Table fromTable = Table.create(entityMetadata.getTableName());
+        List<Column> columns = fromTable.columns(dataAccessStrategy.getAllColumns(entityMetadata.getJavaType()));
+
+        SelectFromAndJoin selectBuilder = StatementBuilder.select(columns).from(fromTable);
+        if (tree.isExistsProjection()) {
+            selectBuilder.limit(1);
+        }
+
+        SqlRenderer sqlRenderer = SqlRenderer.create();
+        String sql = sqlRenderer.render(selectBuilder.build());
+
+        return new BindableQuery() {
+            @Override
+            public <T extends DatabaseClient.BindSpec<T>> T bind(T bindSpec) {
+                return bindSpec;
+            }
+
+            @Override
+            public String get() {
+                return sql;
+            }
+        };
     }
 }