From e45436671d095b744050664fbb137ea32d43d6ce Mon Sep 17 00:00:00 2001 From: AprilWind <2100166581@qq.com> Date: Fri, 15 May 2026 12:34:02 +0800 Subject: [PATCH] =?UTF-8?q?update=20=E5=A2=9E=E5=8A=A0=20Lambda=20?= =?UTF-8?q?=E6=9F=A5=E8=AF=A2=E6=9E=84=E9=80=A0=E8=BE=85=E5=8A=A9=E5=AF=B9?= =?UTF-8?q?=E8=B1=A1=E7=9A=84=E6=9D=A1=E4=BB=B6=E6=96=B9=E6=B3=95=E6=B3=A8?= =?UTF-8?q?=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../core/query/LambdaQueryBuilder.java | 568 ++++++++++++++++++ .../core/query/LambdaQueryCondition.java | 297 +++++++++ .../mybatis/core/query/QueryBuilder.java | 7 + 3 files changed, 872 insertions(+) diff --git a/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/LambdaQueryBuilder.java b/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/LambdaQueryBuilder.java index 2de14879f..a8e77015e 100644 --- a/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/LambdaQueryBuilder.java +++ b/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/LambdaQueryBuilder.java @@ -17,404 +17,972 @@ import java.util.function.Consumer; */ public final class LambdaQueryBuilder implements LambdaQueryCondition> { + /** + * MyBatis-Plus Lambda 查询包装器。 + */ private final LambdaQueryWrapper wrapper; + /** + * 构造 Lambda 查询构造辅助对象。 + * + * @param wrapper Lambda 查询包装器 + */ LambdaQueryBuilder(LambdaQueryWrapper wrapper) { this.wrapper = wrapper; } + /** + * 指定查询字段。 + * + * @param columns 查询字段 + * @return 当前查询构造辅助对象 + */ @SafeVarargs public final LambdaQueryBuilder select(SFunction... columns) { wrapper.select(columns); return this; } + /** + * 添加等于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder eq(SFunction column, Object value) { wrapper.eq(column, value); return this; } + /** + * 添加等于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder eq(boolean condition, SFunction column, Object value) { wrapper.eq(condition, column, value); return this; } + /** + * 添加不等于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder ne(SFunction column, Object value) { wrapper.ne(column, value); return this; } + /** + * 添加不等于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder ne(boolean condition, SFunction column, Object value) { wrapper.ne(condition, column, value); return this; } + /** + * 添加大于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder gt(SFunction column, Object value) { wrapper.gt(column, value); return this; } + /** + * 添加大于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder gt(boolean condition, SFunction column, Object value) { wrapper.gt(condition, column, value); return this; } + /** + * 添加大于等于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder ge(SFunction column, Object value) { wrapper.ge(column, value); return this; } + /** + * 添加大于等于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder ge(boolean condition, SFunction column, Object value) { wrapper.ge(condition, column, value); return this; } + /** + * 添加小于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder lt(SFunction column, Object value) { wrapper.lt(column, value); return this; } + /** + * 添加小于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder lt(boolean condition, SFunction column, Object value) { wrapper.lt(condition, column, value); return this; } + /** + * 添加小于等于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder le(SFunction column, Object value) { wrapper.le(column, value); return this; } + /** + * 添加小于等于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder le(boolean condition, SFunction column, Object value) { wrapper.le(condition, column, value); return this; } + /** + * 添加模糊匹配条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder like(SFunction column, Object value) { wrapper.like(column, value); return this; } + /** + * 添加模糊匹配条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder like(boolean condition, SFunction column, Object value) { wrapper.like(condition, column, value); return this; } + /** + * 添加非模糊匹配条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder notLike(SFunction column, Object value) { wrapper.notLike(column, value); return this; } + /** + * 添加非模糊匹配条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder notLike(boolean condition, SFunction column, Object value) { wrapper.notLike(condition, column, value); return this; } + /** + * 添加左模糊匹配条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder likeLeft(SFunction column, Object value) { wrapper.likeLeft(column, value); return this; } + /** + * 添加左模糊匹配条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder likeLeft(boolean condition, SFunction column, Object value) { wrapper.likeLeft(condition, column, value); return this; } + /** + * 添加右模糊匹配条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder likeRight(SFunction column, Object value) { wrapper.likeRight(column, value); return this; } + /** + * 添加右模糊匹配条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder likeRight(boolean condition, SFunction column, Object value) { wrapper.likeRight(condition, column, value); return this; } + /** + * 添加区间条件。 + * + * @param column 字段 + * @param begin 起始值 + * @param end 结束值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder between(SFunction column, Object begin, Object end) { wrapper.between(column, begin, end); return this; } + /** + * 添加区间条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param begin 起始值 + * @param end 结束值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder between(boolean condition, SFunction column, Object begin, Object end) { wrapper.between(condition, column, begin, end); return this; } + /** + * 添加非区间条件。 + * + * @param column 字段 + * @param begin 起始值 + * @param end 结束值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder notBetween(SFunction column, Object begin, Object end) { wrapper.notBetween(column, begin, end); return this; } + /** + * 添加非区间条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param begin 起始值 + * @param end 结束值 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder notBetween(boolean condition, SFunction column, Object begin, Object end) { wrapper.notBetween(condition, column, begin, end); return this; } + /** + * 添加全部等于条件。 + * + * @param params 字段和值映射 + * @param null2IsNull 值为空时是否转为 IS NULL 条件 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder allEq(Map params, boolean null2IsNull) { wrapper.allEq(true, (Map) params, null2IsNull); return this; } + /** + * 添加全部等于条件。 + * + * @param condition 是否添加该条件 + * @param params 字段和值映射 + * @param null2IsNull 值为空时是否转为 IS NULL 条件 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder 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 allEq(BiPredicate, 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 allEq(boolean condition, BiPredicate, Object> filter, Map params, boolean null2IsNull) { wrapper.allEq(condition, (BiPredicate) filter, (Map) params, null2IsNull); return this; } + /** + * 添加字段为空条件。 + * + * @param column 字段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder isNull(SFunction column) { wrapper.isNull(column); return this; } + /** + * 添加字段为空条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder isNull(boolean condition, SFunction column) { wrapper.isNull(condition, column); return this; } + /** + * 添加字段非空条件。 + * + * @param column 字段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder isNotNull(SFunction column) { wrapper.isNotNull(column); return this; } + /** + * 添加字段非空条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder isNotNull(boolean condition, SFunction column) { wrapper.isNotNull(condition, column); return this; } + /** + * 添加包含集合条件。 + * + * @param column 字段 + * @param values 条件值集合 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder in(SFunction column, Collection values) { wrapper.in(column, values); return this; } + /** + * 添加包含集合条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param values 条件值集合 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder in(boolean condition, SFunction column, Collection values) { wrapper.in(condition, column, values); return this; } + /** + * 添加包含数组条件。 + * + * @param column 字段 + * @param values 条件值数组 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder in(SFunction column, Object... values) { wrapper.in(column, values); return this; } + /** + * 添加包含数组条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param values 条件值数组 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder in(boolean condition, SFunction column, Object... values) { wrapper.in(condition, column, values); return this; } + /** + * 添加不包含集合条件。 + * + * @param column 字段 + * @param values 条件值集合 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder notIn(SFunction column, Collection values) { wrapper.notIn(column, values); return this; } + /** + * 添加不包含集合条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param values 条件值集合 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder notIn(boolean condition, SFunction column, Collection values) { wrapper.notIn(condition, column, values); return this; } + /** + * 添加不包含数组条件。 + * + * @param column 字段 + * @param values 条件值数组 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder notIn(SFunction column, Object... values) { wrapper.notIn(column, values); return this; } + /** + * 添加不包含数组条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param values 条件值数组 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder notIn(boolean condition, SFunction column, Object... values) { wrapper.notIn(condition, column, values); return this; } + /** + * 添加分组字段。 + * + * @param columns 分组字段 + * @return 当前查询构造辅助对象 + */ @SafeVarargs public final LambdaQueryBuilder groupBy(SFunction... columns) { wrapper.groupBy(Arrays.asList(columns)); return this; } + /** + * 添加分组字段。 + * + * @param condition 是否添加该分组 + * @param columns 分组字段 + * @return 当前查询构造辅助对象 + */ @SafeVarargs public final LambdaQueryBuilder groupBy(boolean condition, SFunction... columns) { wrapper.groupBy(condition, Arrays.asList(columns)); return this; } + /** + * 添加排序条件。 + * + * @param condition 是否添加该排序 + * @param isAsc 是否升序 + * @param column 排序字段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder orderBy(boolean condition, boolean isAsc, SFunction column) { wrapper.orderBy(condition, isAsc, column); return this; } + /** + * 添加升序排序字段。 + * + * @param columns 排序字段 + * @return 当前查询构造辅助对象 + */ @SafeVarargs public final LambdaQueryBuilder orderByAsc(SFunction... columns) { wrapper.orderByAsc(Arrays.asList(columns)); return this; } + /** + * 添加升序排序字段。 + * + * @param condition 是否添加该排序 + * @param columns 排序字段 + * @return 当前查询构造辅助对象 + */ @SafeVarargs public final LambdaQueryBuilder orderByAsc(boolean condition, SFunction... columns) { wrapper.orderByAsc(condition, Arrays.asList(columns)); return this; } + /** + * 添加降序排序字段。 + * + * @param columns 排序字段 + * @return 当前查询构造辅助对象 + */ @SafeVarargs public final LambdaQueryBuilder orderByDesc(SFunction... columns) { wrapper.orderByDesc(Arrays.asList(columns)); return this; } + /** + * 添加降序排序字段。 + * + * @param condition 是否添加该排序 + * @param columns 排序字段 + * @return 当前查询构造辅助对象 + */ @SafeVarargs public final LambdaQueryBuilder orderByDesc(boolean condition, SFunction... columns) { wrapper.orderByDesc(condition, Arrays.asList(columns)); return this; } + /** + * 添加 HAVING 条件。 + * + * @param sqlHaving HAVING SQL 片段 + * @param params SQL 片段参数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder having(String sqlHaving, Object... params) { wrapper.having(sqlHaving, params); return this; } + /** + * 添加 HAVING 条件。 + * + * @param condition 是否添加该条件 + * @param sqlHaving HAVING SQL 片段 + * @param params SQL 片段参数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder having(boolean condition, String sqlHaving, Object... params) { wrapper.having(condition, sqlHaving, params); return this; } + /** + * 添加 AND 嵌套条件。 + * + * @param consumer 条件构造函数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder and(Consumer> consumer) { wrapper.and(consumer); return this; } + /** + * 添加 AND 嵌套条件。 + * + * @param condition 是否添加该条件 + * @param consumer 条件构造函数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder and(boolean condition, Consumer> consumer) { wrapper.and(condition, consumer); return this; } + /** + * 添加 OR 拼接。 + * + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder or() { wrapper.or(); return this; } + /** + * 添加 OR 嵌套条件。 + * + * @param consumer 条件构造函数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder or(Consumer> consumer) { wrapper.or(consumer); return this; } + /** + * 添加 OR 嵌套条件。 + * + * @param condition 是否添加该条件 + * @param consumer 条件构造函数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder or(boolean condition, Consumer> consumer) { wrapper.or(condition, consumer); return this; } + /** + * 添加普通嵌套条件。 + * + * @param consumer 条件构造函数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder nested(Consumer> consumer) { wrapper.nested(consumer); return this; } + /** + * 添加普通嵌套条件。 + * + * @param condition 是否添加该条件 + * @param consumer 条件构造函数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder nested(boolean condition, Consumer> consumer) { wrapper.nested(condition, consumer); return this; } + /** + * 添加 EXISTS 条件。 + * + * @param existsSql EXISTS SQL 片段 + * @param values SQL 片段参数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder exists(String existsSql, Object... values) { wrapper.exists(existsSql, values); return this; } + /** + * 添加 EXISTS 条件。 + * + * @param condition 是否添加该条件 + * @param existsSql EXISTS SQL 片段 + * @param values SQL 片段参数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder exists(boolean condition, String existsSql, Object... values) { wrapper.exists(condition, existsSql, values); return this; } + /** + * 添加字段等于 SQL 片段条件。 + * + * @param column 字段 + * @param inValue SQL 片段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder eqSql(SFunction column, String inValue) { wrapper.eqSql(true, column, inValue); return this; } + /** + * 添加字段等于 SQL 片段条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param inValue SQL 片段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder eqSql(boolean condition, SFunction column, String inValue) { wrapper.eqSql(condition, column, inValue); return this; } + /** + * 添加字段 IN SQL 片段条件。 + * + * @param column 字段 + * @param inValue SQL 片段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder inSql(SFunction column, String inValue) { wrapper.inSql(true, column, inValue); return this; } + /** + * 添加字段 IN SQL 片段条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param inValue SQL 片段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder inSql(boolean condition, SFunction column, String inValue) { wrapper.inSql(condition, column, inValue); return this; } + /** + * 添加字段 NOT IN SQL 片段条件。 + * + * @param column 字段 + * @param inValue SQL 片段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder notInSql(SFunction column, String inValue) { wrapper.notInSql(true, column, inValue); return this; } + /** + * 添加字段 NOT IN SQL 片段条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param inValue SQL 片段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder notInSql(boolean condition, SFunction column, String inValue) { wrapper.notInSql(condition, column, inValue); return this; } + /** + * 添加 NOT EXISTS 条件。 + * + * @param existsSql EXISTS SQL 片段 + * @param values SQL 片段参数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder 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 notExists(boolean condition, String existsSql, Object... values) { wrapper.notExists(condition, existsSql, values); return this; } + /** + * 拼接 SQL 片段条件。 + * + * @param applySql SQL 片段 + * @param values SQL 片段参数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder apply(String applySql, Object... values) { wrapper.apply(applySql, values); return this; } + /** + * 拼接 SQL 片段条件。 + * + * @param condition 是否添加该条件 + * @param applySql SQL 片段 + * @param values SQL 片段参数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder apply(boolean condition, String applySql, Object... values) { wrapper.apply(condition, applySql, values); return this; } + /** + * 直接对底层查询包装器应用自定义处理。 + * + * @param consumer 查询包装器处理函数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder apply(Consumer> consumer) { consumer.accept(wrapper); return this; } + /** + * 使用函数式方式追加条件。 + * + * @param consumer 条件构造函数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder func(Consumer> consumer) { wrapper.func(true, consumer); return this; } + /** + * 使用函数式方式追加条件。 + * + * @param condition 是否添加该条件 + * @param consumer 条件构造函数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder func(boolean condition, Consumer> consumer) { wrapper.func(condition, consumer); return this; } + /** + * 添加 NOT 嵌套条件。 + * + * @param consumer 条件构造函数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder not(Consumer> consumer) { wrapper.not(true, consumer); return this; } + /** + * 添加 NOT 嵌套条件。 + * + * @param condition 是否添加该条件 + * @param consumer 条件构造函数 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder not(boolean condition, Consumer> consumer) { wrapper.not(condition, consumer); return this; } + /** + * 添加 SQL 注释。 + * + * @param comment SQL 注释内容 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder comment(String comment) { wrapper.comment(true, comment); return this; } + /** + * 添加 SQL 注释。 + * + * @param condition 是否添加该注释 + * @param comment SQL 注释内容 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder comment(boolean condition, String comment) { wrapper.comment(condition, comment); return this; } + /** + * 拼接 SQL 尾部片段。 + * + * @param lastSql SQL 尾部片段 + * @return 当前查询构造辅助对象 + */ public LambdaQueryBuilder last(String lastSql) { wrapper.last(lastSql); return this; } + /** + * 获取底层 Lambda 查询包装器。 + * + * @return Lambda 查询包装器 + */ public LambdaQueryWrapper build() { return wrapper; } diff --git a/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/LambdaQueryCondition.java b/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/LambdaQueryCondition.java index 459465e91..33e64abec 100644 --- a/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/LambdaQueryCondition.java +++ b/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/LambdaQueryCondition.java @@ -16,92 +16,331 @@ import java.util.Map; */ public interface LambdaQueryCondition { + /** + * 等于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ Children eq(boolean condition, SFunction column, Object value); + /** + * 不等于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ Children ne(boolean condition, SFunction column, Object value); + /** + * 大于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ Children gt(boolean condition, SFunction column, Object value); + /** + * 大于等于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ Children ge(boolean condition, SFunction column, Object value); + /** + * 小于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ Children lt(boolean condition, SFunction column, Object value); + /** + * 小于等于条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ Children le(boolean condition, SFunction column, Object value); + /** + * 模糊匹配条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ Children like(boolean condition, SFunction column, Object value); + /** + * 非模糊匹配条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ Children notLike(boolean condition, SFunction column, Object value); + /** + * 左模糊匹配条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ Children likeLeft(boolean condition, SFunction column, Object value); + /** + * 右模糊匹配条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ Children likeRight(boolean condition, SFunction column, Object value); + /** + * 区间条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param begin 起始值 + * @param end 结束值 + * @return 链式返回对象 + */ Children between(boolean condition, SFunction column, Object begin, Object end); + /** + * 非区间条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param begin 起始值 + * @param end 结束值 + * @return 链式返回对象 + */ Children notBetween(boolean condition, SFunction column, Object begin, Object end); + /** + * 包含集合条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param values 条件值集合 + * @return 链式返回对象 + */ Children in(boolean condition, SFunction column, Collection values); + /** + * 包含数组条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param values 条件值数组 + * @return 链式返回对象 + */ Children in(boolean condition, SFunction column, Object... values); + /** + * 不包含集合条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param values 条件值集合 + * @return 链式返回对象 + */ Children notIn(boolean condition, SFunction column, Collection values); + /** + * 不包含数组条件。 + * + * @param condition 是否添加该条件 + * @param column 字段 + * @param values 条件值数组 + * @return 链式返回对象 + */ Children notIn(boolean condition, SFunction 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 column, Object value) { return eq(value != null, column, value); } + /** + * 文本不为空白时添加等于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ default Children eqIfText(SFunction column, String value) { return eq(StringUtils.isNotBlank(value), column, value); } + /** + * 值不为空时添加不等于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ default Children neIfPresent(SFunction column, Object value) { return ne(value != null, column, value); } + /** + * 文本不为空白时添加不等于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ default Children neIfText(SFunction column, String value) { return ne(StringUtils.isNotBlank(value), column, value); } + /** + * 值不为空时添加大于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ default Children gtIfPresent(SFunction column, Object value) { return gt(value != null, column, value); } + /** + * 值不为空时添加大于等于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ default Children geIfPresent(SFunction column, Object value) { return ge(value != null, column, value); } + /** + * 值不为空时添加小于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ default Children ltIfPresent(SFunction column, Object value) { return lt(value != null, column, value); } + /** + * 值不为空时添加小于等于条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ default Children leIfPresent(SFunction column, Object value) { return le(value != null, column, value); } + /** + * 文本不为空白时添加模糊匹配条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ default Children likeIfText(SFunction column, String value) { return like(StringUtils.isNotBlank(value), column, value); } + /** + * 文本不为空白时添加非模糊匹配条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ default Children notLikeIfText(SFunction column, String value) { return notLike(StringUtils.isNotBlank(value), column, value); } + /** + * 文本不为空白时添加左模糊匹配条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ default Children likeLeftIfText(SFunction column, String value) { return likeLeft(StringUtils.isNotBlank(value), column, value); } + /** + * 文本不为空白时添加右模糊匹配条件。 + * + * @param column 字段 + * @param value 条件值 + * @return 链式返回对象 + */ default Children likeRightIfText(SFunction column, String value) { return likeRight(StringUtils.isNotBlank(value), column, value); } + /** + * 起止值均不为空时添加区间条件。 + * + * @param column 字段 + * @param begin 起始值 + * @param end 结束值 + * @return 链式返回对象 + */ default Children betweenIfPresent(SFunction 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 column, Map params, String beginKey, String endKey) { if (params == null) { return between(false, column, null, null); @@ -111,34 +350,92 @@ public interface LambdaQueryCondition { return between(begin != null && end != null, column, begin, end); } + /** + * 起止值均不为空时添加非区间条件。 + * + * @param column 字段 + * @param begin 起始值 + * @param end 结束值 + * @return 链式返回对象 + */ default Children notBetweenIfPresent(SFunction column, Object begin, Object end) { return notBetween(begin != null && end != null, column, begin, end); } + /** + * 集合不为空时添加包含条件。 + * + * @param column 字段 + * @param values 条件值集合 + * @return 链式返回对象 + */ default Children inIfNotEmpty(SFunction column, Collection values) { return in(values != null && !values.isEmpty(), column, values); } + /** + * 数组不为空时添加包含条件。 + * + * @param column 字段 + * @param values 条件值数组 + * @return 链式返回对象 + */ default Children inIfNotEmpty(SFunction column, Object... values) { return in(values != null && values.length > 0, column, values); } + /** + * 集合不为空时添加不包含条件。 + * + * @param column 字段 + * @param values 条件值集合 + * @return 链式返回对象 + */ default Children notInIfNotEmpty(SFunction column, Collection values) { return notIn(values != null && !values.isEmpty(), column, values); } + /** + * 数组不为空时添加不包含条件。 + * + * @param column 字段 + * @param values 条件值数组 + * @return 链式返回对象 + */ default Children notInIfNotEmpty(SFunction 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); } diff --git a/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/QueryBuilder.java b/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/QueryBuilder.java index 30b710d80..69a2e9660 100644 --- a/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/QueryBuilder.java +++ b/ruoyi-common/ruoyi-common-mybatis/src/main/java/org/dromara/common/mybatis/core/query/QueryBuilder.java @@ -12,6 +12,13 @@ public final class QueryBuilder { private QueryBuilder() { } + /** + * 创建 Lambda 查询构造辅助对象。 + * + * @param entityClass 实体类型 + * @param 实体类型 + * @return Lambda 查询构造辅助对象 + */ public static LambdaQueryBuilder lambda(Class entityClass) { return new LambdaQueryBuilder<>(Wrappers.lambdaQuery(entityClass)); }