Condition (dynamic-sql2 0.1.1 API)

All Known Subinterfaces:

FunctionCondition<C>, HavingCondition<C>, NestedCondition<C>

All Known Implementing Classes:

GenericWhereCondition, MysqlWhereCondition, OracleWhereCondition, WhereCondition
```
public interface Condition<C extends Condition<C>>
```
查询条件构建接口，用于构造数据库查询的条件。
此接口提供了一系列方法，用于构建 SQL 查询中的条件，支持 AND 和 OR 逻辑运算，包括等于、不等于、大于、小于、范围、集合、正则表达式等操作。支持链式调用。

Method Summary

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

- Method Detail
  - andEqualTo
```
<T,F> C andEqualTo(Fn<T,F> fn,
                   Object value)
```
    添加等于条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andEqualTo
```
default <T,F> C andEqualTo(boolean isEffective,
                           Fn<T,F> fn,
                           Object value)
```
    根据条件添加等于条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andEqualTo
```
C andEqualTo(Column column,
             Object value)
```
  - andEqualTo
```
default C andEqualTo(boolean isEffective,
                     Column column,
                     Object value)
```
  - andEqualTo
```
<T1,T2,F> C andEqualTo(Fn<T1,F> field1,
                       Fn<T2,F> field2)
```
    添加等值连接条件，并且运算。
```
     on.andEqualTo(Student::getClassId, Class::getId);
 
```
    这将会生成 SQL 中的 "ON Student.classId = Class.id" 条件。
    Type Parameters:
    
    T1 - 第一个实体类类型
    
    T2 - 第二个实体类类型
    
    F - 字段类型
    
    Parameters:
    
    field1 - 第一个字段，来自第一个实体类
    
    field2 - 第二个字段，来自第二个实体类
    
    Returns:
    
    当前的 Condition 实例，以便实现链式调用
  - andEqualTo
```
default <T1,T2,F> C andEqualTo(boolean isEffective,
                               Fn<T1,F> field1,
                               Fn<T2,F> field2)
```
    根据条件添加等值连接条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 第一个实体类类型
    
    T2 - 第二个实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 第一个字段，来自第一个实体类
    
    field2 - 第二个字段，来自第二个实体类
    
    Returns:
    
    当前的 Condition 实例
  - andEqualTo
```
C andEqualTo(ColumFunction columFunction,
             Object value)
```
  - andEqualTo
```
default C andEqualTo(boolean isEffective,
                     ColumFunction columFunction,
                     Object value)
```
  - orEqualTo
```
<T,F> C orEqualTo(Fn<T,F> fn,
                  Object value)
```
    添加等于条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orEqualTo
```
default <T,F> C orEqualTo(boolean isEffective,
                          Fn<T,F> fn,
                          Object value)
```
    根据条件添加等于条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orEqualTo
```
<T1,T2,F> C orEqualTo(Fn<T1,F> field1,
                      Fn<T2,F> field2)
```
    添加字段等值连接条件，或运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orEqualTo
```
default <T1,T2,F> C orEqualTo(boolean isEffective,
                              Fn<T1,F> field1,
                              Fn<T2,F> field2)
```
    根据条件添加字段等值连接条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orEqualTo
```
C orEqualTo(ColumFunction columFunction,
            Object value)
```
  - orEqualTo
```
default C orEqualTo(boolean isEffective,
                    ColumFunction columFunction,
                    Object value)
```
  - andNotEqualTo
```
<T,F> C andNotEqualTo(Fn<T,F> fn,
                      Object value)
```
    添加不等于条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andNotEqualTo
```
default <T,F> C andNotEqualTo(boolean isEffective,
                              Fn<T,F> fn,
                              Object value)
```
    根据条件添加不等于条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andNotEqualTo
```
<T1,T2,F> C andNotEqualTo(Fn<T1,F> field1,
                          Fn<T2,F> field2)
```
    添加字段不等值连接条件，并且运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - andNotEqualTo
```
default <T1,T2,F> C andNotEqualTo(boolean isEffective,
                                  Fn<T1,F> field1,
                                  Fn<T2,F> field2)
```
    根据条件添加字段不等值连接条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - andNotEqualTo
```
C andNotEqualTo(ColumFunction columFunction,
                Object value)
```
  - andNotEqualTo
```
default C andNotEqualTo(boolean isEffective,
                        ColumFunction columFunction,
                        Object value)
```
  - orNotEqualTo
```
<T,F> C orNotEqualTo(Fn<T,F> fn,
                     Object value)
```
    添加不等于条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orNotEqualTo
```
default <T,F> C orNotEqualTo(boolean isEffective,
                             Fn<T,F> fn,
                             Object value)
```
    根据条件添加不等于条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orNotEqualTo
```
<T1,T2,F> C orNotEqualTo(Fn<T1,F> field1,
                         Fn<T2,F> field2)
```
    添加字段不等值连接条件，或运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orNotEqualTo
```
default <T1,T2,F> C orNotEqualTo(boolean isEffective,
                                 Fn<T1,F> field1,
                                 Fn<T2,F> field2)
```
    根据条件添加字段不等值连接条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orNotEqualTo
```
C orNotEqualTo(ColumFunction columFunction,
               Object value)
```
  - orNotEqualTo
```
default C orNotEqualTo(boolean isEffective,
                       ColumFunction columFunction,
                       Object value)
```
  - andIsNull
```
<T,F> C andIsNull(Fn<T,F> fn)
```
    添加字段为空值条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    Returns:
    
    当前 C 实例
  - andIsNull
```
default <T,F> C andIsNull(boolean isEffective,
                          Fn<T,F> fn)
```
    根据条件添加字段为空值条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    Returns:
    
    当前 C 实例
  - andIsNull
```
C andIsNull(ColumFunction columFunction,
            Object value)
```
  - andIsNull
```
default C andIsNull(boolean isEffective,
                    ColumFunction columFunction,
                    Object value)
```
  - orIsNull
```
<T,F> C orIsNull(Fn<T,F> fn)
```
    添加字段为空值条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    Returns:
    
    当前 C 实例
  - orIsNull
```
default <T,F> C orIsNull(boolean isEffective,
                         Fn<T,F> fn)
```
    根据条件添加字段为空值条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    Returns:
    
    当前 C 实例
  - orIsNull
```
C orIsNull(ColumFunction columFunction,
           Object value)
```
  - orIsNull
```
default C orIsNull(boolean isEffective,
                   ColumFunction columFunction,
                   Object value)
```
  - andIsNotNull
```
<T,F> C andIsNotNull(Fn<T,F> fn)
```
    添加字段非空值条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    Returns:
    
    当前 C 实例
  - andIsNotNull
```
default <T,F> C andIsNotNull(boolean isEffective,
                             Fn<T,F> fn)
```
    根据条件添加字段非空值条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    Returns:
    
    当前 C 实例
  - andIsNotNull
```
C andIsNotNull(ColumFunction columFunction,
               Object value)
```
  - andIsNotNull
```
default C andIsNotNull(boolean isEffective,
                       ColumFunction columFunction,
                       Object value)
```
  - orIsNotNull
```
<T,F> C orIsNotNull(Fn<T,F> fn)
```
    添加字段非空值条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    Returns:
    
    当前 C 实例
  - orIsNotNull
```
default <T,F> C orIsNotNull(boolean isEffective,
                            Fn<T,F> fn)
```
    根据条件添加字段非空值条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    Returns:
    
    当前 C 实例
  - orIsNotNull
```
C orIsNotNull(ColumFunction columFunction,
              Object value)
```
  - orIsNotNull
```
default C orIsNotNull(boolean isEffective,
                      ColumFunction columFunction,
                      Object value)
```
  - andGreaterThan
```
<T,F> C andGreaterThan(Fn<T,F> fn,
                       Object value)
```
    添加字段大于指定值条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andGreaterThan
```
default <T,F> C andGreaterThan(boolean isEffective,
                               Fn<T,F> fn,
                               Object value)
```
    根据条件添加字段大于指定值条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andGreaterThan
```
<T1,T2,F> C andGreaterThan(Fn<T1,F> field1,
                           Fn<T2,F> field2)
```
    添加字段大于连接条件，并且运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - andGreaterThan
```
default <T1,T2,F> C andGreaterThan(boolean isEffective,
                                   Fn<T1,F> field1,
                                   Fn<T2,F> field2)
```
    根据条件添加字段大于连接条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - andGreaterThan
```
C andGreaterThan(ColumFunction columFunction,
                 Object value)
```
  - andGreaterThan
```
default C andGreaterThan(boolean isEffective,
                         ColumFunction columFunction,
                         Object value)
```
  - orGreaterThan
```
<T,F> C orGreaterThan(Fn<T,F> fn,
                      Object value)
```
    添加字段大于指定值条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orGreaterThan
```
default <T,F> C orGreaterThan(boolean isEffective,
                              Fn<T,F> fn,
                              Object value)
```
    根据条件添加字段大于指定值条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orGreaterThan
```
<T1,T2,F> C orGreaterThan(Fn<T1,F> field1,
                          Fn<T2,F> field2)
```
    添加字段大于连接条件，或运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orGreaterThan
```
default <T1,T2,F> C orGreaterThan(boolean isEffective,
                                  Fn<T1,F> field1,
                                  Fn<T2,F> field2)
```
    根据条件添加字段大于连接条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orGreaterThan
```
C orGreaterThan(ColumFunction columFunction,
                Object value)
```
  - orGreaterThan
```
default C orGreaterThan(boolean isEffective,
                        ColumFunction columFunction,
                        Object value)
```
  - andGreaterThanOrEqualTo
```
<T,F> C andGreaterThanOrEqualTo(Fn<T,F> fn,
                                Object value)
```
    添加字段大于或等于指定值条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andGreaterThanOrEqualTo
```
default <T,F> C andGreaterThanOrEqualTo(boolean isEffective,
                                        Fn<T,F> fn,
                                        Object value)
```
    根据条件添加字段大于或等于指定值条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andGreaterThanOrEqualTo
```
<T1,T2,F> C andGreaterThanOrEqualTo(Fn<T1,F> field1,
                                    Fn<T2,F> field2)
```
    添加字段大于或等于连接条件，并且运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - andGreaterThanOrEqualTo
```
default <T1,T2,F> C andGreaterThanOrEqualTo(boolean isEffective,
                                            Fn<T1,F> field1,
                                            Fn<T2,F> field2)
```
    根据条件添加字段大于或等于连接条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - andGreaterThanOrEqualTo
```
C andGreaterThanOrEqualTo(ColumFunction columFunction,
                          Object value)
```
  - andGreaterThanOrEqualTo
```
default C andGreaterThanOrEqualTo(boolean isEffective,
                                  ColumFunction columFunction,
                                  Object value)
```
  - orGreaterThanOrEqualTo
```
<T,F> C orGreaterThanOrEqualTo(Fn<T,F> fn,
                               Object value)
```
    添加字段大于或等于指定值条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orGreaterThanOrEqualTo
```
default <T,F> C orGreaterThanOrEqualTo(boolean isEffective,
                                       Fn<T,F> fn,
                                       Object value)
```
    根据条件添加字段大于或等于指定值条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orGreaterThanOrEqualTo
```
<T1,T2,F> C orGreaterThanOrEqualTo(Fn<T1,F> field1,
                                   Fn<T2,F> field2)
```
    添加字段大于或等于连接条件，或运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orGreaterThanOrEqualTo
```
default <T1,T2,F> C orGreaterThanOrEqualTo(boolean isEffective,
                                           Fn<T1,F> field1,
                                           Fn<T2,F> field2)
```
    根据条件添加字段大于或等于连接条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orGreaterThanOrEqualTo
```
C orGreaterThanOrEqualTo(ColumFunction columFunction,
                         Object value)
```
  - orGreaterThanOrEqualTo
```
default C orGreaterThanOrEqualTo(boolean isEffective,
                                 ColumFunction columFunction,
                                 Object value)
```
  - andLessThan
```
<T,F> C andLessThan(Fn<T,F> fn,
                    Object value)
```
    添加字段小于指定值条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andLessThan
```
default <T,F> C andLessThan(boolean isEffective,
                            Fn<T,F> fn,
                            Object value)
```
    根据条件添加字段小于指定值条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andLessThan
```
<T1,T2,F> C andLessThan(Fn<T1,F> field1,
                        Fn<T2,F> field2)
```
    添加字段小于连接条件，并且运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - andLessThan
```
default <T1,T2,F> C andLessThan(boolean isEffective,
                                Fn<T1,F> field1,
                                Fn<T2,F> field2)
```
    根据条件添加字段小于连接条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - andLessThan
```
C andLessThan(ColumFunction columFunction,
              Object value)
```
  - andLessThan
```
default C andLessThan(boolean isEffective,
                      ColumFunction columFunction,
                      Object value)
```
  - orLessThan
```
<T,F> C orLessThan(Fn<T,F> fn,
                   Object value)
```
    添加字段小于指定值条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orLessThan
```
default <T,F> C orLessThan(boolean isEffective,
                           Fn<T,F> fn,
                           Object value)
```
    根据条件添加字段小于指定值条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orLessThan
```
<T1,T2,F> C orLessThan(Fn<T1,F> field1,
                       Fn<T2,F> field2)
```
    添加字段小于连接条件，或运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orLessThan
```
default <T1,T2,F> C orLessThan(boolean isEffective,
                               Fn<T1,F> field1,
                               Fn<T2,F> field2)
```
    根据条件添加字段小于连接条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orLessThan
```
C orLessThan(ColumFunction columFunction,
             Object value)
```
  - orLessThan
```
default C orLessThan(boolean isEffective,
                     ColumFunction columFunction,
                     Object value)
```
  - andLessThanOrEqualTo
```
<T,F> C andLessThanOrEqualTo(Fn<T,F> fn,
                             Object value)
```
    添加字段小于或等于指定值条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andLessThanOrEqualTo
```
default <T,F> C andLessThanOrEqualTo(boolean isEffective,
                                     Fn<T,F> fn,
                                     Object value)
```
    根据条件添加字段小于或等于指定值条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - andLessThanOrEqualTo
```
<T1,T2,F> C andLessThanOrEqualTo(Fn<T1,F> field1,
                                 Fn<T2,F> field2)
```
    添加字段小于或等于连接条件，并且运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - andLessThanOrEqualTo
```
default <T1,T2,F> C andLessThanOrEqualTo(boolean isEffective,
                                         Fn<T1,F> field1,
                                         Fn<T2,F> field2)
```
    根据条件添加字段小于或等于连接条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - andLessThanOrEqualTo
```
C andLessThanOrEqualTo(ColumFunction columFunction,
                       Object value)
```
  - andLessThanOrEqualTo
```
default C andLessThanOrEqualTo(boolean isEffective,
                               ColumFunction columFunction,
                               Object value)
```
  - orLessThanOrEqualTo
```
<T,F> C orLessThanOrEqualTo(Fn<T,F> fn,
                            Object value)
```
    添加字段小于或等于指定值条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orLessThanOrEqualTo
```
default <T,F> C orLessThanOrEqualTo(boolean isEffective,
                                    Fn<T,F> fn,
                                    Object value)
```
    根据条件添加字段小于或等于指定值条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    value - 匹配的值
    
    Returns:
    
    当前 C 实例
  - orLessThanOrEqualTo
```
<T1,T2,F> C orLessThanOrEqualTo(Fn<T1,F> field1,
                                Fn<T2,F> field2)
```
    添加字段小于或等于连接条件，或运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orLessThanOrEqualTo
```
default <T1,T2,F> C orLessThanOrEqualTo(boolean isEffective,
                                        Fn<T1,F> field1,
                                        Fn<T2,F> field2)
```
    根据条件添加字段小于或等于连接条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取第一个字段值的函数
    
    field2 - 用于获取第二个字段值的函数
    
    Returns:
    
    当前 Condition 实例
  - orLessThanOrEqualTo
```
C orLessThanOrEqualTo(ColumFunction columFunction,
                      Object value)
```
  - orLessThanOrEqualTo
```
default C orLessThanOrEqualTo(boolean isEffective,
                              ColumFunction columFunction,
                              Object value)
```
  - andIn
```
<T,F> C andIn(Fn<T,F> fn,
              Iterable<?> values)
```
    添加字段在指定值集合中条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    values - 匹配的值集合
    
    Returns:
    
    当前 C 实例
  - andIn
```
default <T,F> C andIn(boolean isEffective,
                      Fn<T,F> fn,
                      Iterable<?> values)
```
    根据条件添加字段在指定值集合中条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    values - 匹配的值集合
    
    Returns:
    
    当前 C 实例
  - andIn
```
C andIn(Column column,
        Iterable<?> values)
```
  - andIn
```
default C andIn(boolean isEffective,
                Column column,
                Iterable<?> values)
```
  - andIn
```
C andIn(ColumFunction columFunction,
        Iterable<?> values)
```
  - andIn
```
default C andIn(boolean isEffective,
                ColumFunction columFunction,
                Iterable<?> values)
```
  - orIn
```
<T,F> C orIn(Fn<T,F> fn,
             Iterable<?> values)
```
    添加字段在指定值集合中条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    values - 匹配的值集合
    
    Returns:
    
    当前 C 实例
  - orIn
```
default <T,F> C orIn(boolean isEffective,
                     Fn<T,F> fn,
                     Iterable<?> values)
```
    根据条件添加字段在指定值集合中条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    values - 匹配的值集合
    
    Returns:
    
    当前 C 实例
  - orIn
```
C orIn(ColumFunction columFunction,
       Iterable<?> values)
```
  - orIn
```
default C orIn(boolean isEffective,
               ColumFunction columFunction,
               Iterable<?> values)
```
  - andNotIn
```
<T,F> C andNotIn(Fn<T,F> fn,
                 Iterable<?> values)
```
    添加字段不在指定值集合中条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    values - 匹配的值集合
    
    Returns:
    
    当前 C 实例
  - andNotIn
```
default <T,F> C andNotIn(boolean isEffective,
                         Fn<T,F> fn,
                         Iterable<?> values)
```
    根据条件添加字段不在指定值集合中条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    values - 匹配的值集合
    
    Returns:
    
    当前 C 实例
  - andNotIn
```
C andNotIn(ColumFunction columFunction,
           Iterable<?> values)
```
  - andNotIn
```
default C andNotIn(boolean isEffective,
                   ColumFunction columFunction,
                   Iterable<?> values)
```
  - orNotIn
```
<T,F> C orNotIn(Fn<T,F> fn,
                Iterable<?> values)
```
    添加字段不在指定值集合中条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    values - 匹配的值集合
    
    Returns:
    
    当前 C 实例
  - orNotIn
```
default <T,F> C orNotIn(boolean isEffective,
                        Fn<T,F> fn,
                        Iterable<?> values)
```
    根据条件添加字段不在指定值集合中条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    values - 匹配的值集合
    
    Returns:
    
    当前 C 实例
  - orNotIn
```
C orNotIn(ColumFunction columFunction,
          Iterable<?> values)
```
  - orNotIn
```
default C orNotIn(boolean isEffective,
                  ColumFunction columFunction,
                  Iterable<?> values)
```
  - andBetween
```
<T,F> C andBetween(Fn<T,F> fn,
                   Object start,
                   Object end)
```
    添加字段在指定范围内条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    start - 范围起始值
    
    end - 范围结束值
    
    Returns:
    
    当前 C 实例
  - andBetween
```
default <T,F> C andBetween(boolean isEffective,
                           Fn<T,F> fn,
                           Object start,
                           Object end)
```
    根据条件添加字段在指定范围内条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    start - 范围起始值
    
    end - 范围结束值
    
    Returns:
    
    当前 C 实例
  - andBetween
```
<T1,T2,F> C 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
 
```
    Type Parameters:
    
    T1 - 实体类类型1，表示第一个表的实体类
    
    T2 - 实体类类型2，表示第二个表的实体类
    
    F - 字段类型，表示字段的数据类型
    
    Parameters:
    
    field1 - 用于获取字段值的函数，表示要进行 BETWEEN 比较的字段
    
    startField - 用于获取起始值的函数，表示范围的起始值
    
    endField - 用于获取结束值的函数，表示范围的结束值
    
    Returns:
    
    当前 Condition 实例，以便实现链式调用
  - andBetween
```
default <T1,T2,F> C andBetween(boolean isEffective,
                               Fn<T1,F> field1,
                               Fn<T2,F> startField,
                               Fn<T2,F> endField)
```
    根据条件添加字段 BETWEEN 连接条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取字段值的函数
    
    startField - 用于获取起始值的函数
    
    endField - 用于获取结束值的函数
    
    Returns:
    
    当前 Condition 实例
  - orBetween
```
<T,F> C orBetween(Fn<T,F> fn,
                  Object start,
                  Object end)
```
    添加字段在指定范围内条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    start - 范围起始值
    
    end - 范围结束值
    
    Returns:
    
    当前 C 实例
  - orBetween
```
default <T,F> C orBetween(boolean isEffective,
                          Fn<T,F> fn,
                          Object start,
                          Object end)
```
    根据条件添加字段在指定范围内条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    start - 范围起始值
    
    end - 范围结束值
    
    Returns:
    
    当前 C 实例
  - orBetween
```
<T1,T2,F> C orBetween(Fn<T1,F> field1,
                      Fn<T2,F> startField,
                      Fn<T2,F> endField)
```
    添加字段 BETWEEN 连接条件，或运算。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    field1 - 用于获取字段值的函数
    
    startField - 用于获取起始值的函数
    
    endField - 用于获取结束值的函数
    
    Returns:
    
    当前 Condition 实例
    
    See Also:
    
    andBetween(Fn, Fn, Fn)
  - orBetween
```
default <T1,T2,F> C orBetween(boolean isEffective,
                              Fn<T1,F> field1,
                              Fn<T2,F> startField,
                              Fn<T2,F> endField)
```
    根据条件添加字段 BETWEEN 连接条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T1 - 实体类类型1
    
    T2 - 实体类类型2
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    field1 - 用于获取字段值的函数
    
    startField - 用于获取起始值的函数
    
    endField - 用于获取结束值的函数
    
    Returns:
    
    当前 Condition 实例
  - andNotBetween
```
<T,F> C andNotBetween(Fn<T,F> fn,
                      Object start,
                      Object end)
```
    添加字段不在指定范围内条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    start - 范围起始值
    
    end - 范围结束值
    
    Returns:
    
    当前 C 实例
  - andNotBetween
```
default <T,F> C andNotBetween(boolean isEffective,
                              Fn<T,F> fn,
                              Object start,
                              Object end)
```
    根据条件添加字段不在指定范围内条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    start - 范围起始值
    
    end - 范围结束值
    
    Returns:
    
    当前 C 实例
  - orNotBetween
```
<T,F> C orNotBetween(Fn<T,F> fn,
                     Object start,
                     Object end)
```
    添加字段不在指定范围内条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    start - 范围起始值
    
    end - 范围结束值
    
    Returns:
    
    当前 C 实例
  - orNotBetween
```
default <T,F> C orNotBetween(boolean isEffective,
                             Fn<T,F> fn,
                             Object start,
                             Object end)
```
    根据条件添加字段不在指定范围内条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    start - 范围起始值
    
    end - 范围结束值
    
    Returns:
    
    当前 C 实例
  - andLike
```
<T,F> C andLike(Fn<T,F> fn,
                String pattern)
```
    添加字段匹配指定模式条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    pattern - 匹配的模式（如 SQL 的 LIKE 子句）
    
    Returns:
    
    当前 C 实例
  - andLike
```
default <T,F> C andLike(boolean isEffective,
                        Fn<T,F> fn,
                        String pattern)
```
    根据条件添加字段匹配指定模式条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    pattern - 匹配的模式（如 SQL 的 LIKE 子句）
    
    Returns:
    
    当前 C 实例
  - orLike
```
<T,F> C orLike(Fn<T,F> fn,
               String pattern)
```
    添加字段匹配指定模式条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    pattern - 匹配的模式（如 SQL 的 LIKE 子句）
    
    Returns:
    
    当前 C 实例
  - orLike
```
default <T,F> C orLike(boolean isEffective,
                       Fn<T,F> fn,
                       String pattern)
```
    根据条件添加字段匹配指定模式条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    pattern - 匹配的模式（如 SQL 的 LIKE 子句）
    
    Returns:
    
    当前 C 实例
  - andNotLike
```
<T,F> C andNotLike(Fn<T,F> fn,
                   String pattern)
```
    添加字段不匹配指定模式条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    pattern - 匹配的模式（如 SQL 的 LIKE 子句）
    
    Returns:
    
    当前 C 实例
  - andNotLike
```
default <T,F> C andNotLike(boolean isEffective,
                           Fn<T,F> fn,
                           String pattern)
```
    根据条件添加字段不匹配指定模式条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    pattern - 匹配的模式（如 SQL 的 LIKE 子句）
    
    Returns:
    
    当前 C 实例
  - orNotLike
```
<T,F> C orNotLike(Fn<T,F> fn,
                  String pattern)
```
    添加字段不匹配指定模式条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    pattern - 匹配的模式（如 SQL 的 LIKE 子句）
    
    Returns:
    
    当前 C 实例
  - orNotLike
```
default <T,F> C orNotLike(boolean isEffective,
                          Fn<T,F> fn,
                          String pattern)
```
    根据条件添加字段不匹配指定模式条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    pattern - 匹配的模式（如 SQL 的 LIKE 子句）
    
    Returns:
    
    当前 C 实例
  - andMatches
```
<T,F> C andMatches(Fn<T,F> fn,
                   String regex)
```
    添加字段匹配正则表达式条件，并且运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    regex - 正则表达式模式
    
    Returns:
    
    当前 C 实例
  - andMatches
```
default <T,F> C andMatches(boolean isEffective,
                           Fn<T,F> fn,
                           String regex)
```
    根据条件添加字段匹配正则表达式条件，并且运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    regex - 正则表达式模式
    
    Returns:
    
    当前 C 实例
  - orMatches
```
<T,F> C orMatches(Fn<T,F> fn,
                  String regex)
```
    添加字段匹配正则表达式条件，或运算。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    regex - 正则表达式模式
    
    Returns:
    
    当前 C 实例
  - orMatches
```
default <T,F> C orMatches(boolean isEffective,
                          Fn<T,F> fn,
                          String regex)
```
    根据条件添加字段匹配正则表达式条件，或运算。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    regex - 正则表达式模式
    
    Returns:
    
    当前 C 实例
  - andFindInSet
```
<T,F> C andFindInSet(Fn<T,F> fn,
                     Object item)
```
    添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数）。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    item - 指定的项目
    
    Returns:
    
    当前 C 实例
  - andFindInSet
```
default <T,F> C andFindInSet(boolean isEffective,
                             Fn<T,F> fn,
                             Object item)
```
    根据条件添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数）。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    item - 指定的项目
    
    Returns:
    
    当前 C 实例
  - andFindInSet
```
<T,F> C andFindInSet(Fn<T,F> fn,
                     Object item,
                     String separator)
```
    添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数），并指定分隔符。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    item - 指定的项目
    
    separator - 分隔符
    
    Returns:
    
    当前 C 实例
  - andFindInSet
```
default <T,F> C andFindInSet(boolean isEffective,
                             Fn<T,F> fn,
                             Object item,
                             String separator)
```
    根据条件添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数），并指定分隔符。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    item - 指定的项目
    
    separator - 分隔符
    
    Returns:
    
    当前 C 实例
  - orFindInSet
```
<T,F> C orFindInSet(Fn<T,F> fn,
                    Object item)
```
    添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数）。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    item - 指定的项目
    
    Returns:
    
    当前 C 实例
  - orFindInSet
```
default <T,F> C orFindInSet(boolean isEffective,
                            Fn<T,F> fn,
                            Object item)
```
    根据条件添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数）。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    item - 指定的项目
    
    Returns:
    
    当前 C 实例
  - orFindInSet
```
<T,F> C orFindInSet(Fn<T,F> fn,
                    Object item,
                    String separator)
```
    添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数），并指定分隔符。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    fn - 用于获取字段值的函数
    
    item - 指定的项目
    
    separator - 分隔符
    
    Returns:
    
    当前 C 实例
  - orFindInSet
```
default <T,F> C orFindInSet(boolean isEffective,
                            Fn<T,F> fn,
                            Object item,
                            String separator)
```
    根据条件添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数），并指定分隔符。
    仅当 isEffective 为 true 时追加条件。
    
    Type Parameters:
    
    T - 实体类类型
    
    F - 字段类型
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    fn - 用于获取字段值的函数
    
    item - 指定的项目
    
    separator - 分隔符
    
    Returns:
    
    当前 C 实例
  - limit
```
C limit(int offset,
        int limit)
```
    限制查询结果的返回行数。
    
    Parameters:
    
    offset - 需要跳过的行数
    
    limit - 返回的最大行数
    
    Returns:
    
    当前 C 实例
  - limit
```
default C limit(boolean isEffective,
                int offset,
                int limit)
```
    根据条件限制查询结果的返回行数。
    仅当 isEffective 为 true 时应用限制。
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    offset - 需要跳过的行数
    
    limit - 返回的最大行数
    
    Returns:
    
    当前 C 实例
  - limit
```
C limit(int limit)
```
    限制查询结果的返回行数。
    
    Parameters:
    
    limit - 返回的最大行数
    
    Returns:
    
    当前 C 实例
  - limit
```
default C limit(boolean isEffective,
                int limit)
```
    根据条件限制查询结果的返回行数。
    仅当 isEffective 为 true 时应用限制。
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    limit - 返回的最大行数
    
    Returns:
    
    当前 C 实例
  - andCondition
```
default C andCondition(Consumer<GenericWhereCondition> nestedCondition)
```
    添加一组条件，并且运算。
    该方法允许将一组条件作为当前条件的子条件进行添加，并且将它们合并为一个结果。其中传入的 Consumer 对象接受一个 Condition 实例，用于设置嵌套的条件组合。
    例如：
```
     condition.andCondition(nestedCondition -> {
         nestedCondition.andEqualTo(SomeClass::getA, 1);
         nestedCondition.orCondition(innerCondition -> {
             innerCondition.andEqualTo(SomeClass::getB, 2);
             innerCondition.orEqualTo(SomeClass::getC, 2);
         });
     });
 
```
    Parameters:
    
    nestedCondition - 用于配置嵌套条件的 Consumer 对象
    
    Returns:
    
    当前的 Condition 实例，以便实现链式调用
  - andCondition
```
default C andCondition(boolean isEffective,
                       Consumer<GenericWhereCondition> nestedCondition)
```
    根据条件添加一组条件，并且运算。
    仅当 isEffective 为 true 时应用嵌套条件。
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    nestedCondition - 用于配置嵌套条件的 Consumer 对象
    
    Returns:
    
    当前的 GenericWhereCondition 实例
  - orCondition
```
default C orCondition(Consumer<GenericWhereCondition> nestedCondition)
```
    添加一个嵌套条件，或运算。
    
    Parameters:
    
    nestedCondition - 用于配置嵌套条件的 Consumer 对象
    
    Returns:
    
    当前的 GenericWhereCondition 实例，以便实现链式调用
    
    See Also:
    
    andCondition(Consumer)
  - orCondition
```
default C orCondition(boolean isEffective,
                      Consumer<GenericWhereCondition> nestedCondition)
```
    根据条件添加一个嵌套条件，或运算。
    仅当 isEffective 为 true 时应用嵌套条件。
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    nestedCondition - 用于配置嵌套条件的 Consumer 对象
    
    Returns:
    
    当前的 Condition 实例
  - andFunction
```
C 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());
     
 
```
    Parameters:
    
    columFunction - 要与当前条件通过 AND 连接的列函数条件，不能为空。该参数通常表示对数据库列的某种操作或计算（例如 SUM、AVG 等）。
    
    Returns:
    
    当前的 Condition 实例，以便实现链式调用
  - andFunction
```
default C andFunction(boolean isEffective,
                      ColumFunction columFunction)
```
    根据条件使用 AND 逻辑连接一个列函数条件。
    仅当 isEffective 为 true 时追加条件。
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    columFunction - 要与当前条件通过 AND 连接的列函数条件
    
    Returns:
    
    当前的 Condition 实例
  - orFunction
```
C orFunction(ColumFunction columFunction)
```
    使用 OR 逻辑连接一个列函数条件。
    该方法将指定的列函数条件与当前条件通过 OR 逻辑运算符连接，形成一个新的复合条件。适用于需要多个条件中至少一个满足的查询场景。
    
    Parameters:
    
    columFunction - 要与当前条件通过 OR 连接的列函数条件，不能为空。该参数通常表示对数据库列的某种操作或计算（例如 MAX、MIN 等）。
    
    Returns:
    
    当前的 Condition 实例，以便实现链式调用
  - orFunction
```
default C orFunction(boolean isEffective,
                     ColumFunction columFunction)
```
    根据条件使用 OR 逻辑连接一个列函数条件。
    仅当 isEffective 为 true 时追加条件。
    
    Parameters:
    
    isEffective - 是否使条件生效
    
    columFunction - 要与当前条件通过 OR 连接的列函数条件，不能为空。该参数通常表示对数据库列的某种操作或计算（例如 MAX、MIN 等）。
    
    Returns:
    
    当前的 Condition 实例，以便实现链式调用
  - self
```
default C self()
```
    返回当前对象自身，作为其泛型类型 C 的实例。
    该方法通常用于泛型接口或抽象类中的链式调用，在自引用泛型（self-referencing generics）模式下，可以避免子类在每次方法调用后手动进行类型转换。
```
 public interface Condition<C extends Condition<C>> {
     default C andEqualTo(...) {
         // 逻辑
         return self();
     }
 }
 
```
    Returns:
    
    当前对象，作为泛型类型 C

Interface Condition<C extends Condition<C>>

Method Summary

Method Detail

andEqualTo

andEqualTo

andEqualTo

andEqualTo

andEqualTo

andEqualTo

andEqualTo

andEqualTo

orEqualTo

orEqualTo

orEqualTo

orEqualTo

orEqualTo

orEqualTo

andNotEqualTo

andNotEqualTo

andNotEqualTo

andNotEqualTo

andNotEqualTo

andNotEqualTo

orNotEqualTo

orNotEqualTo

orNotEqualTo

orNotEqualTo

orNotEqualTo

orNotEqualTo

andIsNull

andIsNull

andIsNull

andIsNull

orIsNull

orIsNull

orIsNull

orIsNull

andIsNotNull

andIsNotNull

andIsNotNull

andIsNotNull

orIsNotNull

orIsNotNull

orIsNotNull

orIsNotNull

andGreaterThan

andGreaterThan

andGreaterThan

andGreaterThan

andGreaterThan

andGreaterThan

orGreaterThan

orGreaterThan

orGreaterThan

orGreaterThan

orGreaterThan

orGreaterThan

andGreaterThanOrEqualTo

andGreaterThanOrEqualTo

andGreaterThanOrEqualTo

andGreaterThanOrEqualTo

andGreaterThanOrEqualTo

andGreaterThanOrEqualTo

orGreaterThanOrEqualTo

orGreaterThanOrEqualTo

orGreaterThanOrEqualTo

orGreaterThanOrEqualTo

orGreaterThanOrEqualTo

orGreaterThanOrEqualTo

andLessThan

andLessThan

andLessThan

andLessThan

andLessThan

andLessThan

orLessThan

orLessThan

orLessThan

orLessThan

orLessThan