com.dynamic.sql.core.condition

接口 Condition

所有已知子接口:

FunctionCondition, HavingCondition, NestedCondition

所有已知实现类:

GenericWhereCondition, MysqlWhereCondition, OracleWhereCondition, WhereCondition

public interface Condition

SQL 查询条件接口，用于构建动态 SQL 查询条件。 此接口同时支持 WHERE 和 ON 条件的使用。

此接口提供了一组方法，以流式（链式）方式构建 SQL 查询条件， 支持常见的 SQL 操作符和函数，例如相等、比较、范围、模糊匹配等。 组合各种条件，来生成符合需求的动态 SQL 语句。接口设计上允许条件的组合与扩展， 支持灵活的查询需求。

每个方法都支持链式调用，使得构建复杂的查询条件变得更加简洁和直观。方法前缀（如 `and`, `or`） 表示条件的逻辑关系，用以准确地描述查询的逻辑。

具体方法的使用说明如下：

• andEqualTo(Fn<T, F> fn, Object value)：添加一个“等于”条件，并且将其与之前的条件通过 AND 逻辑连接。
• orEqualTo(Fn<T, F> fn, Object value)：添加一个“等于”条件，并且将其与之前的条件通过 OR 逻辑连接。
• customCondition(String customClause, Object... params)：允许添加自定义的 SQL 条件子句，以支持特殊的 SQL 语法和逻辑。

使用此接口时，可以快速创建一个实现类或通过依赖注入使用实现类来进行查询条件的构建。

示例：

 Condition condition = new SqlConditionBuilder()
     .andEqualTo(User::getName, "John")
     .orGreaterThan(User::getAge, 30)
     .andCustomCondition("custom_column BETWEEN ? AND ?", 10, 20);
 

以上代码将构建一个包含“姓名等于 John”或者“年龄大于 30”并且“custom_column 在 10 到 20 之间”的查询条件。

方法概要

限定符和类型	方法和说明
<T1,T2,F> Condition	andBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 添加字段 BETWEEN 连接条件，并且运算。
<T,F> Condition	andBetween(Fn<T,F> fn, Object start, Object end) 添加字段在指定范围内条件，并且运算。
default Condition	andCondition(Consumer<Condition> nestedCondition) 添加一组条件，并且运算。
Condition	andEqualTo(Column column, Object value)
<T1,T2,F> Condition	andEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加等值连接条件，并且运算。
<T,F> Condition	andEqualTo(Fn<T,F> fn, Object value) 添加等于条件，并且运算。
<T,F> Condition	andFindInSet(Fn<T,F> fn, Object item) 添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数）。
<T,F> Condition	andFindInSet(Fn<T,F> fn, Object item, String separator) 添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数），并指定分隔符。
<T1,T2,F> Condition	andGreaterThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于连接条件，并且运算。
<T,F> Condition	andGreaterThan(Fn<T,F> fn, Object value) 添加字段大于指定值条件，并且运算。
<T1,T2,F> Condition	andGreaterThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于或等于连接条件，并且运算。
<T,F> Condition	andGreaterThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段大于或等于指定值条件，并且运算。
Condition	andIn(Column column, Iterable<?> values)
<T,F> Condition	andIn(Fn<T,F> fn, Iterable<?> values) 添加字段在指定值集合中条件，并且运算。
<T,F> Condition	andIsNotNull(Fn<T,F> fn) 添加字段非空值条件，并且运算。
<T,F> Condition	andIsNull(Fn<T,F> fn) 添加字段为空值条件，并且运算。
<T1,T2,F> Condition	andLessThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于连接条件，并且运算。
<T,F> Condition	andLessThan(Fn<T,F> fn, Object value) 添加字段小于指定值条件，并且运算。
<T1,T2,F> Condition	andLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于或等于连接条件，并且运算。
<T,F> Condition	andLessThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段小于或等于指定值条件，并且运算。
<T,F> Condition	andLike(Fn<T,F> fn, String pattern) 添加字段匹配指定模式条件，并且运算。
<T,F> Condition	andMatches(Fn<T,F> fn, String regex) 添加字段匹配正则表达式条件，并且运算。
<T,F> Condition	andNotBetween(Fn<T,F> fn, Object start, Object end) 添加字段不在指定范围内条件，并且运算。
<T1,T2,F> Condition	andNotEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段不等值连接条件，并且运算。
<T,F> Condition	andNotEqualTo(Fn<T,F> fn, Object value) 添加不等于条件，并且运算。
<T,F> Condition	andNotIn(Fn<T,F> fn, Iterable<?> values) 添加字段不在指定值集合中条件，并且运算。
<T,F> Condition	andNotLike(Fn<T,F> fn, String pattern) 添加字段不匹配指定模式条件，并且运算。
Condition	limit(int limit) 限制查询结果的返回行数
Condition	limit(int offset, int limit) 限制查询结果的返回行数
<T1,T2,F> Condition	orBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 添加字段 BETWEEN 连接条件，或运算。
<T,F> Condition	orBetween(Fn<T,F> fn, Object start, Object end) 添加字段在指定范围内条件，或运算。
default Condition	orCondition(Consumer<Condition> nestedCondition) 添加一个嵌套条件，或运算。
<T1,T2,F> Condition	orEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段等值连接条件，或运算。
<T,F> Condition	orEqualTo(Fn<T,F> fn, Object value) 添加等于条件，或运算。
<T,F> Condition	orFindInSet(Fn<T,F> fn, Object item) 添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数）。
<T,F> Condition	orFindInSet(Fn<T,F> fn, Object item, String separator) 添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数），并指定分隔符。
<T1,T2,F> Condition	orGreaterThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于连接条件，或运算。
<T,F> Condition	orGreaterThan(Fn<T,F> fn, Object value) 添加字段大于指定值条件，或运算。
<T1,T2,F> Condition	orGreaterThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于或等于连接条件，或运算。
<T,F> Condition	orGreaterThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段大于或等于指定值条件，或运算。
<T,F> Condition	orIn(Fn<T,F> fn, Iterable<?> values) 添加字段在指定值集合中条件，或运算。
<T,F> Condition	orIsNotNull(Fn<T,F> fn) 添加字段非空值条件，或运算。
<T,F> Condition	orIsNull(Fn<T,F> fn) 添加字段为空值条件，或运算。
<T1,T2,F> Condition	orLessThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于连接条件，或运算。
<T,F> Condition	orLessThan(Fn<T,F> fn, Object value) 添加字段小于指定值条件，或运算。
<T1,T2,F> Condition	orLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于或等于连接条件，或运算。
<T,F> Condition	orLessThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段小于或等于指定值条件，或运算。
<T,F> Condition	orLike(Fn<T,F> fn, String pattern) 添加字段匹配指定模式条件，或运算。
<T,F> Condition	orMatches(Fn<T,F> fn, String regex) 添加字段匹配正则表达式条件，或运算。
<T,F> Condition	orNotBetween(Fn<T,F> fn, Object start, Object end) 添加字段不在指定范围内条件，或运算。
<T1,T2,F> Condition	orNotEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段不等值连接条件，或运算。
<T,F> Condition	orNotEqualTo(Fn<T,F> fn, Object value) 添加不等于条件，或运算。
<T,F> Condition	orNotIn(Fn<T,F> fn, Iterable<?> values) 添加字段不在指定值集合中条件，或运算。
<T,F> Condition	orNotLike(Fn<T,F> fn, String pattern) 添加字段不匹配指定模式条件，或运算。

方法详细资料

andEqualTo

<T,F> Condition andEqualTo(Fn<T,F> fn,
                           Object value)

添加等于条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

andEqualTo

Condition andEqualTo(Column column,
                     Object value)

andEqualTo

<T1,T2,F> Condition andEqualTo(Fn<T1,F> field1,
                               Fn<T2,F> field2)

添加等值连接条件，并且运算。

     on.andEqualTo(Student::getClassId, Class::getId);
 

这将会生成 SQL 中的 "ON Student.classId = Class.id" 条件。

类型参数:

T1 - 第一个实体类类型

T2 - 第二个实体类类型

F - 字段类型

参数:

field1 - 第一个字段，来自第一个实体类

field2 - 第二个字段，来自第二个实体类

返回:

当前的 Condition 实例，以便实现链式调用

orEqualTo

<T,F> Condition orEqualTo(Fn<T,F> fn,
                          Object value)

添加等于条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

orEqualTo

<T1,T2,F> Condition orEqualTo(Fn<T1,F> field1,
                              Fn<T2,F> field2)

添加字段等值连接条件，或运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取第一个字段值的函数

field2 - 用于获取第二个字段值的函数

返回:

当前 Condition 实例

andNotEqualTo

<T,F> Condition andNotEqualTo(Fn<T,F> fn,
                              Object value)

添加不等于条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

andNotEqualTo

<T1,T2,F> Condition andNotEqualTo(Fn<T1,F> field1,
                                  Fn<T2,F> field2)

添加字段不等值连接条件，并且运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取第一个字段值的函数

field2 - 用于获取第二个字段值的函数

返回:

当前 Condition 实例

orNotEqualTo

<T,F> Condition orNotEqualTo(Fn<T,F> fn,
                             Object value)

添加不等于条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

orNotEqualTo

<T1,T2,F> Condition orNotEqualTo(Fn<T1,F> field1,
                                 Fn<T2,F> field2)

添加字段不等值连接条件，或运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取第一个字段值的函数

field2 - 用于获取第二个字段值的函数

返回:

当前 Condition 实例

andIsNull

<T,F> Condition andIsNull(Fn<T,F> fn)

添加字段为空值条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

返回:

当前 Condition 实例

orIsNull

<T,F> Condition orIsNull(Fn<T,F> fn)

添加字段为空值条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

返回:

当前 Condition 实例

andIsNotNull

<T,F> Condition andIsNotNull(Fn<T,F> fn)

添加字段非空值条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

返回:

当前 Condition 实例

orIsNotNull

<T,F> Condition orIsNotNull(Fn<T,F> fn)

添加字段非空值条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

返回:

当前 Condition 实例

andGreaterThan

<T,F> Condition andGreaterThan(Fn<T,F> fn,
                               Object value)

添加字段大于指定值条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

andGreaterThan

<T1,T2,F> Condition andGreaterThan(Fn<T1,F> field1,
                                   Fn<T2,F> field2)

添加字段大于连接条件，并且运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取第一个字段值的函数

field2 - 用于获取第二个字段值的函数

返回:

当前 Condition 实例

orGreaterThan

<T,F> Condition orGreaterThan(Fn<T,F> fn,
                              Object value)

添加字段大于指定值条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

orGreaterThan

<T1,T2,F> Condition orGreaterThan(Fn<T1,F> field1,
                                  Fn<T2,F> field2)

添加字段大于连接条件，或运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取第一个字段值的函数

field2 - 用于获取第二个字段值的函数

返回:

当前 Condition 实例

andGreaterThanOrEqualTo

<T,F> Condition andGreaterThanOrEqualTo(Fn<T,F> fn,
                                        Object value)

添加字段大于或等于指定值条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

andGreaterThanOrEqualTo

<T1,T2,F> Condition andGreaterThanOrEqualTo(Fn<T1,F> field1,
                                            Fn<T2,F> field2)

添加字段大于或等于连接条件，并且运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取第一个字段值的函数

field2 - 用于获取第二个字段值的函数

返回:

当前 Condition 实例

orGreaterThanOrEqualTo

<T,F> Condition orGreaterThanOrEqualTo(Fn<T,F> fn,
                                       Object value)

添加字段大于或等于指定值条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

orGreaterThanOrEqualTo

<T1,T2,F> Condition orGreaterThanOrEqualTo(Fn<T1,F> field1,
                                           Fn<T2,F> field2)

添加字段大于或等于连接条件，或运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取第一个字段值的函数

field2 - 用于获取第二个字段值的函数

返回:

当前 Condition 实例

andLessThan

<T,F> Condition andLessThan(Fn<T,F> fn,
                            Object value)

添加字段小于指定值条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

andLessThan

<T1,T2,F> Condition andLessThan(Fn<T1,F> field1,
                                Fn<T2,F> field2)

添加字段小于连接条件，并且运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取第一个字段值的函数

field2 - 用于获取第二个字段值的函数

返回:

当前 Condition 实例

orLessThan

<T,F> Condition orLessThan(Fn<T,F> fn,
                           Object value)

添加字段小于指定值条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

orLessThan

<T1,T2,F> Condition orLessThan(Fn<T1,F> field1,
                               Fn<T2,F> field2)

添加字段小于连接条件，或运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取第一个字段值的函数

field2 - 用于获取第二个字段值的函数

返回:

当前 Condition 实例

andLessThanOrEqualTo

<T,F> Condition andLessThanOrEqualTo(Fn<T,F> fn,
                                     Object value)

添加字段小于或等于指定值条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

andLessThanOrEqualTo

<T1,T2,F> Condition andLessThanOrEqualTo(Fn<T1,F> field1,
                                         Fn<T2,F> field2)

添加字段小于或等于连接条件，并且运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取第一个字段值的函数

field2 - 用于获取第二个字段值的函数

返回:

当前 Condition 实例

orLessThanOrEqualTo

<T,F> Condition orLessThanOrEqualTo(Fn<T,F> fn,
                                    Object value)

添加字段小于或等于指定值条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

value - 匹配的值

返回:

当前 Condition 实例

orLessThanOrEqualTo

<T1,T2,F> Condition orLessThanOrEqualTo(Fn<T1,F> field1,
                                        Fn<T2,F> field2)

添加字段小于或等于连接条件，或运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取第一个字段值的函数

field2 - 用于获取第二个字段值的函数

返回:

当前 Condition 实例

andIn

<T,F> Condition andIn(Fn<T,F> fn,
                      Iterable<?> values)

添加字段在指定值集合中条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

values - 匹配的值集合

返回:

当前 Condition 实例

andIn

Condition andIn(Column column,
                Iterable<?> values)

orIn

<T,F> Condition orIn(Fn<T,F> fn,
                     Iterable<?> values)

添加字段在指定值集合中条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

values - 匹配的值集合

返回:

当前 Condition 实例

andNotIn

<T,F> Condition andNotIn(Fn<T,F> fn,
                         Iterable<?> values)

添加字段不在指定值集合中条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

values - 匹配的值集合

返回:

当前 Condition 实例

orNotIn

<T,F> Condition orNotIn(Fn<T,F> fn,
                        Iterable<?> values)

添加字段不在指定值集合中条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

values - 匹配的值集合

返回:

当前 Condition 实例

andBetween

<T,F> Condition andBetween(Fn<T,F> fn,
                           Object start,
                           Object end)

添加字段在指定范围内条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

andBetween

<T1,T2,F> Condition andBetween(Fn<T1,F> field1,
                               Fn<T2,F> startField,
                               Fn<T2,F> endField)

添加字段 BETWEEN 连接条件，并且运算。

该方法用于构建一个 BETWEEN 连接条件，将指定字段的值与起始值和结束值之间的范围进行比较。 在调用此方法时，可以传入一个用于获取字段值的函数，以及两个用于获取起始值和结束值的函数。 这将生成一个 BETWEEN 条件，将其与当前条件组合使用。

例如，假设有两个表 `Order` 和 `Product`，可以使用此方法将 `Order` 表的某个字段与 `Product` 表中的起始和结束字段之间的范围进行比较：

     condition.andBetween(
         Order::getOrderDate,           // Order 表的字段
         Product::getStartDate,         // Product 表中的起始字段
         Product::getEndDate            // Product 表中的结束字段
     );
 

这将生成类似于以下 SQL 条件：

     Order.orderDate BETWEEN Product.startDate AND Product.endDate
 

类型参数:

T1 - 实体类类型1，表示第一个表的实体类

T2 - 实体类类型2，表示第二个表的实体类

F - 字段类型，表示字段的数据类型

参数:

field1 - 用于获取字段值的函数，表示要进行 BETWEEN 比较的字段

startField - 用于获取起始值的函数，表示范围的起始值

endField - 用于获取结束值的函数，表示范围的结束值

返回:

当前 Condition 实例，以便实现链式调用

orBetween

<T,F> Condition orBetween(Fn<T,F> fn,
                          Object start,
                          Object end)

添加字段在指定范围内条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

orBetween

<T1,T2,F> Condition orBetween(Fn<T1,F> field1,
                              Fn<T2,F> startField,
                              Fn<T2,F> endField)

添加字段 BETWEEN 连接条件，或运算。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

field1 - 用于获取字段值的函数

startField - 用于获取起始值的函数

endField - 用于获取结束值的函数

返回:

当前 Condition 实例

另请参阅:

this#andBetween(Fn, Fn, Fn)

andNotBetween

<T,F> Condition andNotBetween(Fn<T,F> fn,
                              Object start,
                              Object end)

添加字段不在指定范围内条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

orNotBetween

<T,F> Condition orNotBetween(Fn<T,F> fn,
                             Object start,
                             Object end)

添加字段不在指定范围内条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

andLike

<T,F> Condition andLike(Fn<T,F> fn,
                        String pattern)

添加字段匹配指定模式条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

pattern - 匹配的模式（如 SQL 的 LIKE 子句）

返回:

当前 Condition 实例

orLike

<T,F> Condition orLike(Fn<T,F> fn,
                       String pattern)

添加字段匹配指定模式条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

pattern - 匹配的模式（如 SQL 的 LIKE 子句）

返回:

当前 Condition 实例

andNotLike

<T,F> Condition andNotLike(Fn<T,F> fn,
                           String pattern)

添加字段不匹配指定模式条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

pattern - 匹配的模式（如 SQL 的 LIKE 子句）

返回:

当前 Condition 实例

orNotLike

<T,F> Condition orNotLike(Fn<T,F> fn,
                          String pattern)

添加字段不匹配指定模式条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

pattern - 匹配的模式（如 SQL 的 LIKE 子句）

返回:

当前 Condition 实例

andMatches

<T,F> Condition andMatches(Fn<T,F> fn,
                           String regex)

添加字段匹配正则表达式条件，并且运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

regex - 正则表达式模式

返回:

当前 Condition 实例

orMatches

<T,F> Condition orMatches(Fn<T,F> fn,
                          String regex)

添加字段匹配正则表达式条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

regex - 正则表达式模式

返回:

当前 Condition 实例

andFindInSet

<T,F> Condition andFindInSet(Fn<T,F> fn,
                             Object item)

添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数）。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

item - 指定的项目

返回:

当前 Condition 实例

andFindInSet

<T,F> Condition andFindInSet(Fn<T,F> fn,
                             Object item,
                             String separator)

添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数），并指定分隔符。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

item - 指定的项目

separator - 分隔符

返回:

当前 Condition 实例

orFindInSet

<T,F> Condition orFindInSet(Fn<T,F> fn,
                            Object item)

添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数）。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

item - 指定的项目

返回:

当前 Condition 实例

orFindInSet

<T,F> Condition orFindInSet(Fn<T,F> fn,
                            Object item,
                            String separator)

添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数），并指定分隔符。

类型参数:

T - 实体类类型

F - 字段类型

参数:

fn - 用于获取字段值的函数

item - 指定的项目

separator - 分隔符

返回:

当前 Condition 实例

limit

Condition limit(int offset,
                int limit)

限制查询结果的返回行数

参数:

offset - 需要跳过的行数

limit - 返回的最大行数

返回:

当前 Condition 实例

limit

Condition limit(int limit)

限制查询结果的返回行数

参数:

limit - 返回的最大行数

返回:

当前 Condition 实例

andCondition

default Condition andCondition(Consumer<Condition> nestedCondition)

添加一组条件，并且运算。

该方法允许将一组条件作为当前条件的子条件进行添加，并且将它们合并为一个结果。 其中传入的 Consumer 对象接受一个 Condition 实例， 用于设置嵌套的条件组合。

例如：

     condition.andCondition(nestedCondition -> {
         nestedCondition.andEqualTo(SomeClass::getA, 1);
         nestedCondition.orCondition(innerCondition -> {
             innerCondition.andEqualTo(SomeClass::getB, 2);
             innerCondition.orEqualTo(SomeClass::getC, 2);
         });
     });
 

参数:

nestedCondition - 用于配置嵌套条件的 Consumer 对象

返回:

当前的 Condition 实例，以便实现链式调用

orCondition

default Condition orCondition(Consumer<Condition> nestedCondition)

添加一个嵌套条件，或运算。

参数:

nestedCondition - 用于配置嵌套条件的 Consumer 对象

返回:

当前的 Condition 实例，以便实现链式调用

另请参阅:

this#andCondition(Consumer)