feat: 暂存脑洞

fluent-sql-core/src/main/java/group/flyfish/fluent/chain/SQLImpl.java

@@ -3,11 +3,15 @@ package group.flyfish.fluent.chain;
 import group.flyfish.fluent.chain.common.AfterJoinSqlChain;
 import group.flyfish.fluent.chain.common.HandleSqlChain;
 import group.flyfish.fluent.chain.common.PreSqlChain;
+import group.flyfish.fluent.chain.execution.BoundEntity;
+import group.flyfish.fluent.chain.execution.BoundProxy;
+import group.flyfish.fluent.chain.execution.ReactiveBoundEntity;
 import group.flyfish.fluent.chain.select.AfterOrderSqlChain;
 import group.flyfish.fluent.chain.select.AfterWhereSqlChain;
 import group.flyfish.fluent.chain.select.PieceSqlChain;
 import group.flyfish.fluent.chain.update.AfterSetSqlChain;
 import group.flyfish.fluent.debug.FluentSqlDebugger;
+import group.flyfish.fluent.entity.DataPage;
 import group.flyfish.fluent.entity.SQLEntity;
 import group.flyfish.fluent.operations.FluentSQLOperations;
 import group.flyfish.fluent.query.JoinCandidate;
@@ -21,7 +25,10 @@ import group.flyfish.fluent.utils.sql.ConcatSegment;
 import group.flyfish.fluent.utils.sql.EntityNameUtils;
 import group.flyfish.fluent.utils.sql.SFunction;
 import group.flyfish.fluent.utils.sql.SqlNameUtils;
+import lombok.RequiredArgsConstructor;
 import org.springframework.util.Assert;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -149,14 +156,24 @@ final class SQLImpl extends ConcatSegment<SQLImpl> implements SQLOperations, Pre
         return concat("ON").concat(query);
     }
 
+    /**
+     * 下一步操作
+     *
+     * @return 结果
+     */
+    @Override
+    public HandleSqlChain then() {
+        return this;
+    }
+
     /**
      * 不带连接条件
      *
      * @return 处理链
      */
     @Override
-    public HandleSqlChain then() {
+    public <T> BoundProxy<T> next() {
-        return this;
+        return new DefaultBoundProxy<>(SQLEntity.of(primaryClass, this::sql, this::parsedParameters));
     }
 
     /**
@@ -187,57 +204,14 @@ final class SQLImpl extends ConcatSegment<SQLImpl> implements SQLOperations, Pre
     }
 
 
-    @Override
-    public <T> T one() {
-        return one(SqlNameUtils.cast(primaryClass));
-    }
-
-    /**
-     * 执行并获取结果
-     *
-     * @param clazz 结果类
-     * @param <T>   泛型
-     */
-    @Override
-    public <T> T one(Class<T> clazz) {
-        limit(1);
-        return SHARED_OPERATIONS.selectOne(entity.get(), clazz);
-    }
-
-    @Override
-    public <T> List<T> list() {
-        return list(SqlNameUtils.cast(primaryClass));
-    }
-
-    /**
-     * 执行并获取多条结果
-     *
-     * @param clazz 结果类
-     * @return 结果列表
-     */
-    @Override
-    public <T> List<T> list(Class<T> clazz) {
-        return SHARED_OPERATIONS.select(entity.get(), clazz);
-    }
-
-    /**
-     * 执行并获取更新条数
-     *
-     * @return 更新条数
-     */
-    @Override
-    public int execute() {
-        return SHARED_OPERATIONS.execute(toEntity());
-    }
-
     /**
      * 获取实体，做下一步的事情
      *
      * @return 结果
      */
     @Override
-    public SQLEntity toEntity() {
+    public <T> BoundProxy<T> as(Class<T> type) {
-        return SQLEntity.of(wrap(this::sql), wrap(this::parsedParameters));
+        return new DefaultBoundProxy<>(SQLEntity.of(type, wrap(this::sql), wrap(this::parsedParameters)));
     }
 
     /**
@@ -289,4 +263,71 @@ final class SQLImpl extends ConcatSegment<SQLImpl> implements SQLOperations, Pre
     public PieceSqlChain offset(int rows) {
         return concat("OFFSET").concat(String.valueOf(rows));
     }
+
+    @RequiredArgsConstructor
+    private static class DefaultBoundProxy<T> implements BoundProxy<T> {
+
+        private final SQLEntity<T> entity;
+
+        @Override
+        public BoundEntity<T> block() {
+            return new DefaultBoundEntity<>();
+        }
+
+        @Override
+        public ReactiveBoundEntity<T> reactive() {
+            return new DefaultReactiveBoundEntity<>();
+        }
+    }
+
+    /**
+     * 默认的绑定实体
+     *
+     * @param <T>
+     */
+    private static class DefaultBoundEntity<T> implements BoundEntity<T> {
+
+        @Override
+        public T one() {
+            return null;
+        }
+
+        @Override
+        public List<T> all() {
+            return List.of();
+        }
+
+        @Override
+        public DataPage<T> page() {
+            return null;
+        }
+
+        @Override
+        public int execute() {
+            return 0;
+        }
+    }
+
+    private static class DefaultReactiveBoundEntity<T> implements ReactiveBoundEntity<T> {
+
+        @Override
+        public Mono<T> one() {
+            return null;
+        }
+
+        @Override
+        public Flux<T> all() {
+            return null;
+        }
+
+        @Override
+        public Mono<DataPage<T>> page() {
+            return null;
+        }
+
+        @Override
+        public Mono<Integer> execute() {
+            return null;
+        }
+    }
 }

fluent-sql-core/src/main/java/group/flyfish/fluent/chain/common/ExecutableSql.java

@@ -1,6 +1,6 @@
 package group.flyfish.fluent.chain.common;
 
-import group.flyfish.fluent.entity.SQLEntity;
+import group.flyfish.fluent.chain.execution.BoundProxy;
 
 /**
  * 可执行的sql
@@ -10,16 +10,10 @@ import group.flyfish.fluent.entity.SQLEntity;
 public interface ExecutableSql {
 
     /**
-     * 执行并获取更新条数
+     * 进入下一步，以主表作为输出结果
      *
-     * @return 更新条数
+     * @param <T> 泛型
+     * @return 绑定操作
      */
-    int execute();
+    <T> BoundProxy<T> next();
-
-    /**
-     * 转换为SQL实体
-     *
-     * @return 结果
-     */
-    SQLEntity toEntity();
 }

fluent-sql-core/src/main/java/group/flyfish/fluent/chain/execution/BoundEntity.java

@@ -0,0 +1,49 @@
+package group.flyfish.fluent.chain.execution;
+
+import group.flyfish.fluent.entity.DataPage;
+import org.springframework.lang.NonNull;
+import org.springframework.lang.Nullable;
+
+import java.util.List;
+
+/**
+ * 已经绑定的实体
+ *
+ * @author wangyu
+ */
+public interface BoundEntity<T> {
+
+
+    /**
+     * 执行一条sql，并且序列化为对象
+     * 注意，如果查询不止一条，该方法仅返回第一条数据
+     * 如果没有结果，将返回null
+     *
+     * @return 查询结果
+     */
+    @Nullable
+    T one();
+
+    /**
+     * 执行一条sql，并且查询出所有行
+     *
+     * @return 返回的列表
+     */
+    @NonNull
+    List<T> all();
+
+    /**
+     * 分页查询
+     *
+     * @return 返回的分页对象
+     */
+    @NonNull
+    DataPage<T> page();
+
+    /**
+     * 直接执行sql，根据update count返回更新行数，如果是查询，永远返回0
+     *
+     * @return 更新行数
+     */
+    int execute();
+}

fluent-sql-core/src/main/java/group/flyfish/fluent/chain/execution/BoundProxy.java

@@ -0,0 +1,24 @@
+package group.flyfish.fluent.chain.execution;
+
+/**
+ * 绑定状态下的代理
+ *
+ * @author wangyu
+ */
+public interface BoundProxy<T> {
+
+    /**
+     * 阻塞的数据库操作
+     *
+     * @return 结果
+     */
+    BoundEntity<T> block();
+
+    /**
+     * 异步数据库逻辑
+     *
+     * @return 结果
+     */
+    ReactiveBoundEntity<T> reactive();
+
+}

fluent-sql-core/src/main/java/group/flyfish/fluent/chain/execution/ReactiveBoundEntity.java

@@ -0,0 +1,48 @@
+package group.flyfish.fluent.chain.execution;
+
+import group.flyfish.fluent.entity.DataPage;
+import org.springframework.lang.NonNull;
+import org.springframework.lang.Nullable;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * 已经绑定的异步实体
+ *
+ * @author wangyu
+ */
+public interface ReactiveBoundEntity<T> {
+
+    /**
+     * 执行一条sql，并且序列化为对象
+     * 注意，如果查询不止一条，该方法仅返回第一条数据
+     * 如果没有结果，将返回null
+     *
+     * @return 查询结果
+     */
+    @Nullable
+    Mono<T> one();
+
+    /**
+     * 执行一条sql，并且查询出所有行
+     *
+     * @return 返回的列表
+     */
+    @NonNull
+    Flux<T> all();
+
+    /**
+     * 分页查询
+     *
+     * @return 返回的分页对象
+     */
+    @NonNull
+    Mono<DataPage<T>> page();
+
+    /**
+     * 直接执行sql，根据update count返回更新行数，如果是查询，永远返回0
+     *
+     * @return 更新行数
+     */
+    Mono<Integer> execute();
+}

fluent-sql-core/src/main/java/group/flyfish/fluent/chain/select/FetchSqlChain.java

@@ -1,42 +1,16 @@
 package group.flyfish.fluent.chain.select;
 
 import group.flyfish.fluent.chain.common.ExecutableSql;
+import group.flyfish.fluent.chain.execution.BoundProxy;
 
 import java.util.List;
 
 public interface FetchSqlChain extends ExecutableSql {
 
     /**
-     * 执行并获取结果
+     * 转换为SQL实体
      *
-     * @param <T> 泛型
+     * @return 结果
-     * @return 单一结果值
      */
-    <T> T one();
+    <T> BoundProxy<T> as(Class<T> type);
-
-    /**
-     * 执行并获取结果
-     *
-     * @param clazz 结果类
-     * @param <T>   泛型
-     * @return 单一结果值
-     */
-    <T> T one(Class<T> clazz);
-
-    /**
-     * 执行并获取多条结果，以主表class为结果
-     *
-     * @param <T> 结果泛型
-     * @return 结果列表
-     */
-    <T> List<T> list();
-
-    /**
-     * 执行并获取多条结果
-     *
-     * @param clazz 结果类
-     * @param <T>   结果泛型
-     * @return 结果列表
-     */
-    <T> List<T> list(Class<T> clazz);
 }

fluent-sql-core/src/main/java/group/flyfish/fluent/entity/SQLEntity.java

@@ -1,38 +1,51 @@
 package group.flyfish.fluent.entity;
 
+import lombok.Getter;
+import org.springframework.lang.NonNull;
+
 import java.util.function.Supplier;
 
 /**
  * sql运行实体
  *
+ * @param <T> 结果类型泛型
  * @author wangyu
  */
-public class SQLEntity {
+public class SQLEntity<T> {
 
     private static final Supplier<Object[]> EMPTY_PARAMETERS = () -> new Object[]{};
 
     // sql提供者
-    private Supplier<String> sqlProvider;
+    @NonNull
+    private final Supplier<String> sql;
 
     // sql参数表提供者
-    private Supplier<Object[]> parametersProvider;
+    private final Supplier<Object[]> parameters;
 
-    public static SQLEntity of(Supplier<String> sqlProvider) {
+    // 结果类型
-        return of(sqlProvider, EMPTY_PARAMETERS);
+    @NonNull
+    @Getter
+    private final Class<T> resultType;
+
+    private SQLEntity(Class<T> resultType, Supplier<String> sql, Supplier<Object[]> parameters) {
+        this.resultType = resultType;
+        this.sql = sql;
+        this.parameters = parameters;
     }
 
-    public static SQLEntity of(Supplier<String> sqlProvider, Supplier<Object[]> parametersProvider) {
+    public static <T> SQLEntity<T> of(Class<T> resultType, Supplier<String> sqlProvider) {
-        SQLEntity entity = new SQLEntity();
+        return of(resultType, sqlProvider, EMPTY_PARAMETERS);
-        entity.sqlProvider = sqlProvider;
+    }
-        entity.parametersProvider = parametersProvider;
+
-        return entity;
+    public static <T> SQLEntity<T> of(Class<T> resultType, Supplier<String> sql, Supplier<Object[]> parameters) {
+        return new SQLEntity<T>(resultType, sql, parameters);
     }
 
     public String getSql() {
-        return sqlProvider.get();
+        return sql.get();
     }
 
     public Object[] getParameters() {
-        return parametersProvider.get();
+        return parameters.get();
     }
 }

fluent-sql-core/src/main/java/group/flyfish/fluent/operations/FluentSQLOperations.java

@@ -19,32 +19,29 @@ public interface FluentSQLOperations {
      * 如果没有结果，将返回null
      *
      * @param entity sql实体
-     * @param clazz  目标类型
      * @param <T>    目标泛型
      * @return 查询结果
      */
     @Nullable
-    <T> T selectOne(SQLEntity entity, Class<T> clazz);
+    <T> T selectOne(SQLEntity<T> entity);
 
     /**
      * 执行一条sql，并且查询出所有行
      *
      * @param entity sql实体
-     * @param clazz  目标类型
      * @param <T>    目标泛型
      * @return 返回的列表
      */
-    <T> List<T> select(SQLEntity entity, Class<T> clazz);
+    <T> List<T> select(SQLEntity<T> entity);
 
     /**
      * 分页查询
      *
      * @param entity sql实体
-     * @param clazz  目标类型
      * @param <T>    目标泛型
      * @return 返回的分页对象
      */
-    <T> DataPage<T> selectPage(SQLEntity entity, Class<T> clazz);
+    <T> DataPage<T> selectPage(SQLEntity<T> entity);
 
     /**
      * 直接执行sql，根据update count返回更新行数，如果是查询，永远返回0
@@ -52,5 +49,5 @@ public interface FluentSQLOperations {
      * @param entity sql实体
      * @return 更新行数
      */
-    int execute(SQLEntity entity);
+    <T> int execute(SQLEntity<T> entity);
 }

fluent-sql-core/src/main/java/group/flyfish/fluent/operations/ReactiveFluentSQLOperations.java

@@ -19,32 +19,29 @@ public interface ReactiveFluentSQLOperations {
      * 如果没有结果，将返回null
      *
      * @param entity sql实体
-     * @param clazz  目标类型
      * @param <T>    目标泛型
      * @return 查询结果
      */
     @Nullable
-    <T> Mono<T> selectOne(SQLEntity entity, Class<T> clazz);
+    <T> Mono<T> selectOne(SQLEntity<T> entity);
 
     /**
      * 执行一条sql，并且查询出所有行
      *
      * @param entity sql实体
-     * @param clazz  目标类型
      * @param <T>    目标泛型
      * @return 返回的列表
      */
-    <T> Flux<T> select(SQLEntity entity, Class<T> clazz);
+    <T> Flux<T> select(SQLEntity<T> entity);
 
     /**
      * 分页查询
      *
      * @param entity sql实体
-     * @param clazz  目标类型
      * @param <T>    目标泛型
      * @return 返回的分页对象
      */
-    <T> Mono<DataPage<T>> selectPage(SQLEntity entity, Class<T> clazz);
+    <T> Mono<DataPage<T>> selectPage(SQLEntity<T> entity);
 
     /**
      * 直接执行sql，根据update count返回更新行数，如果是查询，永远返回0
@@ -52,5 +49,5 @@ public interface ReactiveFluentSQLOperations {
      * @param entity sql实体
      * @return 更新行数
      */
-    Mono<Integer> execute(SQLEntity entity);
+    <T> Mono<Integer> execute(SQLEntity<T> entity);
 }