CompareBuilder (ms-db 1.0.2 API)

java.lang.Object
- com.gitee.cardoon.ms.db.multiple.builder.Builder
- - com.gitee.cardoon.ms.db.multiple.builder.CompareBuilder

public class CompareBuilder
extends Builder

字段概要
- 从类继承的字段 com.gitee.cardoon.ms.db.multiple.builder.Builder
  end, parameter, querySqlList, start

构造器概要

构造器
构造器和说明

CompareBuilder()

构造器
构造器和说明
`CompareBuilder()`

方法概要

All Methods Instance Methods Concrete Methods
限定符和类型	方法和说明
`CompareBuilder`	`and()` 并且
`CompareBuilder`	`and(boolean condition)` 并且
`CompareBuilder`	`and(boolean condition, CompareBuilder builder)` 并且
`CompareBuilder`	`and(CompareBuilder builder)` 并且
`<T> CompareBuilder`	`between(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object leftValue, Object rightValue)` 在两者之间
`<T> CompareBuilder`	`between(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object leftValue, Object rightValue)` 在两者之间
`CompareBuilder`	`between(boolean condition, CompareBuilder builder, Object leftValue, Object rightValue)` 在两者之间
`<T> CompareBuilder`	`between(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object leftValue, Object rightValue)` 在两者之间
`<T> CompareBuilder`	`between(Class<T> tableNickName, SFunction<T,?> column, Object leftValue, Object rightValue)` 在两者之间
`CompareBuilder`	`between(CompareBuilder builder, Object leftValue, Object rightValue)` 在两者之间
`CompareBuilder`	`end()` end
`<T> CompareBuilder`	`eq(boolean condition, Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 相等
`<T> CompareBuilder`	`eq(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 相等
`<T> CompareBuilder`	`eq(boolean condition, Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 相等
`<T> CompareBuilder`	`eq(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 相等
`<T1,T2> CompareBuilder`	`eq(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 相等
`<T1,T2> CompareBuilder`	`eq(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 相等
`<T1,T2> CompareBuilder`	`eq(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 相等
`<T1,T2> CompareBuilder`	`eq(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 相等
`<T> CompareBuilder`	`eq(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 相等
`<T> CompareBuilder`	`eq(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 相等
`CompareBuilder`	`eq(boolean condition, CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 相等
`CompareBuilder`	`eq(boolean condition, CompareBuilder builder, Object value)` 相等
`<T> CompareBuilder`	`eq(Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 相等
`<T> CompareBuilder`	`eq(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 相等
`<T> CompareBuilder`	`eq(Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 相等
`<T> CompareBuilder`	`eq(Class<T> tableNickName, SFunction<T,?> column, Object value)` 相等
`<T1,T2> CompareBuilder`	`eq(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 相等
`<T1,T2> CompareBuilder`	`eq(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 相等
`<T1,T2> CompareBuilder`	`eq(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 相等
`<T1,T2> CompareBuilder`	`eq(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 相等
`<T> CompareBuilder`	`eq(CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 相等
`<T> CompareBuilder`	`eq(CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 相等
`CompareBuilder`	`eq(CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 相等
`CompareBuilder`	`eq(CompareBuilder builder, Object value)` 相等
`<T> CompareBuilder`	`exists(boolean condition, MultipleLambdaQueryWrapper<T> wrapper)` 存在
`<T> CompareBuilder`	`exists(MultipleLambdaQueryWrapper<T> wrapper)` 存在
`<T> CompareBuilder`	`ge(boolean condition, Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 大于等于
`<T> CompareBuilder`	`ge(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 大于等于
`<T> CompareBuilder`	`ge(boolean condition, Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 大于等于
`<T> CompareBuilder`	`ge(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 大于等于
`<T1,T2> CompareBuilder`	`ge(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 大于等于
`<T1,T2> CompareBuilder`	`ge(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 大于等于
`<T1,T2> CompareBuilder`	`ge(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 大于等于
`<T1,T2> CompareBuilder`	`ge(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 大于等于
`<T> CompareBuilder`	`ge(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 大于等于
`<T> CompareBuilder`	`ge(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 大于等于
`CompareBuilder`	`ge(boolean condition, CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 大于等于
`CompareBuilder`	`ge(boolean condition, CompareBuilder builder, Object value)` 大于等于
`<T> CompareBuilder`	`ge(Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 大于等于
`<T> CompareBuilder`	`ge(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 大于等于
`<T> CompareBuilder`	`ge(Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 大于等于
`<T> CompareBuilder`	`ge(Class<T> tableNickName, SFunction<T,?> column, Object value)` 大于等于
`<T1,T2> CompareBuilder`	`ge(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 大于等于
`<T1,T2> CompareBuilder`	`ge(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 大于等于
`<T1,T2> CompareBuilder`	`ge(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 大于等于
`<T1,T2> CompareBuilder`	`ge(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 大于等于
`<T> CompareBuilder`	`ge(CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 大于等于
`<T> CompareBuilder`	`ge(CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 大于等于
`CompareBuilder`	`ge(CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 大于等于
`CompareBuilder`	`ge(CompareBuilder builder, Object value)` 大于等于
`<T> CompareBuilder`	`gt(boolean condition, Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 大于
`<T> CompareBuilder`	`gt(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 大于
`<T> CompareBuilder`	`gt(boolean condition, Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 大于
`<T> CompareBuilder`	`gt(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 大于
`<T1,T2> CompareBuilder`	`gt(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 大于
`<T1,T2> CompareBuilder`	`gt(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 大于
`<T1,T2> CompareBuilder`	`gt(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 大于
`<T1,T2> CompareBuilder`	`gt(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 大于
`<T> CompareBuilder`	`gt(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 大于
`<T> CompareBuilder`	`gt(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 大于
`CompareBuilder`	`gt(boolean condition, CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 大于
`CompareBuilder`	`gt(boolean condition, CompareBuilder builder, Object value)` 大于
`<T> CompareBuilder`	`gt(Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 大于
`<T> CompareBuilder`	`gt(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 大于
`<T> CompareBuilder`	`gt(Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 大于
`<T> CompareBuilder`	`gt(Class<T> tableNickName, SFunction<T,?> column, Object value)` 大于
`<T1,T2> CompareBuilder`	`gt(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 大于
`<T1,T2> CompareBuilder`	`gt(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 大于
`<T1,T2> CompareBuilder`	`gt(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 大于
`<T1,T2> CompareBuilder`	`gt(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 大于
`<T> CompareBuilder`	`gt(CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 大于
`<T> CompareBuilder`	`gt(CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 大于
`CompareBuilder`	`gt(CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 大于
`CompareBuilder`	`gt(CompareBuilder builder, Object value)` 大于
`<T> CompareBuilder`	`in(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Collection<?> value)` 在范围内
`<T> CompareBuilder`	`in(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Collection<?> value)` 在范围内
`CompareBuilder`	`in(boolean condition, CompareBuilder builder, Collection<?> value)` 在范围内
`<T> CompareBuilder`	`in(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Collection<?> value)` 在范围内
`<T> CompareBuilder`	`in(Class<T> tableNickName, SFunction<T,?> column, Collection<?> value)` 在范围内
`CompareBuilder`	`in(CompareBuilder builder, Collection<?> value)` 不在范围内
`<T> CompareBuilder`	`isNotNull(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column)` 不为空
`<T> CompareBuilder`	`isNotNull(boolean condition, Class<T> tableNickName, SFunction<T,?> column)` 不为空
`CompareBuilder`	`isNotNull(boolean condition, CompareBuilder builder)` 不为空
`<T> CompareBuilder`	`isNotNull(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column)` 不为空
`<T> CompareBuilder`	`isNotNull(Class<T> tableNickName, SFunction<T,?> column)` 不为空
`CompareBuilder`	`isNotNull(CompareBuilder builder)` 不为空
`<T> CompareBuilder`	`isNull(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column)` 空
`<T> CompareBuilder`	`isNull(boolean condition, Class<T> tableNickName, SFunction<T,?> column)` 空
`CompareBuilder`	`isNull(boolean condition, CompareBuilder builder)` 空
`<T> CompareBuilder`	`isNull(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column)` 空
`<T> CompareBuilder`	`isNull(Class<T> tableNickName, SFunction<T,?> column)` 空
`CompareBuilder`	`isNull(CompareBuilder builder)` 空
`<T> CompareBuilder`	`le(boolean condition, Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 小于等于
`<T> CompareBuilder`	`le(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 小于等于
`<T> CompareBuilder`	`le(boolean condition, Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 小于等于
`<T> CompareBuilder`	`le(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 小于等于
`<T1,T2> CompareBuilder`	`le(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 小于等于
`<T1,T2> CompareBuilder`	`le(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 小于等于
`<T1,T2> CompareBuilder`	`le(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 小于等于
`<T1,T2> CompareBuilder`	`le(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 小于等于
`<T> CompareBuilder`	`le(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 小于等于
`<T> CompareBuilder`	`le(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 小于等于
`CompareBuilder`	`le(boolean condition, CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 小于等于
`CompareBuilder`	`le(boolean condition, CompareBuilder builder, Object value)` 小于等于
`<T> CompareBuilder`	`le(Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 小于等于
`<T> CompareBuilder`	`le(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 小于等于
`<T> CompareBuilder`	`le(Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 小于等于
`<T> CompareBuilder`	`le(Class<T> tableNickName, SFunction<T,?> column, Object value)` 小于等于
`<T1,T2> CompareBuilder`	`le(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 小于等于
`<T1,T2> CompareBuilder`	`le(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 小于等于
`<T1,T2> CompareBuilder`	`le(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 小于等于
`<T1,T2> CompareBuilder`	`le(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 小于等于
`<T> CompareBuilder`	`le(CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 小于等于
`<T> CompareBuilder`	`le(CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 小于等于
`CompareBuilder`	`le(CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 小于等于
`CompareBuilder`	`le(CompareBuilder builder, Object value)` 小于等于
`<T> CompareBuilder`	`like(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 模糊
`<T> CompareBuilder`	`like(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 模糊
`CompareBuilder`	`like(boolean condition, CompareBuilder builder, Object value)` 模糊
`<T> CompareBuilder`	`like(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 模糊
`<T> CompareBuilder`	`like(Class<T> tableNickName, SFunction<T,?> column, Object value)` 模糊
`CompareBuilder`	`like(CompareBuilder builder, Object value)` 模糊
`<T> CompareBuilder`	`likeLeft(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 从左模糊查询
`<T> CompareBuilder`	`likeLeft(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 从左模糊查询
`CompareBuilder`	`likeLeft(boolean condition, CompareBuilder builder, Object value)` 从左模糊查询
`<T> CompareBuilder`	`likeLeft(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 从左模糊查询
`<T> CompareBuilder`	`likeLeft(Class<T> tableNickName, SFunction<T,?> column, Object value)` 从左模糊查询
`CompareBuilder`	`likeLeft(CompareBuilder builder, Object value)` 不在从左模糊查询
`<T> CompareBuilder`	`likeRight(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 从右模糊查询
`<T> CompareBuilder`	`likeRight(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 从右模糊查询
`CompareBuilder`	`likeRight(boolean condition, CompareBuilder builder, Object value)` 从右模糊查询
`<T> CompareBuilder`	`likeRight(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 从右模糊查询
`<T> CompareBuilder`	`likeRight(Class<T> tableNickName, SFunction<T,?> column, Object value)` 从右模糊查询
`CompareBuilder`	`likeRight(CompareBuilder builder, Object value)` 从右模糊查询
`<T> CompareBuilder`	`lt(boolean condition, Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 小于
`<T> CompareBuilder`	`lt(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 小于
`<T> CompareBuilder`	`lt(boolean condition, Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 小于
`<T> CompareBuilder`	`lt(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 小于
`<T1,T2> CompareBuilder`	`lt(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 小于
`<T1,T2> CompareBuilder`	`lt(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 小于
`<T1,T2> CompareBuilder`	`lt(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 小于
`<T1,T2> CompareBuilder`	`lt(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 小于
`<T> CompareBuilder`	`lt(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 小于
`<T> CompareBuilder`	`lt(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 小于
`CompareBuilder`	`lt(boolean condition, CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 小于
`CompareBuilder`	`lt(boolean condition, CompareBuilder builder, Object value)` 小于
`<T> CompareBuilder`	`lt(Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 小于
`<T> CompareBuilder`	`lt(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 小于
`<T> CompareBuilder`	`lt(Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 小于
`<T> CompareBuilder`	`lt(Class<T> tableNickName, SFunction<T,?> column, Object value)` 小于
`<T1,T2> CompareBuilder`	`lt(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 小于
`<T1,T2> CompareBuilder`	`lt(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 小于
`<T1,T2> CompareBuilder`	`lt(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 小于
`<T1,T2> CompareBuilder`	`lt(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 小于
`<T> CompareBuilder`	`lt(CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 小于
`<T> CompareBuilder`	`lt(CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 小于
`CompareBuilder`	`lt(CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 小于
`CompareBuilder`	`lt(CompareBuilder builder, Object value)` 小于
`<T> CompareBuilder`	`ne(boolean condition, Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 不等
`<T> CompareBuilder`	`ne(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 不等
`<T> CompareBuilder`	`ne(boolean condition, Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 不等
`<T> CompareBuilder`	`ne(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 不等
`<T1,T2> CompareBuilder`	`ne(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 不等
`<T1,T2> CompareBuilder`	`ne(boolean condition, Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 不等
`<T1,T2> CompareBuilder`	`ne(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 不等
`<T1,T2> CompareBuilder`	`ne(boolean condition, Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 不等
`<T> CompareBuilder`	`ne(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 不等
`<T> CompareBuilder`	`ne(boolean condition, CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 不等
`CompareBuilder`	`ne(boolean condition, CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 不等
`CompareBuilder`	`ne(boolean condition, CompareBuilder builder, Object value)` 不等
`<T> CompareBuilder`	`ne(Class<T> leftTableNickName, Integer leftTableNickIndex, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 不等
`<T> CompareBuilder`	`ne(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 不等
`<T> CompareBuilder`	`ne(Class<T> leftTableNickName, SFunction<T,?> leftColumn, CompareBuilder rightBuilder)` 不等
`<T> CompareBuilder`	`ne(Class<T> tableNickName, SFunction<T,?> column, Object value)` 不等
`<T1,T2> CompareBuilder`	`ne(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 不等
`<T1,T2> CompareBuilder`	`ne(Class<T1> leftTableNickName, Integer leftTableNickIndex, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 不等
`<T1,T2> CompareBuilder`	`ne(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, Integer rightTableNickIndex, SFunction<T2,?> rightColumn)` 不等
`<T1,T2> CompareBuilder`	`ne(Class<T1> leftTableNickName, SFunction<T1,?> leftColumn, Class<T2> rightTableNickName, SFunction<T2,?> rightColumn)` 不等
`<T> CompareBuilder`	`ne(CompareBuilder leftBuilder, Class<T> rightTableNickName, Integer rightTableNickIndex, SFunction<T,?> rightColumn)` 不等
`<T> CompareBuilder`	`ne(CompareBuilder leftBuilder, Class<T> rightTableNickName, SFunction<T,?> rightColumn)` 不等
`CompareBuilder`	`ne(CompareBuilder leftBuilder, CompareBuilder rightBuilder)` 不等
`CompareBuilder`	`ne(CompareBuilder builder, Object value)` 不等
`<T> CompareBuilder`	`notBetween(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object leftValue, Object rightValue)` 不在两者之间
`<T> CompareBuilder`	`notBetween(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object leftValue, Object rightValue)` 不在两者之间
`CompareBuilder`	`notBetween(boolean condition, CompareBuilder builder, Object leftValue, Object rightValue)` 不在两者之间
`<T> CompareBuilder`	`notBetween(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object leftValue, Object rightValue)` 不在两者之间
`<T> CompareBuilder`	`notBetween(Class<T> tableNickName, SFunction<T,?> column, Object leftValue, Object rightValue)` 不在两者之间
`CompareBuilder`	`notBetween(CompareBuilder builder, Object leftValue, Object rightValue)` 不在两者之间
`<T> CompareBuilder`	`notExists(boolean condition, MultipleLambdaQueryWrapper<T> wrapper)` 不存在
`<T> CompareBuilder`	`notExists(MultipleLambdaQueryWrapper<T> wrapper)` 不存在
`<T> CompareBuilder`	`notIn(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Collection<?> value)` 不在范围内
`<T> CompareBuilder`	`notIn(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Collection<?> value)` 不在范围内
`CompareBuilder`	`notIn(boolean condition, CompareBuilder builder, Collection<?> value)` 不在范围内
`<T> CompareBuilder`	`notIn(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Collection<?> value)` 不在范围内
`<T> CompareBuilder`	`notIn(Class<T> tableNickName, SFunction<T,?> column, Collection<?> value)` 不在范围内
`CompareBuilder`	`notIn(CompareBuilder builder, Collection<?> value)` 空
`<T> CompareBuilder`	`notLike(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 不在模糊范围内
`<T> CompareBuilder`	`notLike(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 不在模糊范围内
`CompareBuilder`	`notLike(boolean condition, CompareBuilder builder, Object value)` 不在模糊范围内
`<T> CompareBuilder`	`notLike(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 不在模糊范围内
`<T> CompareBuilder`	`notLike(Class<T> tableNickName, SFunction<T,?> column, Object value)` 不在模糊范围内
`CompareBuilder`	`notLike(CompareBuilder builder, Object value)` 不在模糊范围内
`<T> CompareBuilder`	`notLikeLeft(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 不在从左模糊查询
`<T> CompareBuilder`	`notLikeLeft(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 不在从左模糊查询
`CompareBuilder`	`notLikeLeft(boolean condition, CompareBuilder builder, Object value)` 不在从左模糊查询
`<T> CompareBuilder`	`notLikeLeft(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 不在从左模糊查询
`<T> CompareBuilder`	`notLikeLeft(Class<T> tableNickName, SFunction<T,?> column, Object value)` 不在从左模糊查询
`CompareBuilder`	`notLikeLeft(CompareBuilder builder, Object value)` 不在从左模糊查询
`<T> CompareBuilder`	`notLikeRight(boolean condition, Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 不在从右模糊查询
`<T> CompareBuilder`	`notLikeRight(boolean condition, Class<T> tableNickName, SFunction<T,?> column, Object value)` 不在从右模糊查询
`CompareBuilder`	`notLikeRight(boolean condition, CompareBuilder builder, Object value)` 不在从右模糊查询
`<T> CompareBuilder`	`notLikeRight(Class<T> tableNickName, Integer tableNickIndex, SFunction<T,?> column, Object value)` 不在从右模糊查询
`<T> CompareBuilder`	`notLikeRight(Class<T> tableNickName, SFunction<T,?> column, Object value)` 不在从右模糊查询
`CompareBuilder`	`notLikeRight(CompareBuilder builder, Object value)` 在范围内
`CompareBuilder`	`or()` 或者
`CompareBuilder`	`or(boolean condition)` 或者
`CompareBuilder`	`or(boolean condition, CompareBuilder builder)` 或者
`CompareBuilder`	`or(CompareBuilder builder)` 或者
`CompareBuilder`	`otherwise(Object value)` else
`CompareBuilder`	`when(CompareBuilder builder, Object value)` when

从类继承的方法 com.gitee.cardoon.ms.db.multiple.builder.Builder
andSql, andSql, betweenSql, betweenSql, compare, condition, endSql, eqSql, eqSql, eqSql, eqSql, eqSql, eqSql, existsSql, funcSql, geSql, geSql, geSql, geSql, geSql, geSql, getParameter, getQuerySql, getQuerySqlList, gtSql, gtSql, gtSql, gtSql, gtSql, gtSql, inSql, inSql, isNotNullSql, isNotNullSql, isNullSql, isNullSql, leSql, leSql, leSql, leSql, leSql, leSql, likeLeftSql, likeLeftSql, likeRightSql, likeRightSql, likeSql, likeSql, ltSql, ltSql, ltSql, ltSql, ltSql, ltSql, neSql, neSql, neSql, neSql, neSql, neSql, notBetweenSql, notBetweenSql, notExistsSql, notInSql, notInSql, notLikeLeftSql, notLikeLeftSql, notLikeRightSql, notLikeRightSql, notLikeSql, notLikeSql, orSql, orSql, otherwiseSql, whenSql

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

构造器详细资料
- CompareBuilder
```
public CompareBuilder()
```

方法详细资料

when

public CompareBuilder when(CompareBuilder builder,
                           Object value)

when

参数:: builder -; value -
返回:

otherwise

public CompareBuilder otherwise(Object value)

else

参数:: value -
返回:

end
```
public CompareBuilder end()
```
end

返回:

eq

public <T> CompareBuilder eq(boolean condition,
                             Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

相等

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

eq

public <T> CompareBuilder eq(boolean condition,
                             Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

相等

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

eq

public CompareBuilder eq(boolean condition,
                         CompareBuilder builder,
                         Object value)

相等

参数:: condition -; builder -; value -
返回:

eq

public <T1,T2> CompareBuilder eq(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

相等

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

eq

public <T1,T2> CompareBuilder eq(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

相等

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

eq

public <T1,T2> CompareBuilder eq(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

相等

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

eq

public <T1,T2> CompareBuilder eq(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

相等

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

eq

public <T> CompareBuilder eq(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

相等

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

eq

public <T> CompareBuilder eq(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

相等

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightColumn -
返回:

eq

public <T> CompareBuilder eq(boolean condition,
                             Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

相等

类型参数:: T -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

eq

public <T> CompareBuilder eq(boolean condition,
                             Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

相等

类型参数:: T -
参数:: condition -; leftTableNickName -; leftColumn -; rightBuilder -
返回:

eq

public CompareBuilder eq(boolean condition,
                         CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

相等

参数:: condition -; leftBuilder -; rightBuilder -
返回:

eq

public <T> CompareBuilder eq(Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

相等

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

eq

public <T> CompareBuilder eq(Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

相等

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

eq

public CompareBuilder eq(CompareBuilder builder,
                         Object value)

相等

参数:: builder -; value -
返回:

eq

public <T1,T2> CompareBuilder eq(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

相等

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

eq

public <T1,T2> CompareBuilder eq(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

相等

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

eq

public <T1,T2> CompareBuilder eq(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

相等

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

eq

public <T1,T2> CompareBuilder eq(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

相等

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

eq

public <T> CompareBuilder eq(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

相等

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

eq

public <T> CompareBuilder eq(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

相等

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightColumn -
返回:

eq

public <T> CompareBuilder eq(Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

相等

类型参数:: T -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

eq

public <T> CompareBuilder eq(Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

相等

类型参数:: T -
参数:: leftTableNickName -; leftColumn -; rightBuilder -
返回:

eq

public CompareBuilder eq(CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

相等

参数:: leftBuilder -; rightBuilder -
返回:

ne

public <T> CompareBuilder ne(boolean condition,
                             Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

不等

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

ne

public <T> CompareBuilder ne(boolean condition,
                             Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

不等

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

ne

public CompareBuilder ne(boolean condition,
                         CompareBuilder builder,
                         Object value)

不等

参数:: condition -; builder -; value -
返回:

ne

public <T1,T2> CompareBuilder ne(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

不等

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

ne

public <T1,T2> CompareBuilder ne(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

不等

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ne

public <T1,T2> CompareBuilder ne(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

不等

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ne

public <T1,T2> CompareBuilder ne(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

不等

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

ne

public <T> CompareBuilder ne(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

不等

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ne

public <T> CompareBuilder ne(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

不等

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightColumn -
返回:

ne

public <T> CompareBuilder ne(boolean condition,
                             Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

不等

类型参数:: T -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

ne

public <T> CompareBuilder ne(boolean condition,
                             Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

不等

类型参数:: T -
参数:: condition -; leftTableNickName -; leftColumn -; rightBuilder -
返回:

ne

public CompareBuilder ne(boolean condition,
                         CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

不等

参数:: condition -; leftBuilder -; rightBuilder -
返回:

ne

public <T> CompareBuilder ne(Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

不等

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

ne

public <T> CompareBuilder ne(Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

不等

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

ne

public CompareBuilder ne(CompareBuilder builder,
                         Object value)

不等

参数:: builder -; value -
返回:

ne

public <T1,T2> CompareBuilder ne(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

不等

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

ne

public <T1,T2> CompareBuilder ne(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

不等

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ne

public <T1,T2> CompareBuilder ne(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

不等

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ne

public <T1,T2> CompareBuilder ne(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

不等

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

ne

public <T> CompareBuilder ne(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

不等

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ne

public <T> CompareBuilder ne(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

不等

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightColumn -
返回:

ne

public <T> CompareBuilder ne(Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

不等

类型参数:: T -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

ne

public <T> CompareBuilder ne(Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

不等

类型参数:: T -
参数:: leftTableNickName -; leftColumn -; rightBuilder -
返回:

ne

public CompareBuilder ne(CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

不等

参数:: leftBuilder -; rightBuilder -
返回:

gt

public <T> CompareBuilder gt(boolean condition,
                             Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

大于

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

gt

public <T> CompareBuilder gt(boolean condition,
                             Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

大于

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

gt

public CompareBuilder gt(boolean condition,
                         CompareBuilder builder,
                         Object value)

大于

参数:: condition -; builder -; value -
返回:

gt

public <T1,T2> CompareBuilder gt(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

大于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

gt

public <T1,T2> CompareBuilder gt(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

大于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

gt

public <T1,T2> CompareBuilder gt(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

大于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

gt

public <T1,T2> CompareBuilder gt(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

大于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

gt

public <T> CompareBuilder gt(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

大于

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

gt

public <T> CompareBuilder gt(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

大于

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightColumn -
返回:

gt

public <T> CompareBuilder gt(boolean condition,
                             Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

大于

类型参数:: T -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

gt

public <T> CompareBuilder gt(boolean condition,
                             Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

大于

类型参数:: T -
参数:: condition -; leftTableNickName -; leftColumn -; rightBuilder -
返回:

gt

public CompareBuilder gt(boolean condition,
                         CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

大于

参数:: condition -; leftBuilder -; rightBuilder -
返回:

gt

public <T> CompareBuilder gt(Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

大于

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

gt

public <T> CompareBuilder gt(Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

大于

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

gt

public CompareBuilder gt(CompareBuilder builder,
                         Object value)

大于

参数:: builder -; value -
返回:

gt

public <T1,T2> CompareBuilder gt(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

大于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

gt

public <T1,T2> CompareBuilder gt(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

大于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

gt

public <T1,T2> CompareBuilder gt(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

大于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

gt

public <T1,T2> CompareBuilder gt(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

大于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

gt

public <T> CompareBuilder gt(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

大于

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

gt

public <T> CompareBuilder gt(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

大于

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightColumn -
返回:

gt

public <T> CompareBuilder gt(Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

大于

类型参数:: T -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

gt

public <T> CompareBuilder gt(Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

大于

类型参数:: T -
参数:: leftTableNickName -; leftColumn -; rightBuilder -
返回:

gt

public CompareBuilder gt(CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

大于

参数:: leftBuilder -; rightBuilder -
返回:

ge

public <T> CompareBuilder ge(boolean condition,
                             Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

大于等于

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

ge

public <T> CompareBuilder ge(boolean condition,
                             Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

大于等于

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

ge

public CompareBuilder ge(boolean condition,
                         CompareBuilder builder,
                         Object value)

大于等于

参数:: condition -; builder -; value -
返回:

ge

public <T1,T2> CompareBuilder ge(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

大于等于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

ge

public <T1,T2> CompareBuilder ge(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

大于等于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ge

public <T1,T2> CompareBuilder ge(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

大于等于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ge

public <T1,T2> CompareBuilder ge(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

大于等于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

ge

public <T> CompareBuilder ge(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

大于等于

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ge

public <T> CompareBuilder ge(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

大于等于

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightColumn -
返回:

ge

public <T> CompareBuilder ge(boolean condition,
                             Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

大于等于

类型参数:: T -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

ge

public <T> CompareBuilder ge(boolean condition,
                             Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

大于等于

类型参数:: T -
参数:: condition -; leftTableNickName -; leftColumn -; rightBuilder -
返回:

ge

public CompareBuilder ge(boolean condition,
                         CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

大于等于

参数:: condition -; leftBuilder -; rightBuilder -
返回:

ge

public <T> CompareBuilder ge(Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

大于等于

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

ge

public <T> CompareBuilder ge(Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

大于等于

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

ge

public CompareBuilder ge(CompareBuilder builder,
                         Object value)

大于等于

参数:: builder -; value -
返回:

ge

public <T1,T2> CompareBuilder ge(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

大于等于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

ge

public <T1,T2> CompareBuilder ge(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

大于等于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ge

public <T1,T2> CompareBuilder ge(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

大于等于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ge

public <T1,T2> CompareBuilder ge(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

大于等于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

ge

public <T> CompareBuilder ge(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

大于等于

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

ge

public <T> CompareBuilder ge(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

大于等于

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightColumn -
返回:

ge

public <T> CompareBuilder ge(Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

大于等于

类型参数:: T -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

ge

public <T> CompareBuilder ge(Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

大于等于

类型参数:: T -
参数:: leftTableNickName -; leftColumn -; rightBuilder -
返回:

ge

public CompareBuilder ge(CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

大于等于

参数:: leftBuilder -; rightBuilder -
返回:

lt

public <T> CompareBuilder lt(boolean condition,
                             Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

小于

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

lt

public <T> CompareBuilder lt(boolean condition,
                             Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

小于

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

lt

public CompareBuilder lt(boolean condition,
                         CompareBuilder builder,
                         Object value)

小于

参数:: condition -; builder -; value -
返回:

lt

public <T1,T2> CompareBuilder lt(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

小于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

lt

public <T1,T2> CompareBuilder lt(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

小于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

lt

public <T1,T2> CompareBuilder lt(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

小于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

lt

public <T1,T2> CompareBuilder lt(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

小于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

lt

public <T> CompareBuilder lt(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

小于

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

lt

public <T> CompareBuilder lt(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

小于

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightColumn -
返回:

lt

public <T> CompareBuilder lt(boolean condition,
                             Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

小于

类型参数:: T -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

lt

public <T> CompareBuilder lt(boolean condition,
                             Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

小于

类型参数:: T -
参数:: condition -; leftTableNickName -; leftColumn -; rightBuilder -
返回:

lt

public CompareBuilder lt(boolean condition,
                         CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

小于

参数:: condition -; leftBuilder -; rightBuilder -
返回:

lt

public <T> CompareBuilder lt(Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

小于

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

lt

public <T> CompareBuilder lt(Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

小于

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

lt

public CompareBuilder lt(CompareBuilder builder,
                         Object value)

小于

参数:: builder -; value -
返回:

lt

public <T1,T2> CompareBuilder lt(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

小于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

lt

public <T1,T2> CompareBuilder lt(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

小于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

lt

public <T1,T2> CompareBuilder lt(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

小于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

lt

public <T1,T2> CompareBuilder lt(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

小于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

lt

public <T> CompareBuilder lt(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

小于

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

lt

public <T> CompareBuilder lt(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

小于

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightColumn -
返回:

lt

public <T> CompareBuilder lt(Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

小于

类型参数:: T -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

lt

public <T> CompareBuilder lt(Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

小于

类型参数:: T -
参数:: leftTableNickName -; leftColumn -; rightBuilder -
返回:

lt

public CompareBuilder lt(CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

小于

参数:: leftBuilder -; rightBuilder -
返回:

le

public <T> CompareBuilder le(boolean condition,
                             Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

小于等于

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

le

public <T> CompareBuilder le(boolean condition,
                             Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

小于等于

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

le

public CompareBuilder le(boolean condition,
                         CompareBuilder builder,
                         Object value)

小于等于

参数:: condition -; builder -; value -
返回:

le

public <T1,T2> CompareBuilder le(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

小于等于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

le

public <T1,T2> CompareBuilder le(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

小于等于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

le

public <T1,T2> CompareBuilder le(boolean condition,
                                 Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

小于等于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

le

public <T1,T2> CompareBuilder le(boolean condition,
                                 Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

小于等于

类型参数:: T1 -; T2 -
参数:: condition -; leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

le

public <T> CompareBuilder le(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

小于等于

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

le

public <T> CompareBuilder le(boolean condition,
                             CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

小于等于

类型参数:: T -
参数:: condition -; leftBuilder -; rightTableNickName -; rightColumn -
返回:

le

public <T> CompareBuilder le(boolean condition,
                             Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

小于等于

类型参数:: T -
参数:: condition -; leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

le

public <T> CompareBuilder le(boolean condition,
                             Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

小于等于

类型参数:: T -
参数:: condition -; leftTableNickName -; leftColumn -; rightBuilder -
返回:

le

public CompareBuilder le(boolean condition,
                         CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

小于等于

参数:: condition -; leftBuilder -; rightBuilder -
返回:

le

public <T> CompareBuilder le(Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Object value)

小于等于

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

le

public <T> CompareBuilder le(Class<T> tableNickName,
                             SFunction<T,?> column,
                             Object value)

小于等于

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

le

public CompareBuilder le(CompareBuilder builder,
                         Object value)

小于等于

参数:: builder -; value -
返回:

le

public <T1,T2> CompareBuilder le(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

小于等于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightColumn -
返回:

le

public <T1,T2> CompareBuilder le(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

小于等于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

le

public <T1,T2> CompareBuilder le(Class<T1> leftTableNickName,
                                 Integer leftTableNickIndex,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 Integer rightTableNickIndex,
                                 SFunction<T2,?> rightColumn)

小于等于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

le

public <T1,T2> CompareBuilder le(Class<T1> leftTableNickName,
                                 SFunction<T1,?> leftColumn,
                                 Class<T2> rightTableNickName,
                                 SFunction<T2,?> rightColumn)

小于等于

类型参数:: T1 -; T2 -
参数:: leftTableNickName -; leftColumn -; rightTableNickName -; rightColumn -
返回:

le

public <T> CompareBuilder le(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             Integer rightTableNickIndex,
                             SFunction<T,?> rightColumn)

小于等于

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightTableNickIndex -; rightColumn -
返回:

le

public <T> CompareBuilder le(CompareBuilder leftBuilder,
                             Class<T> rightTableNickName,
                             SFunction<T,?> rightColumn)

小于等于

类型参数:: T -
参数:: leftBuilder -; rightTableNickName -; rightColumn -
返回:

le

public <T> CompareBuilder le(Class<T> leftTableNickName,
                             Integer leftTableNickIndex,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

小于等于

类型参数:: T -
参数:: leftTableNickName -; leftTableNickIndex -; leftColumn -; rightBuilder -
返回:

le

public <T> CompareBuilder le(Class<T> leftTableNickName,
                             SFunction<T,?> leftColumn,
                             CompareBuilder rightBuilder)

小于等于

类型参数:: T -
参数:: leftTableNickName -; leftColumn -; rightBuilder -
返回:

le

public CompareBuilder le(CompareBuilder leftBuilder,
                         CompareBuilder rightBuilder)

小于等于

参数:: leftBuilder -; rightBuilder -
返回:

between

public <T> CompareBuilder between(boolean condition,
                                  Class<T> tableNickName,
                                  Integer tableNickIndex,
                                  SFunction<T,?> column,
                                  Object leftValue,
                                  Object rightValue)

在两者之间

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; leftValue -; rightValue -
返回:

between

public <T> CompareBuilder between(boolean condition,
                                  Class<T> tableNickName,
                                  SFunction<T,?> column,
                                  Object leftValue,
                                  Object rightValue)

在两者之间

类型参数:: T -
参数:: condition -; tableNickName -; column -; leftValue -; rightValue -
返回:

between

public CompareBuilder between(boolean condition,
                              CompareBuilder builder,
                              Object leftValue,
                              Object rightValue)

在两者之间

参数:: condition -; builder -; leftValue -; rightValue -
返回:

between

public <T> CompareBuilder between(Class<T> tableNickName,
                                  Integer tableNickIndex,
                                  SFunction<T,?> column,
                                  Object leftValue,
                                  Object rightValue)

在两者之间

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; leftValue -; rightValue -
返回:

between

public <T> CompareBuilder between(Class<T> tableNickName,
                                  SFunction<T,?> column,
                                  Object leftValue,
                                  Object rightValue)

在两者之间

类型参数:: T -
参数:: tableNickName -; column -; leftValue -; rightValue -
返回:

between

public CompareBuilder between(CompareBuilder builder,
                              Object leftValue,
                              Object rightValue)

在两者之间

参数:: builder -; leftValue -; rightValue -
返回:

notBetween

public <T> CompareBuilder notBetween(boolean condition,
                                     Class<T> tableNickName,
                                     Integer tableNickIndex,
                                     SFunction<T,?> column,
                                     Object leftValue,
                                     Object rightValue)

不在两者之间

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; leftValue -; rightValue -
返回:

notBetween

public <T> CompareBuilder notBetween(boolean condition,
                                     Class<T> tableNickName,
                                     SFunction<T,?> column,
                                     Object leftValue,
                                     Object rightValue)

不在两者之间

类型参数:: T -
参数:: condition -; tableNickName -; column -; leftValue -; rightValue -
返回:

notBetween

public CompareBuilder notBetween(boolean condition,
                                 CompareBuilder builder,
                                 Object leftValue,
                                 Object rightValue)

不在两者之间

参数:: condition -; builder -; leftValue -; rightValue -
返回:

notBetween

public <T> CompareBuilder notBetween(Class<T> tableNickName,
                                     Integer tableNickIndex,
                                     SFunction<T,?> column,
                                     Object leftValue,
                                     Object rightValue)

不在两者之间

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; leftValue -; rightValue -
返回:

notBetween

public <T> CompareBuilder notBetween(Class<T> tableNickName,
                                     SFunction<T,?> column,
                                     Object leftValue,
                                     Object rightValue)

不在两者之间

类型参数:: T -
参数:: tableNickName -; column -; leftValue -; rightValue -
返回:

notBetween

public CompareBuilder notBetween(CompareBuilder builder,
                                 Object leftValue,
                                 Object rightValue)

不在两者之间

参数:: builder -; leftValue -; rightValue -
返回:

like

public <T> CompareBuilder like(boolean condition,
                               Class<T> tableNickName,
                               Integer tableNickIndex,
                               SFunction<T,?> column,
                               Object value)

模糊

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

like

public <T> CompareBuilder like(boolean condition,
                               Class<T> tableNickName,
                               SFunction<T,?> column,
                               Object value)

模糊

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

like

public CompareBuilder like(boolean condition,
                           CompareBuilder builder,
                           Object value)

模糊

参数:: condition -; builder -; value -
返回:

like

public <T> CompareBuilder like(Class<T> tableNickName,
                               Integer tableNickIndex,
                               SFunction<T,?> column,
                               Object value)

模糊

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

like

public <T> CompareBuilder like(Class<T> tableNickName,
                               SFunction<T,?> column,
                               Object value)

模糊

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

like

public CompareBuilder like(CompareBuilder builder,
                           Object value)

模糊

参数:: builder -; value -
返回:

notLike

public <T> CompareBuilder notLike(boolean condition,
                                  Class<T> tableNickName,
                                  Integer tableNickIndex,
                                  SFunction<T,?> column,
                                  Object value)

不在模糊范围内

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

notLike

public <T> CompareBuilder notLike(boolean condition,
                                  Class<T> tableNickName,
                                  SFunction<T,?> column,
                                  Object value)

不在模糊范围内

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

notLike

public CompareBuilder notLike(boolean condition,
                              CompareBuilder builder,
                              Object value)

不在模糊范围内

参数:: condition -; builder -; value -
返回:

notLike

public <T> CompareBuilder notLike(Class<T> tableNickName,
                                  Integer tableNickIndex,
                                  SFunction<T,?> column,
                                  Object value)

不在模糊范围内

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

notLike

public <T> CompareBuilder notLike(Class<T> tableNickName,
                                  SFunction<T,?> column,
                                  Object value)

不在模糊范围内

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

notLike

public CompareBuilder notLike(CompareBuilder builder,
                              Object value)

不在模糊范围内

参数:: builder -; value -
返回:

likeLeft

public <T> CompareBuilder likeLeft(boolean condition,
                                   Class<T> tableNickName,
                                   Integer tableNickIndex,
                                   SFunction<T,?> column,
                                   Object value)

从左模糊查询

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

likeLeft

public <T> CompareBuilder likeLeft(boolean condition,
                                   Class<T> tableNickName,
                                   SFunction<T,?> column,
                                   Object value)

从左模糊查询

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

likeLeft

public CompareBuilder likeLeft(boolean condition,
                               CompareBuilder builder,
                               Object value)

从左模糊查询

参数:: condition -; builder -; value -
返回:

likeLeft

public <T> CompareBuilder likeLeft(Class<T> tableNickName,
                                   Integer tableNickIndex,
                                   SFunction<T,?> column,
                                   Object value)

从左模糊查询

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

likeLeft

public <T> CompareBuilder likeLeft(Class<T> tableNickName,
                                   SFunction<T,?> column,
                                   Object value)

从左模糊查询

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

likeLeft

public CompareBuilder likeLeft(CompareBuilder builder,
                               Object value)

不在从左模糊查询

参数:: builder -; value -
返回:

notLikeLeft

public <T> CompareBuilder notLikeLeft(boolean condition,
                                      Class<T> tableNickName,
                                      Integer tableNickIndex,
                                      SFunction<T,?> column,
                                      Object value)

不在从左模糊查询

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

notLikeLeft

public <T> CompareBuilder notLikeLeft(boolean condition,
                                      Class<T> tableNickName,
                                      SFunction<T,?> column,
                                      Object value)

不在从左模糊查询

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

notLikeLeft

public CompareBuilder notLikeLeft(boolean condition,
                                  CompareBuilder builder,
                                  Object value)

不在从左模糊查询

参数:: condition -; builder -; value -
返回:

notLikeLeft

public <T> CompareBuilder notLikeLeft(Class<T> tableNickName,
                                      Integer tableNickIndex,
                                      SFunction<T,?> column,
                                      Object value)

不在从左模糊查询

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

notLikeLeft

public <T> CompareBuilder notLikeLeft(Class<T> tableNickName,
                                      SFunction<T,?> column,
                                      Object value)

不在从左模糊查询

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

notLikeLeft

public CompareBuilder notLikeLeft(CompareBuilder builder,
                                  Object value)

不在从左模糊查询

参数:: builder -; value -
返回:

likeRight

public <T> CompareBuilder likeRight(boolean condition,
                                    Class<T> tableNickName,
                                    Integer tableNickIndex,
                                    SFunction<T,?> column,
                                    Object value)

从右模糊查询

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

likeRight

public <T> CompareBuilder likeRight(boolean condition,
                                    Class<T> tableNickName,
                                    SFunction<T,?> column,
                                    Object value)

从右模糊查询

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

likeRight

public CompareBuilder likeRight(boolean condition,
                                CompareBuilder builder,
                                Object value)

从右模糊查询

参数:: condition -; builder -; value -
返回:

likeRight

public <T> CompareBuilder likeRight(Class<T> tableNickName,
                                    Integer tableNickIndex,
                                    SFunction<T,?> column,
                                    Object value)

从右模糊查询

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

likeRight

public <T> CompareBuilder likeRight(Class<T> tableNickName,
                                    SFunction<T,?> column,
                                    Object value)

从右模糊查询

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

likeRight

public CompareBuilder likeRight(CompareBuilder builder,
                                Object value)

从右模糊查询

参数:: builder -; value -
返回:

notLikeRight

public <T> CompareBuilder notLikeRight(boolean condition,
                                       Class<T> tableNickName,
                                       Integer tableNickIndex,
                                       SFunction<T,?> column,
                                       Object value)

不在从右模糊查询

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

notLikeRight

public <T> CompareBuilder notLikeRight(boolean condition,
                                       Class<T> tableNickName,
                                       SFunction<T,?> column,
                                       Object value)

不在从右模糊查询

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

notLikeRight

public CompareBuilder notLikeRight(boolean condition,
                                   CompareBuilder builder,
                                   Object value)

不在从右模糊查询

参数:: condition -; builder -; value -
返回:

notLikeRight

public <T> CompareBuilder notLikeRight(Class<T> tableNickName,
                                       Integer tableNickIndex,
                                       SFunction<T,?> column,
                                       Object value)

不在从右模糊查询

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

notLikeRight

public <T> CompareBuilder notLikeRight(Class<T> tableNickName,
                                       SFunction<T,?> column,
                                       Object value)

不在从右模糊查询

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

notLikeRight

public CompareBuilder notLikeRight(CompareBuilder builder,
                                   Object value)

在范围内

参数:: builder -; value -
返回:

in

public <T> CompareBuilder in(boolean condition,
                             Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Collection<?> value)

在范围内

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

in

public <T> CompareBuilder in(boolean condition,
                             Class<T> tableNickName,
                             SFunction<T,?> column,
                             Collection<?> value)

在范围内

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

in

public CompareBuilder in(boolean condition,
                         CompareBuilder builder,
                         Collection<?> value)

在范围内

参数:: condition -; builder -; value -
返回:

in

public <T> CompareBuilder in(Class<T> tableNickName,
                             Integer tableNickIndex,
                             SFunction<T,?> column,
                             Collection<?> value)

在范围内

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

in

public <T> CompareBuilder in(Class<T> tableNickName,
                             SFunction<T,?> column,
                             Collection<?> value)

在范围内

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

in

public CompareBuilder in(CompareBuilder builder,
                         Collection<?> value)

不在范围内

参数:: builder -; value -
返回:

notIn

public <T> CompareBuilder notIn(boolean condition,
                                Class<T> tableNickName,
                                Integer tableNickIndex,
                                SFunction<T,?> column,
                                Collection<?> value)

不在范围内

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -; value -
返回:

notIn

public <T> CompareBuilder notIn(boolean condition,
                                Class<T> tableNickName,
                                SFunction<T,?> column,
                                Collection<?> value)

不在范围内

类型参数:: T -
参数:: condition -; tableNickName -; column -; value -
返回:

notIn

public CompareBuilder notIn(boolean condition,
                            CompareBuilder builder,
                            Collection<?> value)

不在范围内

参数:: condition -; builder -; value -
返回:

notIn

public <T> CompareBuilder notIn(Class<T> tableNickName,
                                Integer tableNickIndex,
                                SFunction<T,?> column,
                                Collection<?> value)

不在范围内

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -; value -
返回:

notIn

public <T> CompareBuilder notIn(Class<T> tableNickName,
                                SFunction<T,?> column,
                                Collection<?> value)

不在范围内

类型参数:: T -
参数:: tableNickName -; column -; value -
返回:

notIn

public CompareBuilder notIn(CompareBuilder builder,
                            Collection<?> value)

空

参数:: builder -; value -
返回:

isNull

public <T> CompareBuilder isNull(boolean condition,
                                 Class<T> tableNickName,
                                 Integer tableNickIndex,
                                 SFunction<T,?> column)

空

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -
返回:

isNull

public <T> CompareBuilder isNull(boolean condition,
                                 Class<T> tableNickName,
                                 SFunction<T,?> column)

空

类型参数:: T -
参数:: condition -; tableNickName -; column -
返回:

isNull

public CompareBuilder isNull(boolean condition,
                             CompareBuilder builder)

空

参数:: condition -; builder -
返回:

isNull

public <T> CompareBuilder isNull(Class<T> tableNickName,
                                 Integer tableNickIndex,
                                 SFunction<T,?> column)

空

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -
返回:

isNull

public <T> CompareBuilder isNull(Class<T> tableNickName,
                                 SFunction<T,?> column)

空

类型参数:: T -
参数:: tableNickName -; column -
返回:

isNull

public CompareBuilder isNull(CompareBuilder builder)

空

参数:: builder -
返回:

isNotNull

public <T> CompareBuilder isNotNull(boolean condition,
                                    Class<T> tableNickName,
                                    Integer tableNickIndex,
                                    SFunction<T,?> column)

不为空

类型参数:: T -
参数:: condition -; tableNickName -; tableNickIndex -; column -
返回:

isNotNull

public <T> CompareBuilder isNotNull(boolean condition,
                                    Class<T> tableNickName,
                                    SFunction<T,?> column)

不为空

类型参数:: T -
参数:: condition -; tableNickName -; column -
返回:

isNotNull

public CompareBuilder isNotNull(boolean condition,
                                CompareBuilder builder)

不为空

参数:: condition -; builder -
返回:

isNotNull

public <T> CompareBuilder isNotNull(Class<T> tableNickName,
                                    Integer tableNickIndex,
                                    SFunction<T,?> column)

不为空

类型参数:: T -
参数:: tableNickName -; tableNickIndex -; column -
返回:

isNotNull

public <T> CompareBuilder isNotNull(Class<T> tableNickName,
                                    SFunction<T,?> column)

不为空

类型参数:: T -
参数:: tableNickName -; column -
返回:

isNotNull

public CompareBuilder isNotNull(CompareBuilder builder)

不为空

参数:: builder -
返回:

exists

public <T> CompareBuilder exists(MultipleLambdaQueryWrapper<T> wrapper)

存在

类型参数:: T -
参数:: wrapper -
返回:

exists

public <T> CompareBuilder exists(boolean condition,
                                 MultipleLambdaQueryWrapper<T> wrapper)

存在

类型参数:: T -
参数:: condition -; wrapper -
返回:

notExists

public <T> CompareBuilder notExists(MultipleLambdaQueryWrapper<T> wrapper)

不存在

类型参数:: T -
参数:: wrapper -
返回:

notExists

public <T> CompareBuilder notExists(boolean condition,
                                    MultipleLambdaQueryWrapper<T> wrapper)

不存在

类型参数:: T -
参数:: condition -; wrapper -
返回:

and

public CompareBuilder and(CompareBuilder builder)

并且

参数:: builder -
返回:

and

public CompareBuilder and(boolean condition,
                          CompareBuilder builder)

并且

参数:: condition -; builder -
返回:

and
```
public CompareBuilder and()
```
并且

返回:

and

public CompareBuilder and(boolean condition)

并且

参数:: condition -
返回:

or

public CompareBuilder or(CompareBuilder builder)

或者

参数:: builder -
返回:

or

public CompareBuilder or(boolean condition,
                         CompareBuilder builder)

或者

参数:: condition -; builder -
返回:

or
```
public CompareBuilder or()
```
或者

返回:

or

public CompareBuilder or(boolean condition)

或者

参数:: condition -
返回:

类 CompareBuilder

字段概要

从类继承的字段 com.gitee.cardoon.ms.db.multiple.builder.Builder

构造器概要

方法概要

从类继承的方法 com.gitee.cardoon.ms.db.multiple.builder.Builder

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

构造器详细资料

CompareBuilder

方法详细资料

when

otherwise

end

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

eq

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

ne

gt

gt

gt

gt

gt

gt

gt

gt

gt

gt

gt

gt

gt

gt

gt

gt

gt

gt

gt