update 优化代码注释

This commit is contained in:
疯狂的狮子Li
2026-05-15 14:32:59 +08:00
parent bf70c2c673
commit 70dacfb379
48 changed files with 1868 additions and 272 deletions
@@ -18,6 +18,11 @@ public record DataPermissionAccess(Set<String> perms, Set<String> roleKeys) impl
public static final DataPermissionAccess EMPTY = new DataPermissionAccess(Set.of(), Set.of());
/**
* 是否存在数据权限约束。
*
* @return true 存在权限约束 false 不存在权限约束
*/
public boolean constrained() {
return CollUtil.isNotEmpty(perms) || CollUtil.isNotEmpty(roleKeys);
}
@@ -25,10 +25,10 @@ import java.util.function.Function;
import java.util.function.Predicate;
/**
* Mapper ? Lambda CRUD ??????
* Mapper 级 Lambda CRUD 链式包装器。
*
* @param <T> table ??
* @param <V> vo ??
* @param <T> table 泛型
* @param <V> vo 泛型
* @author Lion Li
*/
public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, LambdaCrudChainWrapper<T, V>>
@@ -40,6 +40,11 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
private final List<String> sqlSet;
private SharedString sqlSelect = new SharedString();
/**
* 构造 Mapper 级 Lambda CRUD 链式包装器。
*
* @param crudMapper Mapper 对象
*/
public LambdaCrudChainWrapper(BaseMapperPlus<T, V> crudMapper) {
this.crudMapper = crudMapper;
super.setEntityClass(crudMapper.currentModelClass());
@@ -47,6 +52,22 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
this.sqlSet = new ArrayList<>();
}
/**
* 构造 Mapper 级 Lambda CRUD 链式包装器实例。
*
* @param crudMapper Mapper 对象
* @param entity 实体对象
* @param entityClass 实体类型
* @param sqlSelect 查询字段 SQL 片段
* @param sqlSet 更新 set SQL 片段集合
* @param paramNameSeq 参数名称序列
* @param paramNameValuePairs 参数名称与参数值映射
* @param mergeSegments 查询条件表达式
* @param paramAlias 参数别名
* @param lastSql SQL 尾部片段
* @param sqlComment SQL 注释片段
* @param sqlFirst SQL 起始片段
*/
LambdaCrudChainWrapper(BaseMapperPlus<T, V> crudMapper, T entity, Class<T> entityClass, SharedString sqlSelect,
List<String> sqlSet, AtomicInteger paramNameSeq, Map<String, Object> paramNameValuePairs,
MergeSegments mergeSegments, SharedString paramAlias, SharedString lastSql,
@@ -65,6 +86,13 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
this.sqlFirst = sqlFirst;
}
/**
* 按条件选择查询字段。
*
* @param condition 是否选择字段
* @param columns 查询字段集合
* @return this
*/
@Override
public LambdaCrudChainWrapper<T, V> select(boolean condition, List<SFunction<T, ?>> columns) {
if (condition && CollectionUtils.isNotEmpty(columns)) {
@@ -73,16 +101,36 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
return typedThis;
}
/**
* 选择查询字段。
*
* @param columns 查询字段
* @return this
*/
@SafeVarargs
public final LambdaCrudChainWrapper<T, V> select(SFunction<T, ?>... columns) {
return select(true, CollectionUtils.toList(columns));
}
/**
* 按条件选择查询字段。
*
* @param condition 是否选择字段
* @param columns 查询字段
* @return this
*/
@SafeVarargs
public final LambdaCrudChainWrapper<T, V> select(boolean condition, SFunction<T, ?>... columns) {
return select(condition, CollectionUtils.toList(columns));
}
/**
* 按字段过滤条件选择查询字段。
*
* @param entityClass 实体类型
* @param predicate 字段过滤条件
* @return this
*/
@Override
public LambdaCrudChainWrapper<T, V> select(Class<T> entityClass, Predicate<TableFieldInfo> predicate) {
if (entityClass == null) {
@@ -95,11 +143,25 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
return typedThis;
}
/**
* 获取查询字段 SQL 片段。
*
* @return 查询字段 SQL 片段
*/
@Override
public String getSqlSelect() {
return sqlSelect.getStringValue();
}
/**
* 按条件设置更新字段。
*
* @param condition 是否设置该字段
* @param column 字段
* @param val 字段值
* @param mapping 参数映射
* @return this
*/
@Override
public LambdaCrudChainWrapper<T, V> set(boolean condition, SFunction<T, ?> column, Object val, String mapping) {
return maybeDo(condition, () -> {
@@ -109,10 +171,10 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
}
/**
* ??? null ????????
* 值不为 null 时设置更新字段。
*
* @param column ??
* @param value ?
* @param column 字段
* @param value 值
* @return this
*/
public LambdaCrudChainWrapper<T, V> setIfPresent(SFunction<T, ?> column, Object value) {
@@ -120,21 +182,37 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
}
/**
* ?????????????
* 文本不为空时设置更新字段。
*
* @param column ??
* @param value ?
* @param column 字段
* @param value 值
* @return this
*/
public LambdaCrudChainWrapper<T, V> setIfText(SFunction<T, ?> column, String value) {
return set(org.dromara.common.core.utils.StringUtils.isNotBlank(value), column, value);
}
/**
* 按条件设置自定义 SQL 更新片段。
*
* @param condition 是否设置该片段
* @param setSql SQL 更新片段
* @param params SQL 片段参数
* @return this
*/
@Override
public LambdaCrudChainWrapper<T, V> setSql(boolean condition, String setSql, Object... params) {
return maybeDo(condition && StringUtils.isNotBlank(setSql), () -> sqlSet.add(formatSqlMaybeWithParam(setSql, params)));
}
/**
* 按条件设置字段自增。
*
* @param condition 是否设置该字段
* @param column 字段
* @param val 自增值
* @return this
*/
@Override
public LambdaCrudChainWrapper<T, V> setIncrBy(boolean condition, SFunction<T, ?> column, Number val) {
return maybeDo(condition, () -> {
@@ -144,6 +222,14 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
});
}
/**
* 按条件设置字段自减。
*
* @param condition 是否设置该字段
* @param column 字段
* @param val 自减值
* @return this
*/
@Override
public LambdaCrudChainWrapper<T, V> setDecrBy(boolean condition, SFunction<T, ?> column, Number val) {
return maybeDo(condition, () -> {
@@ -153,6 +239,11 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
});
}
/**
* 获取更新 set SQL 片段。
*
* @return 更新 set SQL 片段
*/
@Override
public String getSqlSet() {
if (CollectionUtils.isEmpty(sqlSet)) {
@@ -162,7 +253,7 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
}
/**
* ?????? Wrapper?
* 获取查询条件 Wrapper。
*
* @return this
*/
@@ -170,20 +261,42 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
return typedThis;
}
/**
* 添加 FIND_IN_SET 条件。
*
* @param value 匹配值
* @param column 字段
* @return this
*/
public LambdaCrudChainWrapper<T, V> findInSet(Object value, SFunction<T, ?> column) {
return findInSet(true, value, column);
}
/**
* 添加 FIND_IN_SET 条件。
*
* @param condition 是否添加该条件
* @param value 匹配值
* @param column 字段
* @return this
*/
public LambdaCrudChainWrapper<T, V> findInSet(boolean condition, Object value, SFunction<T, ?> column) {
return findInSet(condition, value, columnToString(column));
}
/**
* 值不为空时添加 FIND_IN_SET 条件。
*
* @param value 匹配值
* @param column 字段
* @return this
*/
public LambdaCrudChainWrapper<T, V> findInSetIfPresent(Object value, SFunction<T, ?> column) {
return findInSet(value != null, value, column);
}
/**
* ???? Wrapper?
* 获取当前 Wrapper。
*
* @return this
*/
@@ -192,83 +305,83 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
}
/**
* ???????
* 查询实体列表。
*
* @return ????
* @return 实体列表
*/
public List<T> list() {
return crudMapper.selectList(typedThis);
}
/**
* ?????????
* 查询实体分页记录。
*
* @param page ????
* @return ??????
* @param page 分页条件
* @return 实体分页记录
*/
public List<T> list(IPage<T> page) {
return crudMapper.selectList(page, typedThis);
}
/**
* ?? VO ???
* 查询 VO 列表。
*
* @return VO ??
* @return VO 列表
*/
public List<V> voList() {
return crudMapper.selectVoList(typedThis);
}
/**
* ?????????
* 查询单列对象列表。
*
* @return ??????
* @return 单列对象列表
*/
public List<Object> objs() {
return crudMapper.selectObjs(typedThis);
}
/**
* ??????????????
* 查询单列对象列表并转换类型。
*
* @param mapper ????
* @param <C> ??????
* @return ??????
* @param mapper 转换函数
* @param <C> 转换后的类型
* @return 单列对象列表
*/
public <C> List<C> objs(Function<? super Object, C> mapper) {
return crudMapper.selectObjs(typedThis, mapper);
}
/**
* ???????
* 查询单个实体。
*
* @return ??
* @return 实体
*/
public T one() {
return crudMapper.selectOne(typedThis);
}
/**
* ???????
* 查询单个实体。
*
* @param throwEx ???????????
* @return ??
* @param throwEx 查询到多条时是否抛异常
* @return 实体
*/
public T one(boolean throwEx) {
return crudMapper.selectOne(typedThis, throwEx);
}
/**
* ?????? Optional?
* 查询单个实体 Optional。
*
* @return Optional ??
* @return Optional 实体
*/
public Optional<T> oneOpt() {
return Optional.ofNullable(one());
}
/**
* ???? VO?
* 查询单个 VO。
*
* @return VO
*/
@@ -277,9 +390,9 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
}
/**
* ???? VO?
* 查询单个 VO。
*
* @param throwEx ???????????
* @param throwEx 查询到多条时是否抛异常
* @return VO
*/
public V voOne(boolean throwEx) {
@@ -287,101 +400,106 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
}
/**
* ?????
* 查询数量。
*
* @return ??
* @return 数量
*/
public Long count() {
return crudMapper.selectCount(typedThis);
}
/**
* ???????
* 判断是否存在。
*
* @return ????
* @return 是否存在
*/
public boolean exists() {
return crudMapper.exists(typedThis);
}
/**
* ???????
* 查询实体分页。
*
* @param page ????
* @param <P> ????
* @return ????
* @param page 分页条件
* @param <P> 分页类型
* @return 实体分页
*/
public <P extends IPage<T>> P page(P page) {
return crudMapper.selectPage(page, typedThis);
}
/**
* ?? VO ???
* 查询 VO 分页。
*
* @param page ????
* @param <P> ????
* @return VO ??
* @param page 分页条件
* @param <P> 分页类型
* @return VO 分页
*/
public <P extends IPage<V>> P voPage(IPage<T> page) {
return crudMapper.selectVoPage(page, typedThis);
}
/**
* ?????
* 删除数据。
*
* @return ??????
* @return 是否删除成功
*/
public boolean delete() {
return deleteCount() > 0;
}
/**
* ?????
* 删除数据。
*
* @return ????
* @return 影响行数
*/
public int deleteCount() {
return crudMapper.delete(typedThis);
}
/**
* ?? set ???????
* 使用 set 片段更新数据。
*
* @return ??????
* @return 是否更新成功
*/
public boolean update() {
return updateCount() > 0;
}
/**
* ??????????????
* 使用实体和查询条件更新数据。
*
* @param entity ??
* @return ??????
* @param entity 实体
* @return 是否更新成功
*/
public boolean update(T entity) {
return updateCount(entity) > 0;
}
/**
* ?? set ???????
* 使用 set 片段更新数据。
*
* @return ????
* @return 影响行数
*/
public int updateCount() {
return crudMapper.update(typedThis);
}
/**
* ??????????????
* 使用实体和查询条件更新数据。
*
* @param entity ??
* @return ????
* @param entity 实体
* @return 影响行数
*/
public int updateCount(T entity) {
return crudMapper.update(entity, typedThis);
}
/**
* 创建新的链式包装器实例。
*
* @return 新的链式包装器实例
*/
@Override
protected LambdaCrudChainWrapper<T, V> instance() {
return new LambdaCrudChainWrapper<>(crudMapper, getEntity(), getEntityClass(), null, null, paramNameSeq,
@@ -389,6 +507,9 @@ public class LambdaCrudChainWrapper<T, V> extends AbstractLambdaWrapper<T, Lambd
SharedString.emptyString());
}
/**
* 清空当前 Wrapper 状态。
*/
@Override
public void clear() {
super.clear();
@@ -6,7 +6,6 @@ import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.dromara.common.core.exception.ServiceException;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.core.utils.sql.SqlUtil;
@@ -22,7 +21,6 @@ import java.util.List;
* @author Lion Li
*/
@Data
@NoArgsConstructor
public class PageQuery implements Serializable {
@Serial
@@ -116,11 +114,22 @@ public class PageQuery implements Serializable {
return list;
}
/**
* 获取当前页起始行号。
*
* @return 起始行号
*/
@JsonIgnore
public Integer getFirstNum() {
return (pageNum - 1) * pageSize;
}
/**
* 构造分页查询对象。
*
* @param pageSize 分页大小
* @param pageNum 当前页码
*/
public PageQuery(Integer pageSize, Integer pageNum) {
this.pageSize = pageSize;
this.pageNum = pageNum;
@@ -10,411 +10,979 @@ import java.util.function.BiPredicate;
import java.util.function.Consumer;
/**
* LambdaQueryWrapper ????????
* LambdaQueryWrapper 条件构造辅助类。
*
* @param <T> ????
* @param <T> 实体类型
* @author Lion Li
*/
public final class LambdaQueryBuilder<T> implements LambdaQueryCondition<T, LambdaQueryBuilder<T>> {
/**
* MyBatis-Plus Lambda 查询包装器。
*/
private final LambdaQueryWrapper<T> wrapper;
/**
* 构造 Lambda 查询构造辅助对象。
*
* @param wrapper Lambda 查询包装器
*/
LambdaQueryBuilder(LambdaQueryWrapper<T> wrapper) {
this.wrapper = wrapper;
}
/**
* 指定查询字段。
*
* @param columns 查询字段
* @return 当前查询构造辅助对象
*/
@SafeVarargs
public final LambdaQueryBuilder<T> select(SFunction<T, ?>... columns) {
wrapper.select(columns);
return this;
}
/**
* 添加等于条件。
*
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> eq(SFunction<T, ?> column, Object value) {
wrapper.eq(column, value);
return this;
}
/**
* 添加等于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> eq(boolean condition, SFunction<T, ?> column, Object value) {
wrapper.eq(condition, column, value);
return this;
}
/**
* 添加不等于条件。
*
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> ne(SFunction<T, ?> column, Object value) {
wrapper.ne(column, value);
return this;
}
/**
* 添加不等于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> ne(boolean condition, SFunction<T, ?> column, Object value) {
wrapper.ne(condition, column, value);
return this;
}
/**
* 添加大于条件。
*
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> gt(SFunction<T, ?> column, Object value) {
wrapper.gt(column, value);
return this;
}
/**
* 添加大于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> gt(boolean condition, SFunction<T, ?> column, Object value) {
wrapper.gt(condition, column, value);
return this;
}
/**
* 添加大于等于条件。
*
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> ge(SFunction<T, ?> column, Object value) {
wrapper.ge(column, value);
return this;
}
/**
* 添加大于等于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> ge(boolean condition, SFunction<T, ?> column, Object value) {
wrapper.ge(condition, column, value);
return this;
}
/**
* 添加小于条件。
*
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> lt(SFunction<T, ?> column, Object value) {
wrapper.lt(column, value);
return this;
}
/**
* 添加小于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> lt(boolean condition, SFunction<T, ?> column, Object value) {
wrapper.lt(condition, column, value);
return this;
}
/**
* 添加小于等于条件。
*
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> le(SFunction<T, ?> column, Object value) {
wrapper.le(column, value);
return this;
}
/**
* 添加小于等于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> le(boolean condition, SFunction<T, ?> column, Object value) {
wrapper.le(condition, column, value);
return this;
}
/**
* 添加模糊匹配条件。
*
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> like(SFunction<T, ?> column, Object value) {
wrapper.like(column, value);
return this;
}
/**
* 添加模糊匹配条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> like(boolean condition, SFunction<T, ?> column, Object value) {
wrapper.like(condition, column, value);
return this;
}
/**
* 添加非模糊匹配条件。
*
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notLike(SFunction<T, ?> column, Object value) {
wrapper.notLike(column, value);
return this;
}
/**
* 添加非模糊匹配条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notLike(boolean condition, SFunction<T, ?> column, Object value) {
wrapper.notLike(condition, column, value);
return this;
}
/**
* 添加左模糊匹配条件。
*
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> likeLeft(SFunction<T, ?> column, Object value) {
wrapper.likeLeft(column, value);
return this;
}
/**
* 添加左模糊匹配条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> likeLeft(boolean condition, SFunction<T, ?> column, Object value) {
wrapper.likeLeft(condition, column, value);
return this;
}
/**
* 添加右模糊匹配条件。
*
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> likeRight(SFunction<T, ?> column, Object value) {
wrapper.likeRight(column, value);
return this;
}
/**
* 添加右模糊匹配条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> likeRight(boolean condition, SFunction<T, ?> column, Object value) {
wrapper.likeRight(condition, column, value);
return this;
}
/**
* 添加区间条件。
*
* @param column 字段
* @param begin 起始值
* @param end 结束值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> between(SFunction<T, ?> column, Object begin, Object end) {
wrapper.between(column, begin, end);
return this;
}
/**
* 添加区间条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param begin 起始值
* @param end 结束值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> between(boolean condition, SFunction<T, ?> column, Object begin, Object end) {
wrapper.between(condition, column, begin, end);
return this;
}
/**
* 添加非区间条件。
*
* @param column 字段
* @param begin 起始值
* @param end 结束值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notBetween(SFunction<T, ?> column, Object begin, Object end) {
wrapper.notBetween(column, begin, end);
return this;
}
/**
* 添加非区间条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param begin 起始值
* @param end 结束值
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notBetween(boolean condition, SFunction<T, ?> column, Object begin, Object end) {
wrapper.notBetween(condition, column, begin, end);
return this;
}
/**
* 添加全部等于条件。
*
* @param params 字段和值映射
* @param null2IsNull 值为空时是否转为 IS NULL 条件
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> allEq(Map<?, ?> params, boolean null2IsNull) {
wrapper.allEq(true, (Map) params, null2IsNull);
return this;
}
/**
* 添加全部等于条件。
*
* @param condition 是否添加该条件
* @param params 字段和值映射
* @param null2IsNull 值为空时是否转为 IS NULL 条件
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> allEq(boolean condition, Map<?, ?> params, boolean null2IsNull) {
wrapper.allEq(condition, (Map) params, null2IsNull);
return this;
}
/**
* 添加经过过滤的全部等于条件。
*
* @param filter 字段和值过滤器
* @param params 字段和值映射
* @param null2IsNull 值为空时是否转为 IS NULL 条件
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> allEq(BiPredicate<SFunction<T, ?>, Object> filter, Map<?, ?> params, boolean null2IsNull) {
wrapper.allEq(true, (BiPredicate) filter, (Map) params, null2IsNull);
return this;
}
/**
* 添加经过过滤的全部等于条件。
*
* @param condition 是否添加该条件
* @param filter 字段和值过滤器
* @param params 字段和值映射
* @param null2IsNull 值为空时是否转为 IS NULL 条件
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> allEq(boolean condition, BiPredicate<SFunction<T, ?>, Object> filter, Map<?, ?> params, boolean null2IsNull) {
wrapper.allEq(condition, (BiPredicate) filter, (Map) params, null2IsNull);
return this;
}
/**
* 添加字段为空条件。
*
* @param column 字段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> isNull(SFunction<T, ?> column) {
wrapper.isNull(column);
return this;
}
/**
* 添加字段为空条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> isNull(boolean condition, SFunction<T, ?> column) {
wrapper.isNull(condition, column);
return this;
}
/**
* 添加字段非空条件。
*
* @param column 字段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> isNotNull(SFunction<T, ?> column) {
wrapper.isNotNull(column);
return this;
}
/**
* 添加字段非空条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> isNotNull(boolean condition, SFunction<T, ?> column) {
wrapper.isNotNull(condition, column);
return this;
}
/**
* 添加包含集合条件。
*
* @param column 字段
* @param values 条件值集合
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> in(SFunction<T, ?> column, Collection<?> values) {
wrapper.in(column, values);
return this;
}
/**
* 添加包含集合条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param values 条件值集合
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> in(boolean condition, SFunction<T, ?> column, Collection<?> values) {
wrapper.in(condition, column, values);
return this;
}
/**
* 添加包含数组条件。
*
* @param column 字段
* @param values 条件值数组
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> in(SFunction<T, ?> column, Object... values) {
wrapper.in(column, values);
return this;
}
/**
* 添加包含数组条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param values 条件值数组
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> in(boolean condition, SFunction<T, ?> column, Object... values) {
wrapper.in(condition, column, values);
return this;
}
/**
* 添加不包含集合条件。
*
* @param column 字段
* @param values 条件值集合
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notIn(SFunction<T, ?> column, Collection<?> values) {
wrapper.notIn(column, values);
return this;
}
/**
* 添加不包含集合条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param values 条件值集合
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notIn(boolean condition, SFunction<T, ?> column, Collection<?> values) {
wrapper.notIn(condition, column, values);
return this;
}
/**
* 添加不包含数组条件。
*
* @param column 字段
* @param values 条件值数组
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notIn(SFunction<T, ?> column, Object... values) {
wrapper.notIn(column, values);
return this;
}
/**
* 添加不包含数组条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param values 条件值数组
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notIn(boolean condition, SFunction<T, ?> column, Object... values) {
wrapper.notIn(condition, column, values);
return this;
}
/**
* 添加分组字段。
*
* @param columns 分组字段
* @return 当前查询构造辅助对象
*/
@SafeVarargs
public final LambdaQueryBuilder<T> groupBy(SFunction<T, ?>... columns) {
wrapper.groupBy(Arrays.asList(columns));
return this;
}
/**
* 添加分组字段。
*
* @param condition 是否添加该分组
* @param columns 分组字段
* @return 当前查询构造辅助对象
*/
@SafeVarargs
public final LambdaQueryBuilder<T> groupBy(boolean condition, SFunction<T, ?>... columns) {
wrapper.groupBy(condition, Arrays.asList(columns));
return this;
}
/**
* 添加排序条件。
*
* @param condition 是否添加该排序
* @param isAsc 是否升序
* @param column 排序字段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> orderBy(boolean condition, boolean isAsc, SFunction<T, ?> column) {
wrapper.orderBy(condition, isAsc, column);
return this;
}
/**
* 添加升序排序字段。
*
* @param columns 排序字段
* @return 当前查询构造辅助对象
*/
@SafeVarargs
public final LambdaQueryBuilder<T> orderByAsc(SFunction<T, ?>... columns) {
wrapper.orderByAsc(Arrays.asList(columns));
return this;
}
/**
* 添加升序排序字段。
*
* @param condition 是否添加该排序
* @param columns 排序字段
* @return 当前查询构造辅助对象
*/
@SafeVarargs
public final LambdaQueryBuilder<T> orderByAsc(boolean condition, SFunction<T, ?>... columns) {
wrapper.orderByAsc(condition, Arrays.asList(columns));
return this;
}
/**
* 添加降序排序字段。
*
* @param columns 排序字段
* @return 当前查询构造辅助对象
*/
@SafeVarargs
public final LambdaQueryBuilder<T> orderByDesc(SFunction<T, ?>... columns) {
wrapper.orderByDesc(Arrays.asList(columns));
return this;
}
/**
* 添加降序排序字段。
*
* @param condition 是否添加该排序
* @param columns 排序字段
* @return 当前查询构造辅助对象
*/
@SafeVarargs
public final LambdaQueryBuilder<T> orderByDesc(boolean condition, SFunction<T, ?>... columns) {
wrapper.orderByDesc(condition, Arrays.asList(columns));
return this;
}
/**
* 添加 HAVING 条件。
*
* @param sqlHaving HAVING SQL 片段
* @param params SQL 片段参数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> having(String sqlHaving, Object... params) {
wrapper.having(sqlHaving, params);
return this;
}
/**
* 添加 HAVING 条件。
*
* @param condition 是否添加该条件
* @param sqlHaving HAVING SQL 片段
* @param params SQL 片段参数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> having(boolean condition, String sqlHaving, Object... params) {
wrapper.having(condition, sqlHaving, params);
return this;
}
/**
* 添加 AND 嵌套条件。
*
* @param consumer 条件构造函数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> and(Consumer<LambdaQueryWrapper<T>> consumer) {
wrapper.and(consumer);
return this;
}
/**
* 添加 AND 嵌套条件。
*
* @param condition 是否添加该条件
* @param consumer 条件构造函数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> and(boolean condition, Consumer<LambdaQueryWrapper<T>> consumer) {
wrapper.and(condition, consumer);
return this;
}
/**
* 添加 OR 拼接。
*
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> or() {
wrapper.or();
return this;
}
/**
* 添加 OR 嵌套条件。
*
* @param consumer 条件构造函数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> or(Consumer<LambdaQueryWrapper<T>> consumer) {
wrapper.or(consumer);
return this;
}
/**
* 添加 OR 嵌套条件。
*
* @param condition 是否添加该条件
* @param consumer 条件构造函数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> or(boolean condition, Consumer<LambdaQueryWrapper<T>> consumer) {
wrapper.or(condition, consumer);
return this;
}
/**
* 添加普通嵌套条件。
*
* @param consumer 条件构造函数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> nested(Consumer<LambdaQueryWrapper<T>> consumer) {
wrapper.nested(consumer);
return this;
}
/**
* 添加普通嵌套条件。
*
* @param condition 是否添加该条件
* @param consumer 条件构造函数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> nested(boolean condition, Consumer<LambdaQueryWrapper<T>> consumer) {
wrapper.nested(condition, consumer);
return this;
}
/**
* 添加 EXISTS 条件。
*
* @param existsSql EXISTS SQL 片段
* @param values SQL 片段参数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> exists(String existsSql, Object... values) {
wrapper.exists(existsSql, values);
return this;
}
/**
* 添加 EXISTS 条件。
*
* @param condition 是否添加该条件
* @param existsSql EXISTS SQL 片段
* @param values SQL 片段参数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> exists(boolean condition, String existsSql, Object... values) {
wrapper.exists(condition, existsSql, values);
return this;
}
/**
* 添加字段等于 SQL 片段条件。
*
* @param column 字段
* @param inValue SQL 片段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> eqSql(SFunction<T, ?> column, String inValue) {
wrapper.eqSql(true, column, inValue);
return this;
}
/**
* 添加字段等于 SQL 片段条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param inValue SQL 片段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> eqSql(boolean condition, SFunction<T, ?> column, String inValue) {
wrapper.eqSql(condition, column, inValue);
return this;
}
/**
* 添加字段 IN SQL 片段条件。
*
* @param column 字段
* @param inValue SQL 片段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> inSql(SFunction<T, ?> column, String inValue) {
wrapper.inSql(true, column, inValue);
return this;
}
/**
* 添加字段 IN SQL 片段条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param inValue SQL 片段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> inSql(boolean condition, SFunction<T, ?> column, String inValue) {
wrapper.inSql(condition, column, inValue);
return this;
}
/**
* 添加字段 NOT IN SQL 片段条件。
*
* @param column 字段
* @param inValue SQL 片段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notInSql(SFunction<T, ?> column, String inValue) {
wrapper.notInSql(true, column, inValue);
return this;
}
/**
* 添加字段 NOT IN SQL 片段条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param inValue SQL 片段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notInSql(boolean condition, SFunction<T, ?> column, String inValue) {
wrapper.notInSql(condition, column, inValue);
return this;
}
/**
* 添加 NOT EXISTS 条件。
*
* @param existsSql EXISTS SQL 片段
* @param values SQL 片段参数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notExists(String existsSql, Object... values) {
wrapper.notExists(existsSql, values);
return this;
}
/**
* 添加 NOT EXISTS 条件。
*
* @param condition 是否添加该条件
* @param existsSql EXISTS SQL 片段
* @param values SQL 片段参数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> notExists(boolean condition, String existsSql, Object... values) {
wrapper.notExists(condition, existsSql, values);
return this;
}
/**
* 拼接 SQL 片段条件。
*
* @param applySql SQL 片段
* @param values SQL 片段参数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> apply(String applySql, Object... values) {
wrapper.apply(applySql, values);
return this;
}
/**
* 拼接 SQL 片段条件。
*
* @param condition 是否添加该条件
* @param applySql SQL 片段
* @param values SQL 片段参数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> apply(boolean condition, String applySql, Object... values) {
wrapper.apply(condition, applySql, values);
return this;
}
/**
* 直接对底层查询包装器应用自定义处理。
*
* @param consumer 查询包装器处理函数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> apply(Consumer<LambdaQueryWrapper<T>> consumer) {
consumer.accept(wrapper);
return this;
}
/**
* 使用函数式方式追加条件。
*
* @param consumer 条件构造函数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> func(Consumer<LambdaQueryWrapper<T>> consumer) {
wrapper.func(true, consumer);
return this;
}
/**
* 使用函数式方式追加条件。
*
* @param condition 是否添加该条件
* @param consumer 条件构造函数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> func(boolean condition, Consumer<LambdaQueryWrapper<T>> consumer) {
wrapper.func(condition, consumer);
return this;
}
/**
* 添加 NOT 嵌套条件。
*
* @param consumer 条件构造函数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> not(Consumer<LambdaQueryWrapper<T>> consumer) {
wrapper.not(true, consumer);
return this;
}
/**
* 添加 NOT 嵌套条件。
*
* @param condition 是否添加该条件
* @param consumer 条件构造函数
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> not(boolean condition, Consumer<LambdaQueryWrapper<T>> consumer) {
wrapper.not(condition, consumer);
return this;
}
/**
* 添加 SQL 注释。
*
* @param comment SQL 注释内容
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> comment(String comment) {
wrapper.comment(true, comment);
return this;
}
/**
* 添加 SQL 注释。
*
* @param condition 是否添加该注释
* @param comment SQL 注释内容
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> comment(boolean condition, String comment) {
wrapper.comment(condition, comment);
return this;
}
/**
* 拼接 SQL 尾部片段。
*
* @param lastSql SQL 尾部片段
* @return 当前查询构造辅助对象
*/
public LambdaQueryBuilder<T> last(String lastSql) {
wrapper.last(lastSql);
return this;
}
/**
* 获取底层 Lambda 查询包装器。
*
* @return Lambda 查询包装器
*/
public LambdaQueryWrapper<T> build() {
return wrapper;
}
@@ -8,100 +8,339 @@ import java.util.Collection;
import java.util.Map;
/**
* Lambda ?????????
* Lambda 查询常用条件扩展。
*
* @param <T> ????
* @param <Children> ??????
* @param <T> 实体类型
* @param <Children> 链式返回类型
* @author Lion Li
*/
public interface LambdaQueryCondition<T, Children> {
/**
* 等于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
Children eq(boolean condition, SFunction<T, ?> column, Object value);
/**
* 不等于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
Children ne(boolean condition, SFunction<T, ?> column, Object value);
/**
* 大于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
Children gt(boolean condition, SFunction<T, ?> column, Object value);
/**
* 大于等于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
Children ge(boolean condition, SFunction<T, ?> column, Object value);
/**
* 小于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
Children lt(boolean condition, SFunction<T, ?> column, Object value);
/**
* 小于等于条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
Children le(boolean condition, SFunction<T, ?> column, Object value);
/**
* 模糊匹配条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
Children like(boolean condition, SFunction<T, ?> column, Object value);
/**
* 非模糊匹配条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
Children notLike(boolean condition, SFunction<T, ?> column, Object value);
/**
* 左模糊匹配条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
Children likeLeft(boolean condition, SFunction<T, ?> column, Object value);
/**
* 右模糊匹配条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
Children likeRight(boolean condition, SFunction<T, ?> column, Object value);
/**
* 区间条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param begin 起始值
* @param end 结束值
* @return 链式返回对象
*/
Children between(boolean condition, SFunction<T, ?> column, Object begin, Object end);
/**
* 非区间条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param begin 起始值
* @param end 结束值
* @return 链式返回对象
*/
Children notBetween(boolean condition, SFunction<T, ?> column, Object begin, Object end);
/**
* 包含集合条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param values 条件值集合
* @return 链式返回对象
*/
Children in(boolean condition, SFunction<T, ?> column, Collection<?> values);
/**
* 包含数组条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param values 条件值数组
* @return 链式返回对象
*/
Children in(boolean condition, SFunction<T, ?> column, Object... values);
/**
* 不包含集合条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param values 条件值集合
* @return 链式返回对象
*/
Children notIn(boolean condition, SFunction<T, ?> column, Collection<?> values);
/**
* 不包含数组条件。
*
* @param condition 是否添加该条件
* @param column 字段
* @param values 条件值数组
* @return 链式返回对象
*/
Children notIn(boolean condition, SFunction<T, ?> column, Object... values);
/**
* 拼接 SQL 片段条件。
*
* @param condition 是否添加该条件
* @param applySql SQL 片段
* @param values SQL 片段参数
* @return 链式返回对象
*/
Children apply(boolean condition, String applySql, Object... values);
/**
* 值不为空时添加等于条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children eqIfPresent(SFunction<T, ?> column, Object value) {
return eq(value != null, column, value);
}
/**
* 文本不为空白时添加等于条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children eqIfText(SFunction<T, ?> column, String value) {
return eq(StringUtils.isNotBlank(value), column, value);
}
/**
* 值不为空时添加不等于条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children neIfPresent(SFunction<T, ?> column, Object value) {
return ne(value != null, column, value);
}
/**
* 文本不为空白时添加不等于条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children neIfText(SFunction<T, ?> column, String value) {
return ne(StringUtils.isNotBlank(value), column, value);
}
/**
* 值不为空时添加大于条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children gtIfPresent(SFunction<T, ?> column, Object value) {
return gt(value != null, column, value);
}
/**
* 值不为空时添加大于等于条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children geIfPresent(SFunction<T, ?> column, Object value) {
return ge(value != null, column, value);
}
/**
* 值不为空时添加小于条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children ltIfPresent(SFunction<T, ?> column, Object value) {
return lt(value != null, column, value);
}
/**
* 值不为空时添加小于等于条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children leIfPresent(SFunction<T, ?> column, Object value) {
return le(value != null, column, value);
}
/**
* 文本不为空白时添加模糊匹配条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children likeIfText(SFunction<T, ?> column, String value) {
return like(StringUtils.isNotBlank(value), column, value);
}
/**
* 文本不为空白时添加非模糊匹配条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children notLikeIfText(SFunction<T, ?> column, String value) {
return notLike(StringUtils.isNotBlank(value), column, value);
}
/**
* 文本不为空白时添加左模糊匹配条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children likeLeftIfText(SFunction<T, ?> column, String value) {
return likeLeft(StringUtils.isNotBlank(value), column, value);
}
/**
* 文本不为空白时添加右模糊匹配条件。
*
* @param column 字段
* @param value 条件值
* @return 链式返回对象
*/
default Children likeRightIfText(SFunction<T, ?> column, String value) {
return likeRight(StringUtils.isNotBlank(value), column, value);
}
/**
* 起止值均不为空时添加区间条件。
*
* @param column 字段
* @param begin 起始值
* @param end 结束值
* @return 链式返回对象
*/
default Children betweenIfPresent(SFunction<T, ?> column, Object begin, Object end) {
return between(begin != null && end != null, column, begin, end);
}
/**
* 从参数 Map 中读取起止值,均不为空时添加区间条件。
*
* @param column 字段
* @param params 参数 Map
* @param beginKey 起始值参数名
* @param endKey 结束值参数名
* @return 链式返回对象
*/
default Children betweenParams(SFunction<T, ?> column, Map<String, Object> params, String beginKey, String endKey) {
if (params == null) {
return between(false, column, null, null);
@@ -111,34 +350,92 @@ public interface LambdaQueryCondition<T, Children> {
return between(begin != null && end != null, column, begin, end);
}
/**
* 起止值均不为空时添加非区间条件。
*
* @param column 字段
* @param begin 起始值
* @param end 结束值
* @return 链式返回对象
*/
default Children notBetweenIfPresent(SFunction<T, ?> column, Object begin, Object end) {
return notBetween(begin != null && end != null, column, begin, end);
}
/**
* 集合不为空时添加包含条件。
*
* @param column 字段
* @param values 条件值集合
* @return 链式返回对象
*/
default Children inIfNotEmpty(SFunction<T, ?> column, Collection<?> values) {
return in(values != null && !values.isEmpty(), column, values);
}
/**
* 数组不为空时添加包含条件。
*
* @param column 字段
* @param values 条件值数组
* @return 链式返回对象
*/
default Children inIfNotEmpty(SFunction<T, ?> column, Object... values) {
return in(values != null && values.length > 0, column, values);
}
/**
* 集合不为空时添加不包含条件。
*
* @param column 字段
* @param values 条件值集合
* @return 链式返回对象
*/
default Children notInIfNotEmpty(SFunction<T, ?> column, Collection<?> values) {
return notIn(values != null && !values.isEmpty(), column, values);
}
/**
* 数组不为空时添加不包含条件。
*
* @param column 字段
* @param values 条件值数组
* @return 链式返回对象
*/
default Children notInIfNotEmpty(SFunction<T, ?> column, Object... values) {
return notIn(values != null && values.length > 0, column, values);
}
/**
* 添加 FIND_IN_SET 条件。
*
* @param value 匹配值
* @param column 字段名
* @return 链式返回对象
*/
default Children findInSet(Object value, String column) {
return findInSet(true, value, column);
}
/**
* 添加 FIND_IN_SET 条件。
*
* @param condition 是否添加该条件
* @param value 匹配值
* @param column 字段名
* @return 链式返回对象
*/
default Children findInSet(boolean condition, Object value, String column) {
return apply(condition, DataBaseHelper.findInSet(value, column));
}
/**
* 值不为空时添加 FIND_IN_SET 条件。
*
* @param value 匹配值
* @param column 字段名
* @return 链式返回对象
*/
default Children findInSetIfPresent(Object value, String column) {
return findInSet(value != null, value, column);
}
@@ -3,7 +3,7 @@ package org.dromara.common.mybatis.core.query;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
/**
* MyBatis-Plus ????????
* MyBatis-Plus 查询构造器入口。
*
* @author Lion Li
*/
@@ -12,6 +12,13 @@ public final class QueryBuilder {
private QueryBuilder() {
}
/**
* 创建 Lambda 查询构造辅助对象。
*
* @param entityClass 实体类型
* @param <T> 实体类型
* @return Lambda 查询构造辅助对象
*/
public static <T> LambdaQueryBuilder<T> lambda(Class<T> entityClass) {
return new LambdaQueryBuilder<>(Wrappers.lambdaQuery(entityClass));
}