wybaby168/fluent-sql
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: 暂存脑洞

Browse Source
This commit is contained in:
wangyu 2024-07-11 23:33:30 +08:00
parent a2afbd8753
commit 1b61e13205
9 changed files with 251 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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() {
return this;
public <T> BoundProxy<T> next() {
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() {
return SQLEntity.of(wrap(this::sql), wrap(this::parsedParameters));
public <T> BoundProxy<T> as(Class<T> type) {
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;
}
}
}

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

@ -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();
/**
* 转换为SQL实体
*
* @return 结果
*/
SQLEntity toEntity();
<T> BoundProxy<T> next();
}

49
fluent-sql-core/src/main/java/group/flyfish/fluent/chain/execution/BoundEntity.java Normal file
View File

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

24
fluent-sql-core/src/main/java/group/flyfish/fluent/chain/execution/BoundProxy.java Normal file
View File

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

48
fluent-sql-core/src/main/java/group/flyfish/fluent/chain/execution/ReactiveBoundEntity.java Normal file
View File

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

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

@ -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();
/**
* 执行并获取结果
*
* @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);
<T> BoundProxy<T> as(Class<T> type);
}

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

@ -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) {
SQLEntity entity = new SQLEntity();
entity.sqlProvider = sqlProvider;
entity.parametersProvider = parametersProvider;
return entity;
public static <T> SQLEntity<T> of(Class<T> resultType, Supplier<String> sqlProvider) {
return of(resultType, sqlProvider, EMPTY_PARAMETERS);
}
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();
}
}

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

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

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

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