com.dynamic.sql.core.condition

接口 Condition

所有已知子接口:

FunctionCondition, HavingCondition, NestedCondition

所有已知实现类:

GenericWhereCondition, MysqlWhereCondition, OracleWhereCondition, WhereCondition

public interface Condition

查询条件构建接口，用于构造数据库查询的条件。

此接口提供了一系列方法，用于构建 SQL 查询中的条件，支持 AND 和 OR 逻辑运算， 包括等于、不等于、大于、小于、范围、集合、正则表达式等操作。支持链式调用。

方法概要

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

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 Condition 实例

andEqualTo

Condition andEqualTo(Column column,
                     Object value)

andEqualTo

default Condition andEqualTo(boolean isEffective,
                             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 实例，以便实现链式调用

andEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 第一个实体类类型

T2 - 第二个实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前的 Condition 实例

andEqualTo

Condition andEqualTo(ColumFunction columFunction,
                     Object value)

andEqualTo

default Condition andEqualTo(boolean isEffective,
                             ColumFunction columFunction,
                             Object value)

orEqualTo

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

添加等于条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orEqualTo

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

根据条件添加等于条件，或运算。

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

orEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

orEqualTo

Condition orEqualTo(ColumFunction columFunction,
                    Object value)

orEqualTo

default Condition orEqualTo(boolean isEffective,
                            ColumFunction columFunction,
                            Object value)

andNotEqualTo

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

andNotEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

andNotEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

andNotEqualTo

Condition andNotEqualTo(ColumFunction columFunction,
                        Object value)

andNotEqualTo

default Condition andNotEqualTo(boolean isEffective,
                                ColumFunction columFunction,
                                Object value)

orNotEqualTo

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orNotEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

orNotEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

orNotEqualTo

Condition orNotEqualTo(ColumFunction columFunction,
                       Object value)

orNotEqualTo

default Condition orNotEqualTo(boolean isEffective,
                               ColumFunction columFunction,
                               Object value)

andIsNull

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 Condition 实例

andIsNull

default <T,F> Condition andIsNull(boolean isEffective,
                                  Fn<T,F> fn)

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

返回:

当前 Condition 实例

andIsNull

Condition andIsNull(ColumFunction columFunction,
                    Object value)

andIsNull

default Condition andIsNull(boolean isEffective,
                            ColumFunction columFunction,
                            Object value)

orIsNull

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 Condition 实例

orIsNull

default <T,F> Condition orIsNull(boolean isEffective,
                                 Fn<T,F> fn)

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

返回:

当前 Condition 实例

orIsNull

Condition orIsNull(ColumFunction columFunction,
                   Object value)

orIsNull

default Condition orIsNull(boolean isEffective,
                           ColumFunction columFunction,
                           Object value)

andIsNotNull

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 Condition 实例

andIsNotNull

default <T,F> Condition andIsNotNull(boolean isEffective,
                                     Fn<T,F> fn)

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

返回:

当前 Condition 实例

andIsNotNull

Condition andIsNotNull(ColumFunction columFunction,
                       Object value)

andIsNotNull

default Condition andIsNotNull(boolean isEffective,
                               ColumFunction columFunction,
                               Object value)

orIsNotNull

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 Condition 实例

orIsNotNull

default <T,F> Condition orIsNotNull(boolean isEffective,
                                    Fn<T,F> fn)

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

返回:

当前 Condition 实例

orIsNotNull

Condition orIsNotNull(ColumFunction columFunction,
                      Object value)

orIsNotNull

default Condition orIsNotNull(boolean isEffective,
                              ColumFunction columFunction,
                              Object value)

andGreaterThan

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

andGreaterThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

andGreaterThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

andGreaterThan

Condition andGreaterThan(ColumFunction columFunction,
                         Object value)

andGreaterThan

default Condition andGreaterThan(boolean isEffective,
                                 ColumFunction columFunction,
                                 Object value)

orGreaterThan

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orGreaterThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

orGreaterThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

orGreaterThan

Condition orGreaterThan(ColumFunction columFunction,
                        Object value)

orGreaterThan

default Condition orGreaterThan(boolean isEffective,
                                ColumFunction columFunction,
                                Object value)

andGreaterThanOrEqualTo

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

andGreaterThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

andGreaterThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

andGreaterThanOrEqualTo

Condition andGreaterThanOrEqualTo(ColumFunction columFunction,
                                  Object value)

andGreaterThanOrEqualTo

default Condition andGreaterThanOrEqualTo(boolean isEffective,
                                          ColumFunction columFunction,
                                          Object value)

orGreaterThanOrEqualTo

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orGreaterThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

orGreaterThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

orGreaterThanOrEqualTo

Condition orGreaterThanOrEqualTo(ColumFunction columFunction,
                                 Object value)

orGreaterThanOrEqualTo

default Condition orGreaterThanOrEqualTo(boolean isEffective,
                                         ColumFunction columFunction,
                                         Object value)

andLessThan

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

andLessThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

andLessThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

andLessThan

Condition andLessThan(ColumFunction columFunction,
                      Object value)

andLessThan

default Condition andLessThan(boolean isEffective,
                              ColumFunction columFunction,
                              Object value)

orLessThan

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orLessThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

orLessThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

orLessThan

Condition orLessThan(ColumFunction columFunction,
                     Object value)

orLessThan

default Condition orLessThan(boolean isEffective,
                             ColumFunction columFunction,
                             Object value)

andLessThanOrEqualTo

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

andLessThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

andLessThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

andLessThanOrEqualTo

Condition andLessThanOrEqualTo(ColumFunction columFunction,
                               Object value)

andLessThanOrEqualTo

default Condition andLessThanOrEqualTo(boolean isEffective,
                                       ColumFunction columFunction,
                                       Object value)

orLessThanOrEqualTo

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orLessThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

orLessThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

orLessThanOrEqualTo

Condition orLessThanOrEqualTo(ColumFunction columFunction,
                              Object value)

orLessThanOrEqualTo

default Condition orLessThanOrEqualTo(boolean isEffective,
                                      ColumFunction columFunction,
                                      Object value)

andIn

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 Condition 实例

andIn

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

values - 匹配的值集合

返回:

当前 Condition 实例

andIn

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

andIn

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

andIn

Condition andIn(ColumFunction columFunction,
                Iterable<?> values)

andIn

default Condition andIn(boolean isEffective,
                        ColumFunction columFunction,
                        Iterable<?> values)

orIn

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 Condition 实例

orIn

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

values - 匹配的值集合

返回:

当前 Condition 实例

orIn

Condition orIn(ColumFunction columFunction,
               Iterable<?> values)

orIn

default Condition orIn(boolean isEffective,
                       ColumFunction columFunction,
                       Iterable<?> values)

andNotIn

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 Condition 实例

andNotIn

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

values - 匹配的值集合

返回:

当前 Condition 实例

andNotIn

Condition andNotIn(ColumFunction columFunction,
                   Iterable<?> values)

andNotIn

default Condition andNotIn(boolean isEffective,
                           ColumFunction columFunction,
                           Iterable<?> values)

orNotIn

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 Condition 实例

orNotIn

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

values - 匹配的值集合

返回:

当前 Condition 实例

orNotIn

Condition orNotIn(ColumFunction columFunction,
                  Iterable<?> values)

orNotIn

default Condition orNotIn(boolean isEffective,
                          ColumFunction columFunction,
                          Iterable<?> values)

andBetween

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

andBetween

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例，以便实现链式调用

andBetween

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

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

返回:

当前 Condition 实例

orBetween

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

orBetween

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

另请参阅:

andBetween(Fn, Fn, Fn)

orBetween

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

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

返回:

当前 Condition 实例

andNotBetween

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

andNotBetween

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

orNotBetween

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

orNotBetween

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

andLike

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andLike

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

orLike

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orLike

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

andNotLike

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andNotLike

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

orNotLike

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orNotLike

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 Condition 实例

andMatches

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

regex - 正则表达式模式

返回:

当前 Condition 实例

andMatches

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

regex - 正则表达式模式

返回:

当前 Condition 实例

orMatches

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

regex - 正则表达式模式

返回:

当前 Condition 实例

orMatches

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

regex - 正则表达式模式

返回:

当前 Condition 实例

andFindInSet

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

返回:

当前 Condition 实例

andFindInSet

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

andFindInSet

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

item - 指定的项目

separator - 分隔符

返回:

当前 Condition 实例

orFindInSet

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

返回:

当前 Condition 实例

orFindInSet

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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 实例

orFindInSet

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

item - 指定的项目

separator - 分隔符

返回:

当前 Condition 实例

limit

Condition limit(int offset,
                int limit)

限制查询结果的返回行数。

参数:

offset - 需要跳过的行数

limit - 返回的最大行数

返回:

当前 Condition 实例

limit

default Condition limit(boolean isEffective,
                        int offset,
                        int limit)

根据条件限制查询结果的返回行数。

仅当 isEffective 为 true 时应用限制。

参数:

isEffective - 是否使条件生效

offset - 需要跳过的行数

limit - 返回的最大行数

返回:

当前 Condition 实例

limit

Condition limit(int limit)

限制查询结果的返回行数。

参数:

limit - 返回的最大行数

返回:

当前 Condition 实例

limit

default Condition limit(boolean isEffective,
                        int limit)

根据条件限制查询结果的返回行数。

仅当 isEffective 为 true 时应用限制。

参数:

isEffective - 是否使条件生效

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 实例，以便实现链式调用

andCondition

default Condition andCondition(boolean isEffective,
                               Consumer<Condition> nestedCondition)

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

仅当 isEffective 为 true 时应用嵌套条件。

参数:

isEffective - 是否使条件生效

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

返回:

当前的 Condition 实例

orCondition

default Condition orCondition(Consumer<Condition> nestedCondition)

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

参数:

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

返回:

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

另请参阅:

andCondition(Consumer)

orCondition

default Condition orCondition(boolean isEffective,
                              Consumer<Condition> nestedCondition)

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

仅当 isEffective 为 true 时应用嵌套条件。

参数:

isEffective - 是否使条件生效

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

返回:

当前的 Condition 实例

andFunction

Condition andFunction(ColumFunction columFunction)

使用 AND 逻辑连接一个列函数条件。

该方法将指定的列函数条件与当前条件通过 AND 逻辑运算符连接，形成一个新的复合条件。 适用于需要多个条件同时满足的查询场景。

示例：查询指定的点是否包含在其中

     
         List<LocationEntity> list = sqlContext.select()
                 .allColumn()
                 .from(LocationEntity.class)
                 .where(whereCondition -> whereCondition.andFunction(new Contains(LocationEntity::getArea, new Point(5, 5))))
                 .fetch()
                 .toList();
         System.out.println(list.size());
     
 

参数:

columFunction - 要与当前条件通过 AND 连接的列函数条件，不能为空。 该参数通常表示对数据库列的某种操作或计算（例如 SUM、AVG 等）。

返回:

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

andFunction

default Condition andFunction(boolean isEffective,
                              ColumFunction columFunction)

根据条件使用 AND 逻辑连接一个列函数条件。

仅当 isEffective 为 true 时追加条件。

参数:

isEffective - 是否使条件生效

columFunction - 要与当前条件通过 AND 连接的列函数条件

返回:

当前的 Condition 实例

orFunction

Condition orFunction(ColumFunction columFunction)

使用 OR 逻辑连接一个列函数条件。

该方法将指定的列函数条件与当前条件通过 OR 逻辑运算符连接，形成一个新的复合条件。 适用于需要多个条件中至少一个满足的查询场景。

参数:

columFunction - 要与当前条件通过 OR 连接的列函数条件，不能为空。 该参数通常表示对数据库列的某种操作或计算（例如 MAX、MIN 等）。

返回:

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

orFunction

default Condition orFunction(boolean isEffective,
                             ColumFunction columFunction)

根据条件使用 OR 逻辑连接一个列函数条件。

仅当 isEffective 为 true 时追加条件。

参数:

isEffective - 是否使条件生效

columFunction - 要与当前条件通过 OR 连接的列函数条件，不能为空。 该参数通常表示对数据库列的某种操作或计算（例如 MAX、MIN 等）。

返回:

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