com.dynamic.sql.core.condition

接口 Condition<C extends Condition<C>>

所有已知子接口:

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

所有已知实现类:

GenericWhereCondition, MysqlWhereCondition, OracleWhereCondition, WhereCondition

public interface Condition<C extends Condition<C>>

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

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

方法概要

限定符和类型	方法和说明
default C	andBetween(boolean isEffective, Column column, Object start, Object end)
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) 根据条件添加字段在指定范围内条件，并且运算。
C	andBetween(Column column, 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, Column column2) 根据条件追加列间等于运算。
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, Column column2) 追加列间等于运算。
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 C	andFindInSet(boolean isEffective, Column column, 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 函数），并指定分隔符。
C	andFindInSet(Column column, Object value)
<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 C	andGreaterThan(boolean isEffective, Column column, Column column2)
default C	andGreaterThan(boolean isEffective, Column column, 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)
C	andGreaterThan(Column column, Column column2)
C	andGreaterThan(Column column, 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 C	andGreaterThanOrEqualTo(boolean isEffective, Column column, Column column2)
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)
C	andGreaterThanOrEqualTo(Column column, Column column2)
<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 C	andIsNotNull(boolean isEffective, Column column)
default <T,F> C	andIsNotNull(boolean isEffective, Fn<T,F> fn) 根据条件添加字段非空值条件，并且运算。
C	andIsNotNull(ColumFunction columFunction, Object value)
C	andIsNotNull(Column column)
<T,F> C	andIsNotNull(Fn<T,F> fn) 添加字段非空值条件，并且运算。
default C	andIsNull(boolean isEffective, ColumFunction columFunction, Object value)
default C	andIsNull(boolean isEffective, Column column)
default <T,F> C	andIsNull(boolean isEffective, Fn<T,F> fn) 根据条件添加字段为空值条件，并且运算。
C	andIsNull(ColumFunction columFunction, Object value)
C	andIsNull(Column column)
<T,F> C	andIsNull(Fn<T,F> fn) 添加字段为空值条件，并且运算。
default C	andLessThan(boolean isEffective, ColumFunction columFunction, Object value)
default C	andLessThan(boolean isEffective, Column column, Column column2)
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)
C	andLessThan(Column column, Column column2)
<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 C	andLessThanOrEqualTo(boolean isEffective, Column column, Column column2)
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)
C	andLessThanOrEqualTo(Column column, Column column2)
<T1,T2,F> C	andLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于或等于连接条件，并且运算。
<T,F> C	andLessThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段小于或等于指定值条件，并且运算。
default C	andLike(boolean isEffective, Column column, Object value)
default <T,F> C	andLike(boolean isEffective, Fn<T,F> fn, String pattern) 根据条件添加字段匹配指定模式条件，并且运算。
C	andLike(Column column, Object value)
<T,F> C	andLike(Fn<T,F> fn, String pattern) 添加字段匹配指定模式条件，并且运算。
default C	andMatches(boolean isEffective, Column column, String regex)
default <T,F> C	andMatches(boolean isEffective, Fn<T,F> fn, String regex) 根据条件添加字段匹配正则表达式条件，并且运算。
C	andMatches(Column column, String regex)
<T,F> C	andMatches(Fn<T,F> fn, String regex) 添加字段匹配正则表达式条件，并且运算。
default C	andNotBetween(boolean isEffective, Column column, Object start, Object end)
default <T,F> C	andNotBetween(boolean isEffective, Fn<T,F> fn, Object start, Object end) 根据条件添加字段不在指定范围内条件，并且运算。
C	andNotBetween(Column column, 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 C	andNotEqualTo(boolean isEffective, Column column, Column column2)
default C	andNotEqualTo(boolean isEffective, Column column, 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)
C	andNotEqualTo(Column column, Column column2)
C	andNotEqualTo(Column column, 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 C	andNotLike(boolean isEffective, Column column, Object value)
default <T,F> C	andNotLike(boolean isEffective, Fn<T,F> fn, String pattern) 根据条件添加字段不匹配指定模式条件，并且运算。
C	andNotLike(Column column, Object value)
<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 C	orBetween(boolean isEffective, Column column, Object start, Object end)
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) 根据条件添加字段在指定范围内条件，或运算。
C	orBetween(Column column, 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 C	orEqualTo(boolean isEffective, Column column, Column column2)
default C	orEqualTo(boolean isEffective, Column column, 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)
C	orEqualTo(Column column, Column column2)
C	orEqualTo(Column column, 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 C	orFindInSet(boolean isEffective, Column column, 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 函数），并指定分隔符。
C	orFindInSet(Column column, Object value)
<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 C	orGreaterThan(boolean isEffective, Column column, Column column2)
default C	orGreaterThan(boolean isEffective, Column column, 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)
C	orGreaterThan(Column column, Column column2)
C	orGreaterThan(Column column, 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 C	orGreaterThanOrEqualTo(boolean isEffective, Column column, Column column2)
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)
C	orGreaterThanOrEqualTo(Column column, Column column2)
<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 C	orIsNotNull(boolean isEffective, Column column)
default <T,F> C	orIsNotNull(boolean isEffective, Fn<T,F> fn) 根据条件添加字段非空值条件，或运算。
C	orIsNotNull(ColumFunction columFunction, Object value)
C	orIsNotNull(Column column)
<T,F> C	orIsNotNull(Fn<T,F> fn) 添加字段非空值条件，或运算。
default C	orIsNull(boolean isEffective, ColumFunction columFunction, Object value)
default C	orIsNull(boolean isEffective, Column column)
default <T,F> C	orIsNull(boolean isEffective, Fn<T,F> fn) 根据条件添加字段为空值条件，或运算。
C	orIsNull(ColumFunction columFunction, Object value)
C	orIsNull(Column column)
<T,F> C	orIsNull(Fn<T,F> fn) 添加字段为空值条件，或运算。
default C	orLessThan(boolean isEffective, ColumFunction columFunction, Object value)
default C	orLessThan(boolean isEffective, Column column, Column column2)
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)
C	orLessThan(Column column, Column column2)
<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 C	orLessThanOrEqualTo(boolean isEffective, Column column, Column column2)
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)
C	orLessThanOrEqualTo(Column column, Column column2)
<T1,T2,F> C	orLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于或等于连接条件，或运算。
<T,F> C	orLessThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段小于或等于指定值条件，或运算。
default C	orLike(boolean isEffective, Column column, Object value)
default <T,F> C	orLike(boolean isEffective, Fn<T,F> fn, String pattern) 根据条件添加字段匹配指定模式条件，或运算。
C	orLike(Column column, Object value)
<T,F> C	orLike(Fn<T,F> fn, String pattern) 添加字段匹配指定模式条件，或运算。
default C	orMatches(boolean isEffective, Column column, String regex)
default <T,F> C	orMatches(boolean isEffective, Fn<T,F> fn, String regex) 根据条件添加字段匹配正则表达式条件，或运算。
C	orMatches(Column column, String regex)
<T,F> C	orMatches(Fn<T,F> fn, String regex) 添加字段匹配正则表达式条件，或运算。
default C	orNotBetween(boolean isEffective, Column column, Object start, Object end)
default <T,F> C	orNotBetween(boolean isEffective, Fn<T,F> fn, Object start, Object end) 根据条件添加字段不在指定范围内条件，或运算。
C	orNotBetween(Column column, 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 C	orNotEqualTo(boolean isEffective, Column column, Column column2)
default C	orNotEqualTo(boolean isEffective, Column column, 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)
C	orNotEqualTo(Column column, Column column2)
C	orNotEqualTo(Column column, 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 C	orNotLike(boolean isEffective, Column column, Object value)
default <T,F> C	orNotLike(boolean isEffective, Fn<T,F> fn, String pattern) 根据条件添加字段不匹配指定模式条件，或运算。
C	orNotLike(Column column, Object value)
<T,F> C	orNotLike(Fn<T,F> fn, String pattern) 添加字段不匹配指定模式条件，或运算。
default C	self() 返回当前对象自身，作为其泛型类型 C 的实例。

方法详细资料

andEqualTo

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

andEqualTo

C andEqualTo(Column column,
             Object value)

追加等于运算。

参数:

column - 列对象

value - 匹配的值

返回:

当前 C 实例

andEqualTo

default C andEqualTo(boolean isEffective,
                     Column column,
                     Object value)

根据条件追加等于运算。

参数:

isEffective - 是否使条件生效；为 true 时追加条件，否则忽略

column - 列对象

value - 匹配的值

返回:

当前 C 实例

andEqualTo

C andEqualTo(Column column,
             Column column2)

追加列间等于运算。

参数:

column - 左侧列对象

column2 - 右侧列对象

返回:

当前 C 实例

andEqualTo

default C andEqualTo(boolean isEffective,
                     Column column,
                     Column column2)

根据条件追加列间等于运算。

参数:

isEffective - 是否使条件生效；为 true 时追加条件，否则忽略

column - 左侧列对象

column2 - 右侧列对象

返回:

当前 C 实例

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" 条件。

类型参数:

T1 - 第一个实体类类型

T2 - 第二个实体类类型

F - 字段类型

参数:

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

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

返回:

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

andEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 第一个实体类类型

T2 - 第二个实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前的 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)

添加等于条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

orEqualTo

C orEqualTo(Column column,
            Object value)

orEqualTo

default C orEqualTo(boolean isEffective,
                    Column column,
                    Object value)

orEqualTo

C orEqualTo(Column column,
            Column column2)

orEqualTo

default C orEqualTo(boolean isEffective,
                    Column column,
                    Column column2)

orEqualTo

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

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andNotEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

andNotEqualTo

C andNotEqualTo(Column column,
                Object value)

andNotEqualTo

default C andNotEqualTo(boolean isEffective,
                        Column column,
                        Object value)

andNotEqualTo

C andNotEqualTo(Column column,
                Column column2)

andNotEqualTo

default C andNotEqualTo(boolean isEffective,
                        Column column,
                        Column column2)

andNotEqualTo

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

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andNotEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orNotEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

orNotEqualTo

C orNotEqualTo(Column column,
               Object value)

orNotEqualTo

default C orNotEqualTo(boolean isEffective,
                       Column column,
                       Object value)

orNotEqualTo

C orNotEqualTo(Column column,
               Column column2)

orNotEqualTo

default C orNotEqualTo(boolean isEffective,
                       Column column,
                       Column column2)

orNotEqualTo

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

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orNotEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 C 实例

andIsNull

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

返回:

当前 C 实例

andIsNull

C andIsNull(Column column)

andIsNull

default C andIsNull(boolean isEffective,
                    Column column)

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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 C 实例

orIsNull

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

返回:

当前 C 实例

orIsNull

C orIsNull(ColumFunction columFunction,
           Object value)

orIsNull

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

orIsNull

C orIsNull(Column column)

orIsNull

default C orIsNull(boolean isEffective,
                   Column column)

andIsNotNull

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 C 实例

andIsNotNull

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

返回:

当前 C 实例

andIsNotNull

C andIsNotNull(ColumFunction columFunction,
               Object value)

andIsNotNull

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

andIsNotNull

C andIsNotNull(Column column)

andIsNotNull

default C andIsNotNull(boolean isEffective,
                       Column column)

orIsNotNull

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 C 实例

orIsNotNull

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

返回:

当前 C 实例

orIsNotNull

C orIsNotNull(ColumFunction columFunction,
              Object value)

orIsNotNull

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

orIsNotNull

C orIsNotNull(Column column)

orIsNotNull

default C orIsNotNull(boolean isEffective,
                      Column column)

andGreaterThan

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andGreaterThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

andGreaterThan

C andGreaterThan(Column column,
                 Object value)

andGreaterThan

default C andGreaterThan(boolean isEffective,
                         Column column,
                         Object value)

andGreaterThan

C andGreaterThan(Column column,
                 Column column2)

andGreaterThan

default C andGreaterThan(boolean isEffective,
                         Column column,
                         Column column2)

andGreaterThan

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

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andGreaterThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orGreaterThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

orGreaterThan

C orGreaterThan(Column column,
                Object value)

orGreaterThan

default C orGreaterThan(boolean isEffective,
                        Column column,
                        Object value)

orGreaterThan

C orGreaterThan(Column column,
                Column column2)

orGreaterThan

default C orGreaterThan(boolean isEffective,
                        Column column,
                        Column column2)

orGreaterThan

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

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orGreaterThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andGreaterThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

andGreaterThanOrEqualTo

C andGreaterThanOrEqualTo(Column column,
                          Column column2)

andGreaterThanOrEqualTo

default C andGreaterThanOrEqualTo(boolean isEffective,
                                  Column column,
                                  Column column2)

andGreaterThanOrEqualTo

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

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andGreaterThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orGreaterThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

orGreaterThanOrEqualTo

C orGreaterThanOrEqualTo(Column column,
                         Column column2)

orGreaterThanOrEqualTo

default C orGreaterThanOrEqualTo(boolean isEffective,
                                 Column column,
                                 Column column2)

orGreaterThanOrEqualTo

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

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orGreaterThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andLessThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

andLessThan

C andLessThan(Column column,
              Column column2)

andLessThan

default C andLessThan(boolean isEffective,
                      Column column,
                      Column column2)

andLessThan

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

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andLessThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orLessThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

orLessThan

C orLessThan(Column column,
             Column column2)

orLessThan

default C orLessThan(boolean isEffective,
                     Column column,
                     Column column2)

orLessThan

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

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orLessThan

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andLessThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

andLessThanOrEqualTo

C andLessThanOrEqualTo(Column column,
                       Column column2)

andLessThanOrEqualTo

default C andLessThanOrEqualTo(boolean isEffective,
                               Column column,
                               Column column2)

andLessThanOrEqualTo

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

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andLessThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orLessThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

value - 匹配的值

返回:

当前 C 实例

orLessThanOrEqualTo

C orLessThanOrEqualTo(Column column,
                      Column column2)

orLessThanOrEqualTo

default C orLessThanOrEqualTo(boolean isEffective,
                              Column column,
                              Column column2)

orLessThanOrEqualTo

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

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orLessThanOrEqualTo

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 C 实例

andIn

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

values - 匹配的值集合

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 C 实例

orIn

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

values - 匹配的值集合

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 C 实例

andNotIn

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

values - 匹配的值集合

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 C 实例

orNotIn

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

values - 匹配的值集合

返回:

当前 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)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

andBetween

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

andBetween

C andBetween(Column column,
             Object start,
             Object end)

andBetween

default C andBetween(boolean isEffective,
                     Column column,
                     Object start,
                     Object end)

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
 

类型参数:

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

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

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

参数:

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

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

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

返回:

当前 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 时追加条件。

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

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

返回:

当前 Condition 实例

orBetween

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

orBetween

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

orBetween

C orBetween(Column column,
            Object start,
            Object end)

orBetween

default C orBetween(boolean isEffective,
                    Column column,
                    Object start,
                    Object end)

orBetween

<T1,T2,F> C 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> C 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> C andNotBetween(Fn<T,F> fn,
                      Object start,
                      Object end)

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

andNotBetween

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

andNotBetween

C andNotBetween(Column column,
                Object start,
                Object end)

andNotBetween

default C andNotBetween(boolean isEffective,
                        Column column,
                        Object start,
                        Object end)

orNotBetween

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

orNotBetween

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

orNotBetween

C orNotBetween(Column column,
               Object start,
               Object end)

orNotBetween

default C orNotBetween(boolean isEffective,
                       Column column,
                       Object start,
                       Object end)

andLike

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 C 实例

andLike

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 C 实例

andLike

C andLike(Column column,
          Object value)

andLike

default C andLike(boolean isEffective,
                  Column column,
                  Object value)

orLike

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 C 实例

orLike

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 C 实例

orLike

C orLike(Column column,
         Object value)

orLike

default C orLike(boolean isEffective,
                 Column column,
                 Object value)

andNotLike

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 C 实例

andNotLike

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 C 实例

andNotLike

C andNotLike(Column column,
             Object value)

andNotLike

default C andNotLike(boolean isEffective,
                     Column column,
                     Object value)

orNotLike

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 C 实例

orNotLike

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

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

返回:

当前 C 实例

orNotLike

C orNotLike(Column column,
            Object value)

orNotLike

default C orNotLike(boolean isEffective,
                    Column column,
                    Object value)

andMatches

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

regex - 正则表达式模式

返回:

当前 C 实例

andMatches

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

regex - 正则表达式模式

返回:

当前 C 实例

andMatches

C andMatches(Column column,
             String regex)

andMatches

default C andMatches(boolean isEffective,
                     Column column,
                     String regex)

orMatches

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

regex - 正则表达式模式

返回:

当前 C 实例

orMatches

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

regex - 正则表达式模式

返回:

当前 C 实例

orMatches

C orMatches(Column column,
            String regex)

orMatches

default C orMatches(boolean isEffective,
                    Column column,
                    String regex)

andFindInSet

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

返回:

当前 C 实例

andFindInSet

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

item - 指定的项目

返回:

当前 C 实例

andFindInSet

C andFindInSet(Column column,
               Object value)

andFindInSet

default C andFindInSet(boolean isEffective,
                       Column column,
                       Object value)

andFindInSet

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

separator - 分隔符

返回:

当前 C 实例

andFindInSet

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

item - 指定的项目

separator - 分隔符

返回:

当前 C 实例

orFindInSet

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

返回:

当前 C 实例

orFindInSet

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

item - 指定的项目

返回:

当前 C 实例

orFindInSet

C orFindInSet(Column column,
              Object value)

orFindInSet

default C orFindInSet(boolean isEffective,
                      Column column,
                      Object value)

orFindInSet

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

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

separator - 分隔符

返回:

当前 C 实例

orFindInSet

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

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

仅当 isEffective 为 true 时追加条件。

类型参数:

T - 实体类类型

F - 字段类型

参数:

isEffective - 是否使条件生效

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

item - 指定的项目

separator - 分隔符

返回:

当前 C 实例

limit

C limit(int offset,
        int limit)

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

参数:

offset - 需要跳过的行数

limit - 返回的最大行数

返回:

当前 C 实例

limit

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

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

仅当 isEffective 为 true 时应用限制。

参数:

isEffective - 是否使条件生效

offset - 需要跳过的行数

limit - 返回的最大行数

返回:

当前 C 实例

limit

C limit(int limit)

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

参数:

limit - 返回的最大行数

返回:

当前 C 实例

limit

default C limit(boolean isEffective,
                int limit)

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

仅当 isEffective 为 true 时应用限制。

参数:

isEffective - 是否使条件生效

limit - 返回的最大行数

返回:

当前 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);
         });
     });
 

参数:

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

返回:

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

andCondition

default C andCondition(boolean isEffective,
                       Consumer<GenericWhereCondition> nestedCondition)

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

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

参数:

isEffective - 是否使条件生效

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

返回:

当前的 GenericWhereCondition 实例

orCondition

default C orCondition(Consumer<GenericWhereCondition> nestedCondition)

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

参数:

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

返回:

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

另请参阅:

andCondition(Consumer)

orCondition

default C orCondition(boolean isEffective,
                      Consumer<GenericWhereCondition> nestedCondition)

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

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

参数:

isEffective - 是否使条件生效

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

返回:

当前的 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());
     
 

参数:

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

返回:

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

andFunction

default C andFunction(boolean isEffective,
                      ColumFunction columFunction)

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

仅当 isEffective 为 true 时追加条件。

参数:

isEffective - 是否使条件生效

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

返回:

当前的 Condition 实例

orFunction

C orFunction(ColumFunction columFunction)

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

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

参数:

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

返回:

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

orFunction

default C orFunction(boolean isEffective,
                     ColumFunction columFunction)

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

仅当 isEffective 为 true 时追加条件。

参数:

isEffective - 是否使条件生效

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

返回:

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

self

default C self()

返回当前对象自身，作为其泛型类型 C 的实例。

该方法通常用于泛型接口或抽象类中的链式调用，在自引用泛型（self-referencing generics）模式下， 可以避免子类在每次方法调用后手动进行类型转换。

 public interface Condition<C extends Condition<C>> {
     default C andEqualTo(...) {
         // 逻辑
         return self();
     }
 }
 

返回:

当前对象，作为泛型类型 C