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

类 GenericWhereCondition

java.lang.Object

com.dynamic.sql.core.condition.WhereCondition<GenericWhereCondition>

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

所有已实现的接口:

Condition<GenericWhereCondition>, FunctionCondition<GenericWhereCondition>, NestedCondition<GenericWhereCondition>, HavingCondition<GenericWhereCondition>

直接已知子类:

MysqlWhereCondition, OracleWhereCondition

public class GenericWhereCondition
extends WhereCondition<GenericWhereCondition>

字段概要

字段

限定符和类型	字段和说明
protected Map<String,TableAliasMapping>	aliasTableMap TODO 把这个抽成一个类，用来管理别名和表的映射关系 别名-表映射 1、** 表示如果没有别名则使用该表 2、*** 表示如果有没有别名都强制使用该表
protected StringBuilder	condition
protected String	dataSourceName
protected boolean	isFirstBuild
protected ParameterBinder	parameterBinder
protected SqlExecuteType	sqlExecuteType
protected Version	version

构造器概要

构造器

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

方法概要

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

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

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

从接口继承的方法 com.dynamic.sql.core.condition.NestedCondition

andEqualTo, andExists, andGreaterThan, andGreaterThanOrEqualTo, andIn, andLessThan, andLessThanOrEqualTo, andNotEqualTo, andNotExists, andNotIn, orEqualTo, orExists, orGreaterThan, orGreaterThanOrEqualTo, orIn, orLessThan, orLessThanOrEqualTo, orNotEqualTo, orNotExists, orNotIn

从接口继承的方法 com.dynamic.sql.core.condition.Condition

andBetween, andBetween, andBetween, andCondition, andEqualTo, andEqualTo, andEqualTo, andEqualTo, andEqualTo, andFindInSet, andFindInSet, andFindInSet, andFunction, andGreaterThan, andGreaterThan, andGreaterThan, andGreaterThan, andGreaterThan, andGreaterThanOrEqualTo, andGreaterThanOrEqualTo, andGreaterThanOrEqualTo, andGreaterThanOrEqualTo, andIn, andIn, andIn, andIsNotNull, andIsNotNull, andIsNotNull, andIsNull, andIsNull, andIsNull, andLessThan, andLessThan, andLessThan, andLessThan, andLessThanOrEqualTo, andLessThanOrEqualTo, andLessThanOrEqualTo, andLessThanOrEqualTo, andLike, andLike, andMatches, andMatches, andNotBetween, andNotBetween, andNotEqualTo, andNotEqualTo, andNotEqualTo, andNotEqualTo, andNotEqualTo, andNotIn, andNotIn, andNotLike, andNotLike, limit, limit, orBetween, orBetween, orBetween, orCondition, orEqualTo, orEqualTo, orEqualTo, orEqualTo, orEqualTo, orFindInSet, orFindInSet, orFindInSet, orFunction, orGreaterThan, orGreaterThan, orGreaterThan, orGreaterThan, orGreaterThan, orGreaterThanOrEqualTo, orGreaterThanOrEqualTo, orGreaterThanOrEqualTo, orGreaterThanOrEqualTo, orIn, orIn, orIsNotNull, orIsNotNull, orIsNotNull, orIsNull, orIsNull, orIsNull, orLessThan, orLessThan, orLessThan, orLessThan, orLessThanOrEqualTo, orLessThanOrEqualTo, orLessThanOrEqualTo, orLessThanOrEqualTo, orLike, orLike, orMatches, orMatches, orNotBetween, orNotBetween, orNotEqualTo, orNotEqualTo, orNotEqualTo, orNotEqualTo, orNotEqualTo, orNotIn, orNotIn, orNotLike, orNotLike, self

字段详细资料

version

protected final Version version

aliasTableMap

protected final Map<String,TableAliasMapping> aliasTableMap

TODO 把这个抽成一个类，用来管理别名和表的映射关系 别名-表映射 1、** 表示如果没有别名则使用该表 2、*** 表示如果有没有别名都强制使用该表

condition

protected final StringBuilder condition

parameterBinder

protected final ParameterBinder parameterBinder

dataSourceName

protected String dataSourceName

isFirstBuild

protected boolean isFirstBuild

sqlExecuteType

protected SqlExecuteType sqlExecuteType

构造器详细资料

GenericWhereCondition

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

方法详细资料

andEqualTo

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

andEqualTo

public GenericWhereCondition andEqualTo(Object value,
                                        ColumFunction columFunction)

orEqualTo

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

orEqualTo

public GenericWhereCondition orEqualTo(Object value,
                                       ColumFunction columFunction)

andNotEqualTo

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

orNotEqualTo

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

andGreaterThan

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

orGreaterThan

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

andGreaterThanOrEqualTo

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

orGreaterThanOrEqualTo

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

andLessThan

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

orLessThan

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

andLessThanOrEqualTo

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

orLessThanOrEqualTo

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

andIn

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

orIn

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

andNotIn

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

orNotIn

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

andMatches

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

orMatches

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

andFindInSet

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

orFindInSet

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

andEqualTo

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

从接口复制的说明: NestedCondition

添加等于条件，并且运算，右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

orEqualTo

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

从接口复制的说明: NestedCondition

添加等于条件（OR 运算），右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

andNotEqualTo

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

从接口复制的说明: NestedCondition

添加不等于条件，并且运算，右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

orNotEqualTo

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

从接口复制的说明: NestedCondition

添加不等于条件（OR 运算），右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

andGreaterThan

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

从接口复制的说明: NestedCondition

添加大于条件，并且运算，右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

orGreaterThan

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

从接口复制的说明: NestedCondition

添加大于条件（OR 运算），右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

andGreaterThanOrEqualTo

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

从接口复制的说明: NestedCondition

添加大于等于条件，并且运算，右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

orGreaterThanOrEqualTo

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

从接口复制的说明: NestedCondition

添加大于等于条件（OR 运算），右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

andLessThan

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

从接口复制的说明: NestedCondition

添加小于条件，并且运算，右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

orLessThan

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

从接口复制的说明: NestedCondition

添加小于条件（OR 运算），右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

andLessThanOrEqualTo

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

从接口复制的说明: NestedCondition

添加小于等于条件，并且运算，右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

orLessThanOrEqualTo

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

从接口复制的说明: NestedCondition

添加小于等于条件（OR 运算），右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套查询构造器

返回:

当前 C 实例

andIn

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

从接口复制的说明: NestedCondition

添加 IN 条件，并且运算，右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套子查询构造器

返回:

当前 C 实例

orIn

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

从接口复制的说明: NestedCondition

添加 IN 条件（OR 运算），右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套子查询构造器

返回:

当前 C 实例

andNotIn

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

从接口复制的说明: NestedCondition

添加 NOT IN 条件，并且运算，右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套子查询构造器

返回:

当前 C 实例

orNotIn

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

从接口复制的说明: NestedCondition

添加 NOT IN 条件（OR 运算），右侧值来自嵌套查询。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

nestedSelect - 嵌套子查询构造器

返回:

当前 C 实例

andExists

public GenericWhereCondition andExists(Consumer<AbstractColumnReference> nestedSelect)

从接口复制的说明: NestedCondition

添加 EXISTS 条件，并且运算，判断子查询是否存在。

参数:

nestedSelect - 嵌套子查询构造器

返回:

当前 C 实例

orExists

public GenericWhereCondition orExists(Consumer<AbstractColumnReference> nestedSelect)

从接口复制的说明: NestedCondition

添加 EXISTS 条件（OR 运算），判断子查询是否存在。

参数:

nestedSelect - 嵌套子查询构造器

返回:

当前 C 实例

andNotExists

public GenericWhereCondition andNotExists(Consumer<AbstractColumnReference> nestedSelect)

从接口复制的说明: NestedCondition

添加 NOT EXISTS 条件，并且运算，判断子查询是否不存在。

参数:

nestedSelect - 嵌套子查询构造器

返回:

当前 C 实例

orNotExists

public GenericWhereCondition orNotExists(Consumer<AbstractColumnReference> nestedSelect)

从接口复制的说明: NestedCondition

添加 NOT EXISTS 条件（OR 运算），判断子查询是否不存在。

参数:

nestedSelect - 嵌套子查询构造器

返回:

当前 C 实例

andCondition

public GenericWhereCondition andCondition(Consumer<GenericWhereCondition> 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 GenericWhereCondition orCondition(Consumer<GenericWhereCondition> nestedCondition)

从接口复制的说明: Condition

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

参数:

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

返回:

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

另请参阅:

Condition.andCondition(Consumer)

andFunction

public GenericWhereCondition andFunction(ColumFunction columFunction)

从接口复制的说明: Condition

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

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

示例：查询指定的点是否包含在其中

     
         List<LocationEntity> list = sqlContext.select()
                 .allColumn()
                 .from(LocationEntity.class)
                 .where(whereCondition -> whereCondition.andFunction(new Contains(LocationEntity::getArea, new Point(5, 5))))
                 .fetch()
                 .toList();
         System.out.println(list.size());
     
 

参数:

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

返回:

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

orFunction

public GenericWhereCondition orFunction(ColumFunction columFunction)

从接口复制的说明: Condition

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

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

参数:

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

返回:

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

andEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andEqualTo

public GenericWhereCondition andEqualTo(Column column,
                                        Object value)

从接口复制的说明: Condition

追加等于运算。

参数:

column - 列对象

value - 匹配的值

返回:

当前 C 实例

andEqualTo

public GenericWhereCondition andEqualTo(Column column,
                                        Column column2)

从接口复制的说明: Condition

追加列间等于运算。

参数:

column - 左侧列对象

column2 - 右侧列对象

返回:

当前 C 实例

andEqualTo

public <T1,T2,F> GenericWhereCondition 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 实例，以便实现链式调用

andEqualTo

public GenericWhereCondition andEqualTo(ColumFunction columFunction,
                                        Object value)

orEqualTo

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

从接口复制的说明: Condition

添加等于条件，或运算。

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orEqualTo

public GenericWhereCondition orEqualTo(Column column,
                                       Object value)

orEqualTo

public GenericWhereCondition orEqualTo(Column column,
                                       Column column2)

orEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orEqualTo

public GenericWhereCondition orEqualTo(ColumFunction columFunction,
                                       Object value)

andNotEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andNotEqualTo

public GenericWhereCondition andNotEqualTo(Column column,
                                           Object value)

andNotEqualTo

public GenericWhereCondition andNotEqualTo(Column column,
                                           Column column2)

andNotEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andNotEqualTo

public GenericWhereCondition andNotEqualTo(ColumFunction columFunction,
                                           Object value)

orNotEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orNotEqualTo

public GenericWhereCondition orNotEqualTo(Column column,
                                          Object value)

orNotEqualTo

public GenericWhereCondition orNotEqualTo(Column column,
                                          Column column2)

orNotEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orNotEqualTo

public GenericWhereCondition orNotEqualTo(ColumFunction columFunction,
                                          Object value)

andIsNull

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 C 实例

andIsNull

public GenericWhereCondition andIsNull(Column column)

andIsNull

public GenericWhereCondition andIsNull(ColumFunction columFunction,
                                       Object value)

orIsNull

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 C 实例

orIsNull

public GenericWhereCondition orIsNull(ColumFunction columFunction,
                                      Object value)

orIsNull

public GenericWhereCondition orIsNull(Column column)

andIsNotNull

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 C 实例

andIsNotNull

public GenericWhereCondition andIsNotNull(ColumFunction columFunction,
                                          Object value)

andIsNotNull

public GenericWhereCondition andIsNotNull(Column column)

orIsNotNull

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

返回:

当前 C 实例

orIsNotNull

public GenericWhereCondition orIsNotNull(ColumFunction columFunction,
                                         Object value)

orIsNotNull

public GenericWhereCondition orIsNotNull(Column column)

andGreaterThan

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andGreaterThan

public GenericWhereCondition andGreaterThan(Column column,
                                            Object value)

andGreaterThan

public GenericWhereCondition andGreaterThan(Column column,
                                            Column column2)

andGreaterThan

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andGreaterThan

public GenericWhereCondition andGreaterThan(ColumFunction columFunction,
                                            Object value)

orGreaterThan

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orGreaterThan

public GenericWhereCondition orGreaterThan(Column column,
                                           Object value)

orGreaterThan

public GenericWhereCondition orGreaterThan(Column column,
                                           Column column2)

orGreaterThan

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orGreaterThan

public GenericWhereCondition orGreaterThan(ColumFunction columFunction,
                                           Object value)

andGreaterThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andGreaterThanOrEqualTo

public GenericWhereCondition andGreaterThanOrEqualTo(Column column,
                                                     Column column2)

andGreaterThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andGreaterThanOrEqualTo

public GenericWhereCondition andGreaterThanOrEqualTo(ColumFunction columFunction,
                                                     Object value)

orGreaterThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orGreaterThanOrEqualTo

public GenericWhereCondition orGreaterThanOrEqualTo(Column column,
                                                    Column column2)

orGreaterThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orGreaterThanOrEqualTo

public GenericWhereCondition orGreaterThanOrEqualTo(ColumFunction columFunction,
                                                    Object value)

andLessThan

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andLessThan

public GenericWhereCondition andLessThan(Column column,
                                         Column column2)

andLessThan

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

andLessThan

public GenericWhereCondition andLessThan(ColumFunction columFunction,
                                         Object value)

orLessThan

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orLessThan

public GenericWhereCondition orLessThan(Column column,
                                        Column column2)

orLessThan

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orLessThan

public GenericWhereCondition orLessThan(ColumFunction columFunction,
                                        Object value)

andLessThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

andLessThanOrEqualTo

public GenericWhereCondition andLessThanOrEqualTo(Column column,
                                                  Column column2)

andLessThanOrEqualTo

public GenericWhereCondition andLessThanOrEqualTo(ColumFunction columFunction,
                                                  Object value)

andLessThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orLessThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

value - 匹配的值

返回:

当前 C 实例

orLessThanOrEqualTo

public GenericWhereCondition orLessThanOrEqualTo(Column column,
                                                 Column column2)

orLessThanOrEqualTo

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

返回:

当前 Condition 实例

orLessThanOrEqualTo

public GenericWhereCondition orLessThanOrEqualTo(ColumFunction columFunction,
                                                 Object value)

andIn

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 C 实例

andIn

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

andIn

public GenericWhereCondition andIn(ColumFunction columFunction,
                                   Iterable<?> values)

orIn

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 C 实例

orIn

public GenericWhereCondition orIn(ColumFunction columFunction,
                                  Iterable<?> values)

andNotIn

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 C 实例

andNotIn

public GenericWhereCondition andNotIn(ColumFunction columFunction,
                                      Iterable<?> values)

orNotIn

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

values - 匹配的值集合

返回:

当前 C 实例

orNotIn

public GenericWhereCondition orNotIn(ColumFunction columFunction,
                                     Iterable<?> values)

andBetween

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

andBetween

public GenericWhereCondition andBetween(Column column,
                                        Object start,
                                        Object end)

andBetween

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

orBetween

public GenericWhereCondition orBetween(Column column,
                                       Object start,
                                       Object end)

orBetween

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

从接口复制的说明: Condition

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

类型参数:

T1 - 实体类类型1

T2 - 实体类类型2

F - 字段类型

参数:

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

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

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

返回:

当前 Condition 实例

另请参阅:

Condition.andBetween(Fn, Fn, Fn)

andNotBetween

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

andNotBetween

public GenericWhereCondition andNotBetween(Column column,
                                           Object start,
                                           Object end)

orNotBetween

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

start - 范围起始值

end - 范围结束值

返回:

当前 C 实例

orNotBetween

public GenericWhereCondition orNotBetween(Column column,
                                          Object start,
                                          Object end)

andLike

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 C 实例

andLike

public GenericWhereCondition andLike(Column column,
                                     Object value)

orLike

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 C 实例

orLike

public GenericWhereCondition orLike(Column column,
                                    Object value)

andNotLike

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 C 实例

andNotLike

public GenericWhereCondition andNotLike(Column column,
                                        Object value)

orNotLike

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

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

返回:

当前 C 实例

orNotLike

public GenericWhereCondition orNotLike(Column column,
                                       Object value)

andMatches

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

regex - 正则表达式模式

返回:

当前 C 实例

andMatches

public GenericWhereCondition andMatches(Column column,
                                        String regex)

orMatches

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

regex - 正则表达式模式

返回:

当前 C 实例

orMatches

public GenericWhereCondition orMatches(Column column,
                                       String regex)

andFindInSet

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

返回:

当前 C 实例

andFindInSet

public GenericWhereCondition andFindInSet(Column column,
                                          Object value)

orFindInSet

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

返回:

当前 C 实例

orFindInSet

public GenericWhereCondition orFindInSet(Column column,
                                         Object value)

andFindInSet

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

separator - 分隔符

返回:

当前 C 实例

orFindInSet

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

从接口复制的说明: Condition

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

类型参数:

T - 实体类类型

F - 字段类型

参数:

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

item - 指定的项目

separator - 分隔符

返回:

当前 C 实例

limit

public GenericWhereCondition limit(int offset,
                                   int limit)

从接口复制的说明: Condition

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

参数:

offset - 需要跳过的行数

limit - 返回的最大行数

返回:

当前 C 实例

limit

public GenericWhereCondition limit(int limit)

从接口复制的说明: Condition

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

参数:

limit - 返回的最大行数

返回:

当前 C 实例

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 GenericWhereCondition andEqualTo(AggregateFunction function,
                                        Object value)

andEqualTo

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

orEqualTo

public GenericWhereCondition orEqualTo(AggregateFunction function,
                                       Object value)

orEqualTo

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

andNotEqualTo

public GenericWhereCondition andNotEqualTo(AggregateFunction function,
                                           Object value)

andNotEqualTo

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

orNotEqualTo

public GenericWhereCondition orNotEqualTo(AggregateFunction function,
                                          Object value)

orNotEqualTo

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

andGreaterThan

public GenericWhereCondition andGreaterThan(AggregateFunction function,
                                            Object value)

andGreaterThan

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

orGreaterThan

public GenericWhereCondition orGreaterThan(AggregateFunction function,
                                           Object value)

orGreaterThan

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

andGreaterThanOrEqualTo

public GenericWhereCondition andGreaterThanOrEqualTo(AggregateFunction function,
                                                     Object value)

andGreaterThanOrEqualTo

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

orGreaterThanOrEqualTo

public GenericWhereCondition orGreaterThanOrEqualTo(AggregateFunction function,
                                                    Object value)

orGreaterThanOrEqualTo

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

andLessThan

public GenericWhereCondition andLessThan(AggregateFunction function,
                                         Object value)

andLessThan

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

orLessThan

public GenericWhereCondition orLessThan(AggregateFunction function,
                                        Object value)

orLessThan

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

andLessThanOrEqualTo

public GenericWhereCondition andLessThanOrEqualTo(AggregateFunction function,
                                                  Object value)

andLessThanOrEqualTo

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

orLessThanOrEqualTo

public GenericWhereCondition orLessThanOrEqualTo(AggregateFunction function,
                                                 Object value)

orLessThanOrEqualTo

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

andIn

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

andIn

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

orIn

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

orIn

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

andNotIn

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

andNotIn

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

orNotIn

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

orNotIn

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

andBetween

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

orBetween

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

andNotBetween

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

orNotBetween

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

sql

public GenericWhereCondition sql(String sql)

从类复制的说明: WhereCondition

拼接自定义 SQL 条件。

该方法用于插入无法通过已有 API 构建的原始 SQL 条件，常用于处理复杂逻辑、数据库函数、自定义分区截取等情况。

注意： 该方法不做 SQL 安全校验，需确保传入字符串是安全且语法正确的 SQL 片段。

指定者:

sql 在类中 WhereCondition<GenericWhereCondition>

参数:

sql - 自定义 SQL 条件表达式，例如 "and age > 18", "or row_num = 1", "exists (...)"

返回:

返回当前条件构造器对象，用于链式调用

executeFunctionToString

protected String executeFunctionToString(AggregateFunction function)

sqlDialect

protected SqlDialect sqlDialect()

setSqlExecuteType

public void setSqlExecuteType(SqlExecuteType sqlExecuteType)