接口的使用
com.dynamic.sql.core.Fn

使用Fn的程序包

程序包	说明
com.dynamic.sql.context
com.dynamic.sql.core
com.dynamic.sql.core.column
com.dynamic.sql.core.column.conventional
com.dynamic.sql.core.column.function
com.dynamic.sql.core.column.function.table
com.dynamic.sql.core.condition
com.dynamic.sql.core.condition.impl.dialect
com.dynamic.sql.core.database.parser
com.dynamic.sql.core.database.parser.dialect
com.dynamic.sql.core.dml.insert
com.dynamic.sql.core.dml.update
com.dynamic.sql.mapper
com.dynamic.sql.utils

com.dynamic.sql.context中Fn的使用

类型变量类型为Fn的com.dynamic.sql.context中的方法参数

限定符和类型	方法和说明
<T> int	DefaultSqlContext.insertSelective(T entity, Collection<Fn<T,?>> forcedFields)
<T> int	DefaultSqlContext.updateSelective(T entity, Collection<Fn<T,?>> forcedFields, Consumer<GenericWhereCondition> condition)
<T> int	DefaultSqlContext.updateSelectiveByPrimaryKey(T entity, Collection<Fn<T,?>> forcedFields)
<T> int	DefaultSqlContext.upsertSelective(T entity, Collection<Fn<T,?>> forcedFields)

com.dynamic.sql.core中Fn的使用

com.dynamic.sql.core中Fn的子接口

限定符和类型	接口和说明
interface	FieldFn<T,R>

实现Fn的com.dynamic.sql.core中的类

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

参数类型为Fn的com.dynamic.sql.core中的方法

限定符和类型	方法和说明
<T,F> AbstractColumnReference	AbstractColumnReference.column(boolean isEffective, Fn<T,F> fn) 条件性地添加一个列到查询中。
<T,F> ColumnReference	ColumnReference.column(Fn<T,F> fn)
abstract <T,F> AbstractColumnReference	AbstractColumnReference.column(Fn<T,F> fn) 添加一个列到查询中，使用方法引用指定字段。
<T,F> AbstractColumnReference	AbstractColumnReference.ignoreColumn(boolean isEffective, Fn<T,F> fn) 条件性地忽略一个列。
<T,F> AbstractColumnReference	ColumnReference.ignoreColumn(Fn<T,F> fn)
abstract <T,F> AbstractColumnReference	AbstractColumnReference.ignoreColumn(Fn<T,F> fn) 显式忽略一个列，使其不参与查询结果。

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

限定符和类型	方法和说明
<T> int	SqlContext.insertSelective(T entity, Collection<Fn<T,?>> forcedFields) 插入一个实体到数据库，选择性插入非空字段，并强制插入指定字段。
<T> int	SqlContext.updateSelective(T entity, Collection<Fn<T,?>> forcedFields, Consumer<GenericWhereCondition> condition) 根据指定条件更新实体对象的非空字段，并强制更新指定的字段。
<T> int	SqlContext.updateSelectiveByPrimaryKey(T entity, Collection<Fn<T,?>> forcedFields) 根据主键更新实体对象中非空字段，并强制更新指定的字段。
<T> int	SqlContext.upsertSelective(T entity, Collection<Fn<T,?>> forcedFields) 插入或更新实体（仅更新非空字段），并强制更新指定字段。

com.dynamic.sql.core.column中Fn的使用

实现Fn的com.dynamic.sql.core.column中的类

限定符和类型	类和说明
class	AbstractAliasHelper<T,F>
static class	AbstractAliasHelper.TableAliasImpl<T,F>

参数类型为Fn的com.dynamic.sql.core.column中的方法

限定符和类型	方法和说明
<T,F> ColumnArithmetic	ColumnArithmetic.add(Fn<T,F> column) 将指定列的值与当前列相加。
<T,F> ColumnArithmetic	ColumnArithmetic.divide(Fn<T,F> column) 将当前列的值与指定列相除。
<T,F> ColumnArithmetic	ColumnArithmetic.multiply(Fn<T,F> column) 将当前列的值与指定列相乘。
<T,F> ColumnArithmetic	ColumnArithmetic.subtract(Fn<T,F> column) 将指定列的值从当前列中减去。

com.dynamic.sql.core.column.conventional中Fn的使用

返回Fn的com.dynamic.sql.core.column.conventional中的方法

限定符和类型	方法和说明
Fn<?,?>	AllColumn.getOriginColumnFn()
Fn<?,?>	NumberColumn.getOriginColumnFn()
Fn<?,?>	Column.getOriginColumnFn()

参数类型为Fn的com.dynamic.sql.core.column.conventional中的构造器

构造器和说明
Column(Fn<T,F> fn)
Column(String tableAlias, Fn<T,F> fn)

com.dynamic.sql.core.column.function中Fn的使用

返回Fn的com.dynamic.sql.core.column.function中的方法

限定符和类型	方法和说明
Fn<?,?>	ColumFunction.getOriginColumnFn()
Fn<?,?>	ColumnFunctionDecorator.getOriginColumnFn()
Fn<?,?>	TableFunction.getOriginColumnFn()
Fn<?,?>	AnonymousFunction.getOriginColumnFn()

参数类型为Fn的com.dynamic.sql.core.column.function中的方法

限定符和类型	方法和说明
<T,F> AbstractColumFunction	AbstractColumFunction.add(Fn<T,F> column)
<T,F> AbstractColumFunction	AbstractColumFunction.divide(Fn<T,F> column)
<T,F> AbstractColumFunction	AbstractColumFunction.multiply(Fn<T,F> column)
<T,F> AbstractColumFunction	AbstractColumFunction.subtract(Fn<T,F> column)

com.dynamic.sql.core.column.function.table中Fn的使用

返回Fn的com.dynamic.sql.core.column.function.table中的方法

限定符和类型	方法和说明
Fn<?,?>	AbstractTableFunction.getOriginColumnFn()

参数类型为Fn的com.dynamic.sql.core.column.function.table中的构造器

构造器和说明
AbstractTableFunction(Fn<T,F> field)

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

参数类型为Fn的com.dynamic.sql.core.condition中的方法

限定符和类型	方法和说明
default <T1,T2,F> C	Condition.andBetween(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 根据条件添加字段 BETWEEN 连接条件，并且运算。
default <T1,T2,F> C	Condition.andBetween(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 根据条件添加字段 BETWEEN 连接条件，并且运算。
default <T1,T2,F> C	Condition.andBetween(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 根据条件添加字段 BETWEEN 连接条件，并且运算。
default <T,F> C	Condition.andBetween(boolean isEffective, Fn<T,F> fn, Object start, Object end) 根据条件添加字段在指定范围内条件，并且运算。
<T1,T2,F> C	Condition.andBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 添加字段 BETWEEN 连接条件，并且运算。
<T1,T2,F> C	Condition.andBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 添加字段 BETWEEN 连接条件，并且运算。
<T1,T2,F> C	Condition.andBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 添加字段 BETWEEN 连接条件，并且运算。
<T,F> C	Condition.andBetween(Fn<T,F> fn, Object start, Object end) 添加字段在指定范围内条件，并且运算。
default <T1,T2,F> C	Condition.andEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加等值连接条件，并且运算。
default <T1,T2,F> C	Condition.andEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加等值连接条件，并且运算。
default <T,F> C	NestedCondition.andEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加等于条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	Condition.andEqualTo(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加等于条件，并且运算。
<T1,T2,F> C	Condition.andEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加等值连接条件，并且运算。
<T1,T2,F> C	Condition.andEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加等值连接条件，并且运算。
<T,F> C	FunctionCondition.andEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.andEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加等于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	Condition.andEqualTo(Fn<T,F> fn, Object value) 添加等于条件，并且运算。
default <T,F> C	Condition.andFindInSet(boolean isEffective, Fn<T,F> fn, Object item) 根据条件添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数）。
default <T,F> C	Condition.andFindInSet(boolean isEffective, Fn<T,F> fn, Object item, String separator) 根据条件添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数），并指定分隔符。
<T,F> C	FunctionCondition.andFindInSet(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	Condition.andFindInSet(Fn<T,F> fn, Object item) 添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数）。
<T,F> C	Condition.andFindInSet(Fn<T,F> fn, Object item, String separator) 添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数），并指定分隔符。
default <T1,T2,F> C	Condition.andGreaterThan(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段大于连接条件，并且运算。
default <T1,T2,F> C	Condition.andGreaterThan(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段大于连接条件，并且运算。
default <T,F> C	NestedCondition.andGreaterThan(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加大于条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	Condition.andGreaterThan(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加字段大于指定值条件，并且运算。
<T1,T2,F> C	Condition.andGreaterThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于连接条件，并且运算。
<T1,T2,F> C	Condition.andGreaterThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于连接条件，并且运算。
<T,F> C	FunctionCondition.andGreaterThan(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.andGreaterThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加大于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	Condition.andGreaterThan(Fn<T,F> fn, Object value) 添加字段大于指定值条件，并且运算。
default <T1,T2,F> C	Condition.andGreaterThanOrEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段大于或等于连接条件，并且运算。
default <T1,T2,F> C	Condition.andGreaterThanOrEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段大于或等于连接条件，并且运算。
default <T,F> C	NestedCondition.andGreaterThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加大于等于条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	Condition.andGreaterThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加字段大于或等于指定值条件，并且运算。
<T1,T2,F> C	Condition.andGreaterThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于或等于连接条件，并且运算。
<T1,T2,F> C	Condition.andGreaterThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于或等于连接条件，并且运算。
<T,F> C	FunctionCondition.andGreaterThanOrEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.andGreaterThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加大于等于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	Condition.andGreaterThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段大于或等于指定值条件，并且运算。
default <T,F> C	NestedCondition.andIn(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 IN 条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	Condition.andIn(boolean isEffective, Fn<T,F> fn, Iterable<?> values) 根据条件添加字段在指定值集合中条件，并且运算。
<T,F> C	FunctionCondition.andIn(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.andIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加 IN 条件，并且运算，右侧值来自嵌套查询。
<T,F> C	Condition.andIn(Fn<T,F> fn, Iterable<?> values) 添加字段在指定值集合中条件，并且运算。
default <T,F> C	Condition.andIsNotNull(boolean isEffective, Fn<T,F> fn) 根据条件添加字段非空值条件，并且运算。
<T,F> C	Condition.andIsNotNull(Fn<T,F> fn) 添加字段非空值条件，并且运算。
default <T,F> C	Condition.andIsNull(boolean isEffective, Fn<T,F> fn) 根据条件添加字段为空值条件，并且运算。
<T,F> C	Condition.andIsNull(Fn<T,F> fn) 添加字段为空值条件，并且运算。
default <T1,T2,F> C	Condition.andLessThan(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段小于连接条件，并且运算。
default <T1,T2,F> C	Condition.andLessThan(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段小于连接条件，并且运算。
default <T,F> C	NestedCondition.andLessThan(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加小于条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	Condition.andLessThan(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加字段小于指定值条件，并且运算。
<T1,T2,F> C	Condition.andLessThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于连接条件，并且运算。
<T1,T2,F> C	Condition.andLessThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于连接条件，并且运算。
<T,F> C	FunctionCondition.andLessThan(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.andLessThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加小于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	Condition.andLessThan(Fn<T,F> fn, Object value) 添加字段小于指定值条件，并且运算。
default <T1,T2,F> C	Condition.andLessThanOrEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段小于或等于连接条件，并且运算。
default <T1,T2,F> C	Condition.andLessThanOrEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段小于或等于连接条件，并且运算。
default <T,F> C	NestedCondition.andLessThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加小于等于条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	Condition.andLessThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加字段小于或等于指定值条件，并且运算。
<T1,T2,F> C	Condition.andLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于或等于连接条件，并且运算。
<T1,T2,F> C	Condition.andLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于或等于连接条件，并且运算。
<T,F> C	FunctionCondition.andLessThanOrEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.andLessThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加小于等于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	Condition.andLessThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段小于或等于指定值条件，并且运算。
default <T,F> C	Condition.andLike(boolean isEffective, Fn<T,F> fn, String pattern) 根据条件添加字段匹配指定模式条件，并且运算。
<T,F> C	Condition.andLike(Fn<T,F> fn, String pattern) 添加字段匹配指定模式条件，并且运算。
default <T,F> C	Condition.andMatches(boolean isEffective, Fn<T,F> fn, String regex) 根据条件添加字段匹配正则表达式条件，并且运算。
<T,F> C	FunctionCondition.andMatches(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	Condition.andMatches(Fn<T,F> fn, String regex) 添加字段匹配正则表达式条件，并且运算。
default <T,F> C	Condition.andNotBetween(boolean isEffective, Fn<T,F> fn, Object start, Object end) 根据条件添加字段不在指定范围内条件，并且运算。
<T,F> C	Condition.andNotBetween(Fn<T,F> fn, Object start, Object end) 添加字段不在指定范围内条件，并且运算。
default <T1,T2,F> C	Condition.andNotEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段不等值连接条件，并且运算。
default <T1,T2,F> C	Condition.andNotEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段不等值连接条件，并且运算。
default <T,F> C	NestedCondition.andNotEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加不等于条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	Condition.andNotEqualTo(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加不等于条件，并且运算。
<T1,T2,F> C	Condition.andNotEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段不等值连接条件，并且运算。
<T1,T2,F> C	Condition.andNotEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段不等值连接条件，并且运算。
<T,F> C	FunctionCondition.andNotEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.andNotEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加不等于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	Condition.andNotEqualTo(Fn<T,F> fn, Object value) 添加不等于条件，并且运算。
default <T,F> C	NestedCondition.andNotIn(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 NOT IN 条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	Condition.andNotIn(boolean isEffective, Fn<T,F> fn, Iterable<?> values) 根据条件添加字段不在指定值集合中条件，并且运算。
<T,F> C	FunctionCondition.andNotIn(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.andNotIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加 NOT IN 条件，并且运算，右侧值来自嵌套查询。
<T,F> C	Condition.andNotIn(Fn<T,F> fn, Iterable<?> values) 添加字段不在指定值集合中条件，并且运算。
default <T,F> C	Condition.andNotLike(boolean isEffective, Fn<T,F> fn, String pattern) 根据条件添加字段不匹配指定模式条件，并且运算。
<T,F> C	Condition.andNotLike(Fn<T,F> fn, String pattern) 添加字段不匹配指定模式条件，并且运算。
default <T1,T2,F> C	Condition.orBetween(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 根据条件添加字段 BETWEEN 连接条件，或运算。
default <T1,T2,F> C	Condition.orBetween(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 根据条件添加字段 BETWEEN 连接条件，或运算。
default <T1,T2,F> C	Condition.orBetween(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 根据条件添加字段 BETWEEN 连接条件，或运算。
default <T,F> C	Condition.orBetween(boolean isEffective, Fn<T,F> fn, Object start, Object end) 根据条件添加字段在指定范围内条件，或运算。
<T1,T2,F> C	Condition.orBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 添加字段 BETWEEN 连接条件，或运算。
<T1,T2,F> C	Condition.orBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 添加字段 BETWEEN 连接条件，或运算。
<T1,T2,F> C	Condition.orBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 添加字段 BETWEEN 连接条件，或运算。
<T,F> C	Condition.orBetween(Fn<T,F> fn, Object start, Object end) 添加字段在指定范围内条件，或运算。
default <T1,T2,F> C	Condition.orEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段等值连接条件，或运算。
default <T1,T2,F> C	Condition.orEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段等值连接条件，或运算。
default <T,F> C	NestedCondition.orEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加等于条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	Condition.orEqualTo(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加等于条件，或运算。
<T1,T2,F> C	Condition.orEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段等值连接条件，或运算。
<T1,T2,F> C	Condition.orEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段等值连接条件，或运算。
<T,F> C	FunctionCondition.orEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.orEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加等于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	Condition.orEqualTo(Fn<T,F> fn, Object value) 添加等于条件，或运算。
default <T,F> C	Condition.orFindInSet(boolean isEffective, Fn<T,F> fn, Object item) 根据条件添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数）。
default <T,F> C	Condition.orFindInSet(boolean isEffective, Fn<T,F> fn, Object item, String separator) 根据条件添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数），并指定分隔符。
<T,F> C	FunctionCondition.orFindInSet(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	Condition.orFindInSet(Fn<T,F> fn, Object item) 添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数）。
<T,F> C	Condition.orFindInSet(Fn<T,F> fn, Object item, String separator) 添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数），并指定分隔符。
default <T1,T2,F> C	Condition.orGreaterThan(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段大于连接条件，或运算。
default <T1,T2,F> C	Condition.orGreaterThan(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段大于连接条件，或运算。
default <T,F> C	NestedCondition.orGreaterThan(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加大于条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	Condition.orGreaterThan(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加字段大于指定值条件，或运算。
<T1,T2,F> C	Condition.orGreaterThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于连接条件，或运算。
<T1,T2,F> C	Condition.orGreaterThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于连接条件，或运算。
<T,F> C	FunctionCondition.orGreaterThan(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.orGreaterThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加大于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	Condition.orGreaterThan(Fn<T,F> fn, Object value) 添加字段大于指定值条件，或运算。
default <T1,T2,F> C	Condition.orGreaterThanOrEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段大于或等于连接条件，或运算。
default <T1,T2,F> C	Condition.orGreaterThanOrEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段大于或等于连接条件，或运算。
default <T,F> C	NestedCondition.orGreaterThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加大于等于条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	Condition.orGreaterThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加字段大于或等于指定值条件，或运算。
<T1,T2,F> C	Condition.orGreaterThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于或等于连接条件，或运算。
<T1,T2,F> C	Condition.orGreaterThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于或等于连接条件，或运算。
<T,F> C	FunctionCondition.orGreaterThanOrEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.orGreaterThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加大于等于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	Condition.orGreaterThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段大于或等于指定值条件，或运算。
default <T,F> C	NestedCondition.orIn(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 IN 条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	Condition.orIn(boolean isEffective, Fn<T,F> fn, Iterable<?> values) 根据条件添加字段在指定值集合中条件，或运算。
<T,F> C	FunctionCondition.orIn(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.orIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加 IN 条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	Condition.orIn(Fn<T,F> fn, Iterable<?> values) 添加字段在指定值集合中条件，或运算。
default <T,F> C	Condition.orIsNotNull(boolean isEffective, Fn<T,F> fn) 根据条件添加字段非空值条件，或运算。
<T,F> C	Condition.orIsNotNull(Fn<T,F> fn) 添加字段非空值条件，或运算。
default <T,F> C	Condition.orIsNull(boolean isEffective, Fn<T,F> fn) 根据条件添加字段为空值条件，或运算。
<T,F> C	Condition.orIsNull(Fn<T,F> fn) 添加字段为空值条件，或运算。
default <T1,T2,F> C	Condition.orLessThan(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段小于连接条件，或运算。
default <T1,T2,F> C	Condition.orLessThan(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段小于连接条件，或运算。
default <T,F> C	NestedCondition.orLessThan(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加小于条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	Condition.orLessThan(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加字段小于指定值条件，或运算。
<T1,T2,F> C	Condition.orLessThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于连接条件，或运算。
<T1,T2,F> C	Condition.orLessThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于连接条件，或运算。
<T,F> C	FunctionCondition.orLessThan(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.orLessThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加小于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	Condition.orLessThan(Fn<T,F> fn, Object value) 添加字段小于指定值条件，或运算。
default <T1,T2,F> C	Condition.orLessThanOrEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段小于或等于连接条件，或运算。
default <T1,T2,F> C	Condition.orLessThanOrEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段小于或等于连接条件，或运算。
default <T,F> C	NestedCondition.orLessThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加小于等于条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	Condition.orLessThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加字段小于或等于指定值条件，或运算。
<T1,T2,F> C	Condition.orLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于或等于连接条件，或运算。
<T1,T2,F> C	Condition.orLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于或等于连接条件，或运算。
<T,F> C	FunctionCondition.orLessThanOrEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.orLessThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加小于等于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	Condition.orLessThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段小于或等于指定值条件，或运算。
default <T,F> C	Condition.orLike(boolean isEffective, Fn<T,F> fn, String pattern) 根据条件添加字段匹配指定模式条件，或运算。
<T,F> C	Condition.orLike(Fn<T,F> fn, String pattern) 添加字段匹配指定模式条件，或运算。
default <T,F> C	Condition.orMatches(boolean isEffective, Fn<T,F> fn, String regex) 根据条件添加字段匹配正则表达式条件，或运算。
<T,F> C	FunctionCondition.orMatches(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	Condition.orMatches(Fn<T,F> fn, String regex) 添加字段匹配正则表达式条件，或运算。
default <T,F> C	Condition.orNotBetween(boolean isEffective, Fn<T,F> fn, Object start, Object end) 根据条件添加字段不在指定范围内条件，或运算。
<T,F> C	Condition.orNotBetween(Fn<T,F> fn, Object start, Object end) 添加字段不在指定范围内条件，或运算。
default <T1,T2,F> C	Condition.orNotEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段不等值连接条件，或运算。
default <T1,T2,F> C	Condition.orNotEqualTo(boolean isEffective, Fn<T1,F> field1, Fn<T2,F> field2) 根据条件添加字段不等值连接条件，或运算。
default <T,F> C	NestedCondition.orNotEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加不等于条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	Condition.orNotEqualTo(boolean isEffective, Fn<T,F> fn, Object value) 根据条件添加不等于条件，或运算。
<T1,T2,F> C	Condition.orNotEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段不等值连接条件，或运算。
<T1,T2,F> C	Condition.orNotEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段不等值连接条件，或运算。
<T,F> C	FunctionCondition.orNotEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.orNotEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加不等于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	Condition.orNotEqualTo(Fn<T,F> fn, Object value) 添加不等于条件，或运算。
default <T,F> C	NestedCondition.orNotIn(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 NOT IN 条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	Condition.orNotIn(boolean isEffective, Fn<T,F> fn, Iterable<?> values) 根据条件添加字段不在指定值集合中条件，或运算。
<T,F> C	FunctionCondition.orNotIn(Fn<T,F> fn, ColumFunction columFunction)
<T,F> C	NestedCondition.orNotIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加 NOT IN 条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	Condition.orNotIn(Fn<T,F> fn, Iterable<?> values) 添加字段不在指定值集合中条件，或运算。
default <T,F> C	Condition.orNotLike(boolean isEffective, Fn<T,F> fn, String pattern) 根据条件添加字段不匹配指定模式条件，或运算。
<T,F> C	Condition.orNotLike(Fn<T,F> fn, String pattern) 添加字段不匹配指定模式条件，或运算。

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

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

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

com.dynamic.sql.core.database.parser中Fn的使用

参数类型为Fn的com.dynamic.sql.core.database.parser中的方法

限定符和类型	方法和说明
void	InsertParser.insertSelective(Fn<?,?>[] forcedFields)
void	UpdateParser.updateSelective(Fn<?,?>[] forcedFields)
void	UpdateParser.updateSelectiveByPrimaryKey(Fn<?,?>[] forcedFields)
void	InsertParser.upsert(Fn<?,?>[] forcedFields)
void	UpdateParser.upsertSelective(Fn<?,?>[] forcedFields)

com.dynamic.sql.core.database.parser.dialect中Fn的使用

参数类型为Fn的com.dynamic.sql.core.database.parser.dialect中的方法

限定符和类型	方法和说明
void	MysqlParser.insertSelective(Fn<?,?>[] forcedFields)
void	OracleParser.insertSelective(Fn<?,?>[] forcedFields)
void	MysqlParser.updateSelective(Fn<?,?>[] forcedFields)
void	OracleParser.updateSelective(Fn<?,?>[] forcedFields)
void	MysqlParser.updateSelectiveByPrimaryKey(Fn<?,?>[] forcedFields)
void	OracleParser.updateSelectiveByPrimaryKey(Fn<?,?>[] forcedFields)
void	MysqlParser.upsert(Fn<?,?>[] forcedFields)
void	OracleParser.upsert(Fn<?,?>[] forcedFields)
void	MysqlParser.upsertSelective(Fn<?,?>[] forcedFields)
void	OracleParser.upsertSelective(Fn<?,?>[] forcedFields)

com.dynamic.sql.core.dml.insert中Fn的使用

参数类型为Fn的com.dynamic.sql.core.dml.insert中的构造器

构造器和说明
EntitiesInserter(Object entity, Fn<?,?>[] forcedFields)

com.dynamic.sql.core.dml.update中Fn的使用

参数类型为Fn的com.dynamic.sql.core.dml.update中的构造器

构造器和说明
EntitiesUpdater(Collection<Object> entities, Fn<?,?>[] forcedFields)
EntitiesUpdater(Collection<Object> entities, Fn<?,?>[] forcedFields, Consumer<GenericWhereCondition> condition)

com.dynamic.sql.mapper中Fn的使用

类型变量类型为Fn的com.dynamic.sql.mapper中的方法参数

限定符和类型	方法和说明
int	EntityMapper.insertSelective(T entity, Collection<Fn<T,?>> forcedFields) 插入一个实体到数据库，选择性插入非空字段，并强制插入指定字段。
int	EntityMapper.updateSelective(T entity, Collection<Fn<T,?>> forcedFields, Consumer<WhereCondition> condition) 根据指定条件更新实体对象的非空字段，并强制更新指定的字段。
int	EntityMapper.updateSelectiveByPrimaryKey(T entity, Collection<Fn<T,?>> forcedFields) 根据主键更新实体对象中非空字段，并强制更新指定的字段。
int	EntityMapper.upsertSelective(T entity, Collection<Fn<T,?>> forcedFields) 插入或更新实体（仅更新非空字段），并强制更新指定字段。

com.dynamic.sql.utils中Fn的使用

参数类型为Fn的com.dynamic.sql.utils中的方法

限定符和类型	方法和说明
static <T,F> String	SqlUtils.extractQualifiedAlias(Fn<T,F> field, Map<String,TableAliasMapping> aliasTableMap, String dataSourceName)
static <T,F> String	SqlUtils.extractQualifiedAlias(Fn<T,F> field, Map<String,TableAliasMapping> aliasTableMap, String dataSourceName, SqlExecuteType sqlExecuteType)
static <T,F> String	SqlUtils.extractQualifiedAlias(String tableAlias, Fn<T,F> field, Map<String,TableAliasMapping> aliasTableMap, String dataSourceName, SqlExecuteType sqlExecuteType) 按照当前SQL语义匹配最佳表别名, 之后拼接列名 TODO 应当将别名和列名分开处理
static String	ReflectUtils.fnToFieldName(Fn fn) 根据传入的函数式接口 Fn 获取对应的字段名。
static String	ReflectUtils.getOriginalClassCanonicalName(Fn fn) 从 SerializedLambda 获取原始类的全限定名称。
static String	ReflectUtils.getOriginalClassShortCanonicalName(Fn fn) 从 SerializedLambda 获取原始类的短名称（不包含包名）。
static <C> Class<C>	ReflectUtils.getReturnTypeFromSignature(Fn fn) 从给定的函数式接口 `Fn` 中获取返回值的类型。
static String	SqlUtils.registerValueWithKey(ParameterBinder parameters, Fn<?,?> fn, Object value)