xinyin025/RuoYi-Vue-Plus
1
0
Fork 0
mirror of https://github.com/dromara/RuoYi-Vue-Plus.git synced 2026-07-17 18:16:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

update 增加 Lambda 查询构造辅助对象的条件方法注释

Browse Source
This commit is contained in:
AprilWind
2026-05-15 12:34:02 +08:00
parent 0d8a5f9224
commit e45436671d
3 changed files with 872 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/LambdaQueryBuilder.java
+568
View File
@@ -17,404 +17,972 @@ import java.util.function.Consumer;
*/
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;
}
ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/LambdaQueryCondition.java
+297
View File
@@ -16,92 +16,331 @@ import java.util.Map;
*/
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);
}
ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/QueryBuilder.java
+7
View File
@@ -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));
}