com.dynamic.sql.core.condition.impl.dialect

类 GenericWhereCondition

java.lang.Object

com.dynamic.sql.core.condition.WhereCondition

com.dynamic.sql.core.condition.impl.dialect.GenericWhereCondition

所有已实现的接口:

Condition, FunctionCondition, NestedCondition, HavingCondition

直接已知子类:

MysqlWhereCondition, OracleWhereCondition

public class GenericWhereCondition
extends WhereCondition

字段概要

字段

限定符和类型	字段和说明
protected Map<String,String>	aliasTableMap
protected StringBuilder	condition
protected String	dataSourceName
protected boolean	isFirstBuild
protected ParameterBinder	parameterBinder
protected Version	version

构造器概要

构造器

构造器和说明
GenericWhereCondition(Version version, Map<String,String> aliasTableMap, String dataSourceName)

方法概要

限定符和类型	方法和说明
HavingCondition	andBetween(AggregateFunction function, Object start, Object end)
<T1,T2,F> Condition	andBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 添加字段 BETWEEN 连接条件，并且运算。
<T,F> Condition	andBetween(Fn<T,F> fn, Object start, Object end) 添加字段在指定范围内条件，并且运算。
Condition	andCondition(Consumer<Condition> nestedCondition) 添加一组条件，并且运算。
HavingCondition	andEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	andEqualTo(AggregateFunction function, Object value)
Condition	andEqualTo(Column column, Object value)
<T1,T2,F> Condition	andEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加等值连接条件，并且运算。
<T,F> FunctionCondition	andEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	andEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	andEqualTo(Fn<T,F> fn, Object value) 添加等于条件，并且运算。
FunctionCondition	andEqualTo(Object value, ColumFunction columFunction)
NestedCondition	andExists(Consumer<AbstractColumnReference> nestedSelect)
<T,F> FunctionCondition	andFindInSet(Fn<T,F> fn, ColumFunction columFunction)
<T,F> Condition	andFindInSet(Fn<T,F> fn, Object item) 添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数）。
<T,F> Condition	andFindInSet(Fn<T,F> fn, Object item, String separator) 添加字段在指定集合中条件，并且运算（使用 FIND_IN_SET 函数），并指定分隔符。
HavingCondition	andGreaterThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	andGreaterThan(AggregateFunction function, Object value)
<T1,T2,F> Condition	andGreaterThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于连接条件，并且运算。
<T,F> FunctionCondition	andGreaterThan(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	andGreaterThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	andGreaterThan(Fn<T,F> fn, Object value) 添加字段大于指定值条件，并且运算。
HavingCondition	andGreaterThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	andGreaterThanOrEqualTo(AggregateFunction function, Object value)
<T1,T2,F> Condition	andGreaterThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于或等于连接条件，并且运算。
<T,F> FunctionCondition	andGreaterThanOrEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	andGreaterThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	andGreaterThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段大于或等于指定值条件，并且运算。
HavingCondition	andIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	andIn(AggregateFunction function, Iterable<?> values)
Condition	andIn(Column column, Iterable<?> values)
<T,F> FunctionCondition	andIn(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	andIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	andIn(Fn<T,F> fn, Iterable<?> values) 添加字段在指定值集合中条件，并且运算。
<T,F> Condition	andIsNotNull(Fn<T,F> fn) 添加字段非空值条件，并且运算。
<T,F> Condition	andIsNull(Fn<T,F> fn) 添加字段为空值条件，并且运算。
HavingCondition	andLessThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	andLessThan(AggregateFunction function, Object value)
<T1,T2,F> Condition	andLessThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于连接条件，并且运算。
<T,F> FunctionCondition	andLessThan(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	andLessThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	andLessThan(Fn<T,F> fn, Object value) 添加字段小于指定值条件，并且运算。
HavingCondition	andLessThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	andLessThanOrEqualTo(AggregateFunction function, Object value)
<T1,T2,F> Condition	andLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于或等于连接条件，并且运算。
<T,F> FunctionCondition	andLessThanOrEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	andLessThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	andLessThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段小于或等于指定值条件，并且运算。
<T,F> Condition	andLike(Fn<T,F> fn, String pattern) 添加字段匹配指定模式条件，并且运算。
<T,F> FunctionCondition	andMatches(Fn<T,F> fn, ColumFunction columFunction)
<T,F> Condition	andMatches(Fn<T,F> fn, String regex) 添加字段匹配正则表达式条件，并且运算。
HavingCondition	andNotBetween(AggregateFunction function, Object start, Object end)
<T,F> Condition	andNotBetween(Fn<T,F> fn, Object start, Object end) 添加字段不在指定范围内条件，并且运算。
HavingCondition	andNotEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	andNotEqualTo(AggregateFunction function, Object value)
<T1,T2,F> Condition	andNotEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段不等值连接条件，并且运算。
<T,F> FunctionCondition	andNotEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	andNotEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	andNotEqualTo(Fn<T,F> fn, Object value) 添加不等于条件，并且运算。
NestedCondition	andNotExists(Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	andNotIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	andNotIn(AggregateFunction function, Iterable<?> values)
<T,F> FunctionCondition	andNotIn(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	andNotIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	andNotIn(Fn<T,F> fn, Iterable<?> values) 添加字段不在指定值集合中条件，并且运算。
<T,F> Condition	andNotLike(Fn<T,F> fn, String pattern) 添加字段不匹配指定模式条件，并且运算。
protected String	executeFunctionToString(AggregateFunction function)
ParameterBinder	getParameterBinder()
String	getWhereConditionSyntax()
Condition	limit(int limit) 限制查询结果的返回行数
Condition	limit(int offset, int limit) 限制查询结果的返回行数
protected String	logicalOperatorType(LogicalOperatorType logicalOperatorType)
protected String	logicalOperatorType(LogicalOperatorType logicalOperatorType, SqlDialect sqlDialect) 首次连接时才会去拼接 and 或者 or
HavingCondition	orBetween(AggregateFunction function, Object start, Object end)
<T1,T2,F> Condition	orBetween(Fn<T1,F> field1, Fn<T2,F> startField, Fn<T2,F> endField) 添加字段 BETWEEN 连接条件，或运算。
<T,F> Condition	orBetween(Fn<T,F> fn, Object start, Object end) 添加字段在指定范围内条件，或运算。
Condition	orCondition(Consumer<Condition> nestedCondition) 添加一个嵌套条件，或运算。
HavingCondition	orEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	orEqualTo(AggregateFunction function, Object value)
<T1,T2,F> Condition	orEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段等值连接条件，或运算。
<T,F> FunctionCondition	orEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	orEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	orEqualTo(Fn<T,F> fn, Object value) 添加等于条件，或运算。
FunctionCondition	orEqualTo(Object value, ColumFunction columFunction)
NestedCondition	orExists(Consumer<AbstractColumnReference> nestedSelect)
<T,F> FunctionCondition	orFindInSet(Fn<T,F> fn, ColumFunction columFunction)
<T,F> Condition	orFindInSet(Fn<T,F> fn, Object item) 添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数）。
<T,F> Condition	orFindInSet(Fn<T,F> fn, Object item, String separator) 添加字段在指定集合中条件，或运算（使用 FIND_IN_SET 函数），并指定分隔符。
HavingCondition	orGreaterThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	orGreaterThan(AggregateFunction function, Object value)
<T1,T2,F> Condition	orGreaterThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于连接条件，或运算。
<T,F> FunctionCondition	orGreaterThan(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	orGreaterThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	orGreaterThan(Fn<T,F> fn, Object value) 添加字段大于指定值条件，或运算。
HavingCondition	orGreaterThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	orGreaterThanOrEqualTo(AggregateFunction function, Object value)
<T1,T2,F> Condition	orGreaterThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段大于或等于连接条件，或运算。
<T,F> FunctionCondition	orGreaterThanOrEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	orGreaterThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	orGreaterThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段大于或等于指定值条件，或运算。
HavingCondition	orIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	orIn(AggregateFunction function, Iterable<?> values)
<T,F> FunctionCondition	orIn(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	orIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	orIn(Fn<T,F> fn, Iterable<?> values) 添加字段在指定值集合中条件，或运算。
<T,F> Condition	orIsNotNull(Fn<T,F> fn) 添加字段非空值条件，或运算。
<T,F> Condition	orIsNull(Fn<T,F> fn) 添加字段为空值条件，或运算。
HavingCondition	orLessThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	orLessThan(AggregateFunction function, Object value)
<T1,T2,F> Condition	orLessThan(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于连接条件，或运算。
<T,F> FunctionCondition	orLessThan(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	orLessThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	orLessThan(Fn<T,F> fn, Object value) 添加字段小于指定值条件，或运算。
HavingCondition	orLessThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	orLessThanOrEqualTo(AggregateFunction function, Object value)
<T1,T2,F> Condition	orLessThanOrEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段小于或等于连接条件，或运算。
<T,F> FunctionCondition	orLessThanOrEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	orLessThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	orLessThanOrEqualTo(Fn<T,F> fn, Object value) 添加字段小于或等于指定值条件，或运算。
<T,F> Condition	orLike(Fn<T,F> fn, String pattern) 添加字段匹配指定模式条件，或运算。
<T,F> FunctionCondition	orMatches(Fn<T,F> fn, ColumFunction columFunction)
<T,F> Condition	orMatches(Fn<T,F> fn, String regex) 添加字段匹配正则表达式条件，或运算。
HavingCondition	orNotBetween(AggregateFunction function, Object start, Object end)
<T,F> Condition	orNotBetween(Fn<T,F> fn, Object start, Object end) 添加字段不在指定范围内条件，或运算。
HavingCondition	orNotEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	orNotEqualTo(AggregateFunction function, Object value)
<T1,T2,F> Condition	orNotEqualTo(Fn<T1,F> field1, Fn<T2,F> field2) 添加字段不等值连接条件，或运算。
<T,F> FunctionCondition	orNotEqualTo(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	orNotEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	orNotEqualTo(Fn<T,F> fn, Object value) 添加不等于条件，或运算。
NestedCondition	orNotExists(Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	orNotIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
HavingCondition	orNotIn(AggregateFunction function, Iterable<?> values)
<T,F> FunctionCondition	orNotIn(Fn<T,F> fn, ColumFunction columFunction)
<T,F> NestedCondition	orNotIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
<T,F> Condition	orNotIn(Fn<T,F> fn, Iterable<?> values) 添加字段不在指定值集合中条件，或运算。
<T,F> Condition	orNotLike(Fn<T,F> fn, String pattern) 添加字段不匹配指定模式条件，或运算。
protected SqlDialect	sqlDialect()

从类继承的方法 java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

字段详细资料

version

protected final Version version

aliasTableMap

protected final Map<String,String> aliasTableMap

condition

protected final StringBuilder condition

parameterBinder

protected final ParameterBinder parameterBinder

dataSourceName

protected String dataSourceName

isFirstBuild

protected boolean isFirstBuild

构造器详细资料

GenericWhereCondition

public GenericWhereCondition(Version version,
                             Map<String,String> aliasTableMap,
                             String dataSourceName)

方法详细资料

andEqualTo

public <T,F> FunctionCondition andEqualTo(Fn<T,F> fn,
                                          ColumFunction columFunction)

andEqualTo

public FunctionCondition andEqualTo(Object value,
                                    ColumFunction columFunction)

orEqualTo

public <T,F> FunctionCondition orEqualTo(Fn<T,F> fn,
                                         ColumFunction columFunction)

orEqualTo

public FunctionCondition orEqualTo(Object value,
                                   ColumFunction columFunction)

andNotEqualTo

public <T,F> FunctionCondition andNotEqualTo(Fn<T,F> fn,
                                             ColumFunction columFunction)

orNotEqualTo

public <T,F> FunctionCondition orNotEqualTo(Fn<T,F> fn,
                                            ColumFunction columFunction)

andGreaterThan

public <T,F> FunctionCondition andGreaterThan(Fn<T,F> fn,
                                              ColumFunction columFunction)

orGreaterThan

public <T,F> FunctionCondition orGreaterThan(Fn<T,F> fn,
                                             ColumFunction columFunction)

andGreaterThanOrEqualTo

public <T,F> FunctionCondition andGreaterThanOrEqualTo(Fn<T,F> fn,
                                                       ColumFunction columFunction)

orGreaterThanOrEqualTo

public <T,F> FunctionCondition orGreaterThanOrEqualTo(Fn<T,F> fn,
                                                      ColumFunction columFunction)

andLessThan

public <T,F> FunctionCondition andLessThan(Fn<T,F> fn,
                                           ColumFunction columFunction)

orLessThan

public <T,F> FunctionCondition orLessThan(Fn<T,F> fn,
                                          ColumFunction columFunction)

andLessThanOrEqualTo

public <T,F> FunctionCondition andLessThanOrEqualTo(Fn<T,F> fn,
                                                    ColumFunction columFunction)

orLessThanOrEqualTo

public <T,F> FunctionCondition orLessThanOrEqualTo(Fn<T,F> fn,
                                                   ColumFunction columFunction)

andIn

public <T,F> FunctionCondition andIn(Fn<T,F> fn,
                                     ColumFunction columFunction)

orIn

public <T,F> FunctionCondition orIn(Fn<T,F> fn,
                                    ColumFunction columFunction)

andNotIn

public <T,F> FunctionCondition andNotIn(Fn<T,F> fn,
                                        ColumFunction columFunction)

orNotIn

public <T,F> FunctionCondition orNotIn(Fn<T,F> fn,
                                       ColumFunction columFunction)

andMatches

public <T,F> FunctionCondition andMatches(Fn<T,F> fn,
                                          ColumFunction columFunction)

orMatches

public <T,F> FunctionCondition orMatches(Fn<T,F> fn,
                                         ColumFunction columFunction)

andFindInSet

public <T,F> FunctionCondition andFindInSet(Fn<T,F> fn,
                                            ColumFunction columFunction)

orFindInSet

public <T,F> FunctionCondition orFindInSet(Fn<T,F> fn,
                                           ColumFunction columFunction)

andEqualTo

public <T,F> NestedCondition andEqualTo(Fn<T,F> fn,
                                        Consumer<AbstractColumnReference> nestedSelect)

orEqualTo

public <T,F> NestedCondition orEqualTo(Fn<T,F> fn,
                                       Consumer<AbstractColumnReference> nestedSelect)

andNotEqualTo

public <T,F> NestedCondition andNotEqualTo(Fn<T,F> fn,
                                           Consumer<AbstractColumnReference> nestedSelect)

orNotEqualTo

public <T,F> NestedCondition orNotEqualTo(Fn<T,F> fn,
                                          Consumer<AbstractColumnReference> nestedSelect)

andGreaterThan

public <T,F> NestedCondition andGreaterThan(Fn<T,F> fn,
                                            Consumer<AbstractColumnReference> nestedSelect)

orGreaterThan

public <T,F> NestedCondition orGreaterThan(Fn<T,F> fn,
                                           Consumer<AbstractColumnReference> nestedSelect)

andGreaterThanOrEqualTo

public <T,F> NestedCondition andGreaterThanOrEqualTo(Fn<T,F> fn,
                                                     Consumer<AbstractColumnReference> nestedSelect)

orGreaterThanOrEqualTo

public <T,F> NestedCondition orGreaterThanOrEqualTo(Fn<T,F> fn,
                                                    Consumer<AbstractColumnReference> nestedSelect)

andLessThan

public <T,F> NestedCondition andLessThan(Fn<T,F> fn,
                                         Consumer<AbstractColumnReference> nestedSelect)

orLessThan

public <T,F> NestedCondition orLessThan(Fn<T,F> fn,
                                        Consumer<AbstractColumnReference> nestedSelect)

andLessThanOrEqualTo

public <T,F> NestedCondition andLessThanOrEqualTo(Fn<T,F> fn,
                                                  Consumer<AbstractColumnReference> nestedSelect)

orLessThanOrEqualTo

public <T,F> NestedCondition orLessThanOrEqualTo(Fn<T,F> fn,
                                                 Consumer<AbstractColumnReference> nestedSelect)

andIn

public <T,F> NestedCondition andIn(Fn<T,F> fn,
                                   Consumer<AbstractColumnReference> nestedSelect)

orIn

public <T,F> NestedCondition orIn(Fn<T,F> fn,
                                  Consumer<AbstractColumnReference> nestedSelect)

andNotIn

public <T,F> NestedCondition andNotIn(Fn<T,F> fn,
                                      Consumer<AbstractColumnReference> nestedSelect)

orNotIn

public <T,F> NestedCondition orNotIn(Fn<T,F> fn,
                                     Consumer<AbstractColumnReference> nestedSelect)

andExists

public NestedCondition andExists(Consumer<AbstractColumnReference> nestedSelect)

orExists

public NestedCondition orExists(Consumer<AbstractColumnReference> nestedSelect)

andNotExists

public NestedCondition andNotExists(Consumer<AbstractColumnReference> nestedSelect)

orNotExists

public NestedCondition orNotExists(Consumer<AbstractColumnReference> nestedSelect)

andCondition

public Condition andCondition(Consumer<Condition> nestedCondition)

从接口复制的说明: Condition

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

该方法允许将一组条件作为当前条件的子条件进行添加，并且将它们合并为一个结果。 其中传入的 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 实例，以便实现链式调用

orCondition

public Condition orCondition(Consumer<Condition> nestedCondition)

从接口复制的说明: Condition

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

参数:

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

返回:

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

另请参阅:

this#andCondition(Consumer)

andEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

andEqualTo

public Condition andEqualTo(Column column,
                            Object value)

andEqualTo

public <T1,T2,F> Condition andEqualTo(Fn<T1,F> field1,
                                      Fn<T2,F> field2)

从接口复制的说明: Condition

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

     on.andEqualTo(Student::getClassId, Class::getId);
 

这将会生成 SQL 中的 "ON Student.classId = Class.id" 条件。

类型参数:

T1 - 第一个实体类类型

T2 - 第二个实体类类型

F - 字段类型

参数:

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

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

返回:

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

orEqualTo

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

从接口复制的说明: Condition

添加等于条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andNotEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

andNotEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orNotEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orNotEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andIsNull

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 Condition 实例

orIsNull

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 Condition 实例

andIsNotNull

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 Condition 实例

orIsNotNull

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 Condition 实例

andGreaterThan

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

andGreaterThan

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orGreaterThan

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orGreaterThan

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andGreaterThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

andGreaterThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orGreaterThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orGreaterThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andLessThan

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

andLessThan

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orLessThan

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orLessThan

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andLessThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

andLessThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orLessThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 Condition 实例

orLessThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andIn

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 Condition 实例

andIn

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

orIn

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 Condition 实例

andNotIn

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 Condition 实例

orNotIn

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 Condition 实例

andBetween

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

andBetween

public <T1,T2,F> Condition andBetween(Fn<T1,F> field1,
                                      Fn<T2,F> startField,
                                      Fn<T2,F> endField)

从接口复制的说明: Condition

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

orBetween

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

orBetween

public <T1,T2,F> Condition orBetween(Fn<T1,F> field1,
                                     Fn<T2,F> startField,
                                     Fn<T2,F> endField)

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

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

返回:

当前 Condition 实例

另请参阅:

this#andBetween(Fn, Fn, Fn)

andNotBetween

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

orNotBetween

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 Condition 实例

andLike

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orLike

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andNotLike

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orNotLike

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andMatches

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

regex - 正则表达式模式

返回:

当前 Condition 实例

orMatches

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

regex - 正则表达式模式

返回:

当前 Condition 实例

andFindInSet

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

返回:

当前 Condition 实例

orFindInSet

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

返回:

当前 Condition 实例

andFindInSet

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

separator - 分隔符

返回:

当前 Condition 实例

orFindInSet

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

separator - 分隔符

返回:

当前 Condition 实例

limit

public Condition limit(int offset,
                       int limit)

从接口复制的说明: Condition

限制查询结果的返回行数

参数:

offset - 需要跳过的行数

limit - 返回的最大行数

返回:

当前 Condition 实例

limit

public Condition limit(int limit)

从接口复制的说明: Condition

限制查询结果的返回行数

参数:

limit - 返回的最大行数

返回:

当前 Condition 实例

getWhereConditionSyntax

public String getWhereConditionSyntax()

getParameterBinder

public ParameterBinder getParameterBinder()

logicalOperatorType

protected String logicalOperatorType(LogicalOperatorType logicalOperatorType)

logicalOperatorType

protected String logicalOperatorType(LogicalOperatorType logicalOperatorType,
                                     SqlDialect sqlDialect)

首次连接时才会去拼接 and 或者 or

andEqualTo

public HavingCondition andEqualTo(AggregateFunction function,
                                  Object value)

andEqualTo

public HavingCondition andEqualTo(AggregateFunction function,
                                  Consumer<AbstractColumnReference> nestedSelect)

orEqualTo

public HavingCondition orEqualTo(AggregateFunction function,
                                 Object value)

orEqualTo

public HavingCondition orEqualTo(AggregateFunction function,
                                 Consumer<AbstractColumnReference> nestedSelect)

andNotEqualTo

public HavingCondition andNotEqualTo(AggregateFunction function,
                                     Object value)

andNotEqualTo

public HavingCondition andNotEqualTo(AggregateFunction function,
                                     Consumer<AbstractColumnReference> nestedSelect)

orNotEqualTo

public HavingCondition orNotEqualTo(AggregateFunction function,
                                    Object value)

orNotEqualTo

public HavingCondition orNotEqualTo(AggregateFunction function,
                                    Consumer<AbstractColumnReference> nestedSelect)

andGreaterThan

public HavingCondition andGreaterThan(AggregateFunction function,
                                      Object value)

andGreaterThan

public HavingCondition andGreaterThan(AggregateFunction function,
                                      Consumer<AbstractColumnReference> nestedSelect)

orGreaterThan

public HavingCondition orGreaterThan(AggregateFunction function,
                                     Object value)

orGreaterThan

public HavingCondition orGreaterThan(AggregateFunction function,
                                     Consumer<AbstractColumnReference> nestedSelect)

andGreaterThanOrEqualTo

public HavingCondition andGreaterThanOrEqualTo(AggregateFunction function,
                                               Object value)

andGreaterThanOrEqualTo

public HavingCondition andGreaterThanOrEqualTo(AggregateFunction function,
                                               Consumer<AbstractColumnReference> nestedSelect)

orGreaterThanOrEqualTo

public HavingCondition orGreaterThanOrEqualTo(AggregateFunction function,
                                              Object value)

orGreaterThanOrEqualTo

public HavingCondition orGreaterThanOrEqualTo(AggregateFunction function,
                                              Consumer<AbstractColumnReference> nestedSelect)

andLessThan

public HavingCondition andLessThan(AggregateFunction function,
                                   Object value)

andLessThan

public HavingCondition andLessThan(AggregateFunction function,
                                   Consumer<AbstractColumnReference> nestedSelect)

orLessThan

public HavingCondition orLessThan(AggregateFunction function,
                                  Object value)

orLessThan

public HavingCondition orLessThan(AggregateFunction function,
                                  Consumer<AbstractColumnReference> nestedSelect)

andLessThanOrEqualTo

public HavingCondition andLessThanOrEqualTo(AggregateFunction function,
                                            Object value)

andLessThanOrEqualTo

public HavingCondition andLessThanOrEqualTo(AggregateFunction function,
                                            Consumer<AbstractColumnReference> nestedSelect)

orLessThanOrEqualTo

public HavingCondition orLessThanOrEqualTo(AggregateFunction function,
                                           Object value)

orLessThanOrEqualTo

public HavingCondition orLessThanOrEqualTo(AggregateFunction function,
                                           Consumer<AbstractColumnReference> nestedSelect)

andIn

public HavingCondition andIn(AggregateFunction function,
                             Iterable<?> values)

andIn

public HavingCondition andIn(AggregateFunction function,
                             Consumer<AbstractColumnReference> nestedSelect)

orIn

public HavingCondition orIn(AggregateFunction function,
                            Iterable<?> values)

orIn

public HavingCondition orIn(AggregateFunction function,
                            Consumer<AbstractColumnReference> nestedSelect)

andNotIn

public HavingCondition andNotIn(AggregateFunction function,
                                Iterable<?> values)

andNotIn

public HavingCondition andNotIn(AggregateFunction function,
                                Consumer<AbstractColumnReference> nestedSelect)

orNotIn

public HavingCondition orNotIn(AggregateFunction function,
                               Iterable<?> values)

orNotIn

public HavingCondition orNotIn(AggregateFunction function,
                               Consumer<AbstractColumnReference> nestedSelect)

andBetween

public HavingCondition andBetween(AggregateFunction function,
                                  Object start,
                                  Object end)

orBetween

public HavingCondition orBetween(AggregateFunction function,
                                 Object start,
                                 Object end)

andNotBetween

public HavingCondition andNotBetween(AggregateFunction function,
                                     Object start,
                                     Object end)

orNotBetween

public HavingCondition orNotBetween(AggregateFunction function,
                                    Object start,
                                    Object end)

executeFunctionToString

protected String executeFunctionToString(AggregateFunction function)

sqlDialect

protected SqlDialect sqlDialect()