接口的使用
com.dynamic.sql.core.condition.Condition

使用Condition的程序包

程序包	说明
com.dynamic.sql.core.condition
com.dynamic.sql.core.condition.impl.dialect
com.dynamic.sql.core.dml.select
com.dynamic.sql.core.dml.select.build.join

com.dynamic.sql.core.condition中Condition的使用

com.dynamic.sql.core.condition中Condition的子接口

限定符和类型	接口和说明
interface	FunctionCondition
interface	NestedCondition

实现Condition的com.dynamic.sql.core.condition中的类

限定符和类型	类和说明
class	WhereCondition

返回Condition的com.dynamic.sql.core.condition中的方法

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

类型变量类型为Condition的com.dynamic.sql.core.condition中的方法参数

限定符和类型	方法和说明
default Condition	Condition.andCondition(boolean isEffective, Consumer<Condition> nestedCondition) 根据条件添加一组条件，并且运算。
default Condition	Condition.andCondition(Consumer<Condition> nestedCondition) 添加一组条件，并且运算。
default Condition	Condition.orCondition(boolean isEffective, Consumer<Condition> nestedCondition) 根据条件添加一个嵌套条件，或运算。
default Condition	Condition.orCondition(Consumer<Condition> nestedCondition) 添加一个嵌套条件，或运算。

com.dynamic.sql.core.condition.impl.dialect中Condition的使用

实现Condition的com.dynamic.sql.core.condition.impl.dialect中的类

限定符和类型	类和说明
class	GenericWhereCondition
class	MysqlWhereCondition
class	OracleWhereCondition

返回Condition的com.dynamic.sql.core.condition.impl.dialect中的方法

限定符和类型	方法和说明
<T1,T2,F> Condition	GenericWhereCondition.andBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField)
<T,F> Condition	GenericWhereCondition.andBetween(Fn<T,F> fn, Object start, Object end)
Condition	GenericWhereCondition.andCondition(Consumer<Condition> nestedCondition)
Condition	GenericWhereCondition.andEqualTo(ColumFunction columFunction, Object value)
Condition	GenericWhereCondition.andEqualTo(Column column, Object value)
<T1,T2,F> Condition	GenericWhereCondition.andEqualTo(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.andEqualTo(Fn<T,F> fn, Object value)
<T,F> Condition	GenericWhereCondition.andFindInSet(Fn<T,F> fn, Object item)
<T,F> Condition	MysqlWhereCondition.andFindInSet(Fn<T,F> fn, Object item)
<T,F> Condition	GenericWhereCondition.andFindInSet(Fn<T,F> fn, Object item, String separator)
<T,F> Condition	MysqlWhereCondition.andFindInSet(Fn<T,F> fn, Object item, String separator)
Condition	GenericWhereCondition.andFunction(ColumFunction columFunction)
Condition	GenericWhereCondition.andGreaterThan(ColumFunction columFunction, Object value)
<T1,T2,F> Condition	GenericWhereCondition.andGreaterThan(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.andGreaterThan(Fn<T,F> fn, Object value)
Condition	GenericWhereCondition.andGreaterThanOrEqualTo(ColumFunction columFunction, Object value)
<T1,T2,F> Condition	GenericWhereCondition.andGreaterThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.andGreaterThanOrEqualTo(Fn<T,F> fn, Object value)
Condition	GenericWhereCondition.andIn(ColumFunction columFunction, Iterable<?> values)
Condition	GenericWhereCondition.andIn(Column column, Iterable<?> values)
<T,F> Condition	GenericWhereCondition.andIn(Fn<T,F> fn, Iterable<?> values)
Condition	GenericWhereCondition.andIsNotNull(ColumFunction columFunction, Object value)
<T,F> Condition	GenericWhereCondition.andIsNotNull(Fn<T,F> fn)
Condition	GenericWhereCondition.andIsNull(ColumFunction columFunction, Object value)
<T,F> Condition	GenericWhereCondition.andIsNull(Fn<T,F> fn)
Condition	GenericWhereCondition.andLessThan(ColumFunction columFunction, Object value)
<T1,T2,F> Condition	GenericWhereCondition.andLessThan(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.andLessThan(Fn<T,F> fn, Object value)
Condition	GenericWhereCondition.andLessThanOrEqualTo(ColumFunction columFunction, Object value)
<T1,T2,F> Condition	GenericWhereCondition.andLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.andLessThanOrEqualTo(Fn<T,F> fn, Object value)
<T,F> Condition	GenericWhereCondition.andLike(Fn<T,F> fn, String pattern)
<T,F> Condition	GenericWhereCondition.andMatches(Fn<T,F> fn, String regex)
<T,F> Condition	OracleWhereCondition.andMatches(Fn<T,F> fn, String regex)
<T,F> Condition	MysqlWhereCondition.andMatches(Fn<T,F> fn, String regex)
<T,F> Condition	GenericWhereCondition.andNotBetween(Fn<T,F> fn, Object start, Object end)
Condition	GenericWhereCondition.andNotEqualTo(ColumFunction columFunction, Object value)
<T1,T2,F> Condition	GenericWhereCondition.andNotEqualTo(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.andNotEqualTo(Fn<T,F> fn, Object value)
Condition	GenericWhereCondition.andNotIn(ColumFunction columFunction, Iterable<?> values)
<T,F> Condition	GenericWhereCondition.andNotIn(Fn<T,F> fn, Iterable<?> values)
<T,F> Condition	GenericWhereCondition.andNotLike(Fn<T,F> fn, String pattern)
Condition	GenericWhereCondition.limit(int limit)
Condition	MysqlWhereCondition.limit(int limit)
Condition	GenericWhereCondition.limit(int offset, int limit)
Condition	MysqlWhereCondition.limit(int offset, int limit)
<T,F> Condition	OracleWhereCondition.matches(LogicalOperatorType logicalOperatorType, Fn<T,F> fn, String regex)
<T,F> Condition	MysqlWhereCondition.matches(LogicalOperatorType logicalOperatorType, Fn<T,F> fn, String regex)
<T1,T2,F> Condition	GenericWhereCondition.orBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField)
<T,F> Condition	GenericWhereCondition.orBetween(Fn<T,F> fn, Object start, Object end)
Condition	GenericWhereCondition.orCondition(Consumer<Condition> nestedCondition)
Condition	GenericWhereCondition.orEqualTo(ColumFunction columFunction, Object value)
<T1,T2,F> Condition	GenericWhereCondition.orEqualTo(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.orEqualTo(Fn<T,F> fn, Object value)
<T,F> Condition	GenericWhereCondition.orFindInSet(Fn<T,F> fn, Object item)
<T,F> Condition	MysqlWhereCondition.orFindInSet(Fn<T,F> fn, Object item)
<T,F> Condition	GenericWhereCondition.orFindInSet(Fn<T,F> fn, Object item, String separator)
<T,F> Condition	MysqlWhereCondition.orFindInSet(Fn<T,F> fn, Object item, String separator)
Condition	GenericWhereCondition.orFunction(ColumFunction columFunction)
Condition	GenericWhereCondition.orGreaterThan(ColumFunction columFunction, Object value)
<T1,T2,F> Condition	GenericWhereCondition.orGreaterThan(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.orGreaterThan(Fn<T,F> fn, Object value)
Condition	GenericWhereCondition.orGreaterThanOrEqualTo(ColumFunction columFunction, Object value)
<T1,T2,F> Condition	GenericWhereCondition.orGreaterThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.orGreaterThanOrEqualTo(Fn<T,F> fn, Object value)
Condition	GenericWhereCondition.orIn(ColumFunction columFunction, Iterable<?> values)
<T,F> Condition	GenericWhereCondition.orIn(Fn<T,F> fn, Iterable<?> values)
Condition	GenericWhereCondition.orIsNotNull(ColumFunction columFunction, Object value)
<T,F> Condition	GenericWhereCondition.orIsNotNull(Fn<T,F> fn)
Condition	GenericWhereCondition.orIsNull(ColumFunction columFunction, Object value)
<T,F> Condition	GenericWhereCondition.orIsNull(Fn<T,F> fn)
Condition	GenericWhereCondition.orLessThan(ColumFunction columFunction, Object value)
<T1,T2,F> Condition	GenericWhereCondition.orLessThan(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.orLessThan(Fn<T,F> fn, Object value)
Condition	GenericWhereCondition.orLessThanOrEqualTo(ColumFunction columFunction, Object value)
<T1,T2,F> Condition	GenericWhereCondition.orLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.orLessThanOrEqualTo(Fn<T,F> fn, Object value)
<T,F> Condition	GenericWhereCondition.orLike(Fn<T,F> fn, String pattern)
<T,F> Condition	GenericWhereCondition.orMatches(Fn<T,F> fn, String regex)
<T,F> Condition	OracleWhereCondition.orMatches(Fn<T,F> fn, String regex)
<T,F> Condition	MysqlWhereCondition.orMatches(Fn<T,F> fn, String regex)
<T,F> Condition	GenericWhereCondition.orNotBetween(Fn<T,F> fn, Object start, Object end)
Condition	GenericWhereCondition.orNotEqualTo(ColumFunction columFunction, Object value)
<T1,T2,F> Condition	GenericWhereCondition.orNotEqualTo(Fn<T1,F> field1, Fn<T2,F> field2)
<T,F> Condition	GenericWhereCondition.orNotEqualTo(Fn<T,F> fn, Object value)
Condition	GenericWhereCondition.orNotIn(ColumFunction columFunction, Iterable<?> values)
<T,F> Condition	GenericWhereCondition.orNotIn(Fn<T,F> fn, Iterable<?> values)
<T,F> Condition	GenericWhereCondition.orNotLike(Fn<T,F> fn, String pattern)

类型变量类型为Condition的com.dynamic.sql.core.condition.impl.dialect中的方法参数

限定符和类型	方法和说明
Condition	GenericWhereCondition.andCondition(Consumer<Condition> nestedCondition)
Condition	GenericWhereCondition.orCondition(Consumer<Condition> nestedCondition)

com.dynamic.sql.core.dml.select中Condition的使用

com.dynamic.sql.core.dml.select中Condition的子接口

限定符和类型	接口和说明
interface	HavingCondition

类型变量类型为Condition的com.dynamic.sql.core.dml.select中的方法参数

限定符和类型	方法和说明
JoinCondition	JoinCondition.fullJoin(Class<?> clazz, Consumer<Condition> onCondition) 构建一个 FULL JOIN 连接，用于将当前查询与另一个表关联。
JoinCondition	TableRelation.fullJoin(Class<?> clazz, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.fullJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition) 构建一个 FULL JOIN 连接，用于将当前查询与另一个表关联。
JoinCondition	TableRelation.fullJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.fullJoin(CteTable cte, Consumer<Condition> onCondition) 构建一个 FULL JOIN 连接，用于将当前查询与公共表表达式 (CTE) 的结果关联。
JoinCondition	TableRelation.fullJoin(CteTable cte, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.innerJoin(Class<?> clazz, Consumer<Condition> onCondition) 构建一个 INNER JOIN 连接，用于将当前查询与另一个表关联。
JoinCondition	TableRelation.innerJoin(Class<?> clazz, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.innerJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition) 构建一个 INNER JOIN 连接，用于将当前查询与另一个表关联。
JoinCondition	TableRelation.innerJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.innerJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<Condition> onCondition) 构建一个 INNER JOIN 连接，用于将当前查询与子查询结果关联。
JoinCondition	TableRelation.innerJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.innerJoin(CteTable cte, Consumer<Condition> onCondition) 构建一个 INNER JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
JoinCondition	TableRelation.innerJoin(CteTable cte, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.innerJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<Condition> onCondition) 构建一个 INNER JOIN 连接，用于将当前查询与表函数的结果关联。
JoinCondition	TableRelation.innerJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<Condition> onCondition)
default JoinCondition	JoinCondition.join(Class<?> clazz, Consumer<Condition> onCondition) INNER JOIN 的别名方法。
default JoinCondition	JoinCondition.join(Class<?> clazz, String alias, Consumer<Condition> onCondition) INNER JOIN 的别名方法，允许指定表别名。
default JoinCondition	JoinCondition.join(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<Condition> onCondition) 使用嵌套查询的 INNER JOIN 方法。
default JoinCondition	JoinCondition.join(CteTable cte, Consumer<Condition> onCondition) 使用 CTE 表进行 INNER JOIN。
default JoinCondition	JoinCondition.join(Supplier<TableFunction> tableFunction, String alias, Consumer<Condition> onCondition) 使用表函数和条件进行 INNER JOIN。
JoinCondition	JoinCondition.leftJoin(Class<?> clazz, Consumer<Condition> onCondition) 构建一个 LEFT JOIN 连接，用于将当前查询与另一个表关联。
JoinCondition	TableRelation.leftJoin(Class<?> clazz, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.leftJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition) 构建一个 LEFT JOIN 连接，用于将当前查询与另一个表关联。
JoinCondition	TableRelation.leftJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.leftJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<Condition> onCondition) 构建一个 LEFT JOIN 连接，用于将当前查询与子查询结果关联。
JoinCondition	TableRelation.leftJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.leftJoin(CteTable cte, Consumer<Condition> onCondition) 构建一个 LEFT JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
JoinCondition	TableRelation.leftJoin(CteTable cte, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.leftJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<Condition> onCondition) 构建一个 LEFT JOIN 连接，用于将当前查询与表函数的结果关联。
JoinCondition	TableRelation.leftJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.rightJoin(Class<?> clazz, Consumer<Condition> onCondition) 构建一个 RIGHT JOIN 连接，用于将当前查询与另一个表关联。
JoinCondition	TableRelation.rightJoin(Class<?> clazz, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.rightJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition) 构建一个 RIGHT JOIN 连接，用于将当前查询与另一个表关联。
JoinCondition	TableRelation.rightJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.rightJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<Condition> onCondition) 构建一个 RIGHT JOIN 连接，用于将当前查询与子查询结果关联。
JoinCondition	TableRelation.rightJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.rightJoin(CteTable cte, Consumer<Condition> onCondition) 构建一个 RIGHT JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
JoinCondition	TableRelation.rightJoin(CteTable cte, Consumer<Condition> onCondition)
JoinCondition	JoinCondition.rightJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<Condition> onCondition) 构建一个 RIGHT JOIN 连接，用于将当前查询与表函数的结果关联。
JoinCondition	TableRelation.rightJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<Condition> onCondition)

com.dynamic.sql.core.dml.select.build.join中Condition的使用

返回变量类型为Condition的类型的com.dynamic.sql.core.dml.select.build.join中的方法

限定符和类型	方法和说明
Consumer<Condition>	LeftJoin.getOnCondition()
Consumer<Condition>	NestedJoin.getOnCondition()
Consumer<Condition>	RightJoin.getOnCondition()
Consumer<Condition>	SelfJoin.getOnCondition()
Consumer<Condition>	InnerJoin.getOnCondition()
Consumer<Condition>	FromJoin.getOnCondition()
Consumer<Condition>	CrossJoin.getOnCondition()
Consumer<Condition>	FullJoin.getOnCondition()
abstract Consumer<Condition>	JoinTable.getOnCondition()
Consumer<Condition>	TableFunctionJoin.getOnCondition()

类型变量类型为Condition的com.dynamic.sql.core.dml.select.build.join中的构造器参数

构造器和说明
FullJoin(Class<?> tableClass, String alias, Consumer<Condition> onCondition)
FullJoin(CteTable cteTable, Consumer<Condition> onCondition)
InnerJoin(Class<?> tableClass, String alias, Consumer<Condition> onCondition)
InnerJoin(CteTable cteTable, Consumer<Condition> onCondition)
LeftJoin(Class<?> tableClass, String alias, Consumer<Condition> onCondition)
LeftJoin(CteTable cteTable, Consumer<Condition> onCondition)
NestedJoin(JoinTableType joinTableType, Consumer<AbstractColumnReference> nestedSelect, String tableAlias, Consumer<Condition> onCondition)
RightJoin(Class<?> tableClass, String alias, Consumer<Condition> onCondition)
RightJoin(CteTable cteTable, Consumer<Condition> onCondition)
SelfJoin(Class<?> tableClass, String alias, Consumer<Condition> onCondition)
SelfJoin(CteTable cteTable, Consumer<Condition> onCondition)
TableFunctionJoin(JoinTableType joinTableType, Supplier<TableFunction> tableFunction, String tableAlias, Consumer<Condition> onCondition)