Conditional (MyBatis-Flex

Type Parameters:

R - 链式调用返回值类型

All Known Implementing Classes:

ArithmeticQueryColumn, CaseQueryColumn, CaseSearchQueryColumn, DistinctQueryColumn, FunctionQueryColumn, IfFunctionQueryColumn, NegativeQueryColumn, QueryColumn, QueryColumnAdapter, QueryConditionBuilder, RawQueryColumn, SelectQueryColumn, StringFunctionQueryColumn, WhereBuilder
```
public interface Conditional<R>
```
动态条件查询接口。

Since:

2023-08-12

Author:

王帅

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`R`	`between(Object[] values)` `BETWEEN values[0] AND values[1]`
`R`	`between(Object[] values, boolean isEffective)` `BETWEEN values[0] AND values[1]`
`R`	`between(Object start, Object end)` `BETWEEN start AND end`
`R`	`between(Object start, Object end, boolean isEffective)` `BETWEEN start AND end`
`R`	`between(Object start, Object end, BooleanSupplier isEffective)` `BETWEEN start AND end`
`<S,E> R`	`between(S start, E end, BiPredicate<S,E> isEffective)` `BETWEEN start AND end`
`R`	`eq(Object value)` 等于 `=`
`R`	`eq(Object value, boolean isEffective)` 等于 `=`
`R`	`eq(Object value, BooleanSupplier isEffective)` 等于 `=`
`<T> R`	`eq(T value, Predicate<T> isEffective)` 等于 `=`
`R`	`ge(Object value)` 大于等于 `>=`
`R`	`ge(Object value, boolean isEffective)` 大于等于 `>=`
`R`	`ge(Object value, BooleanSupplier isEffective)` 大于等于 `>=`
`<T> R`	`ge(T value, Predicate<T> isEffective)` 大于等于 `>=`
`R`	`gt(Object value)` 大于 `>`
`R`	`gt(Object value, boolean isEffective)` 大于 `>`
`R`	`gt(Object value, BooleanSupplier isEffective)` 大于 `>`
`<T> R`	`gt(T value, Predicate<T> isEffective)` 大于 `>`
`R`	`in(Collection<?> value)` `IN(value)`
`R`	`in(Collection<?> value, boolean isEffective)` `IN(value)`
`R`	`in(Collection<?> value, BooleanSupplier isEffective)` `IN(value)`
`R`	`in(Object... value)` `IN(value)`
`R`	`in(Object[] value, boolean isEffective)` `IN(value)`
`R`	`in(Object[] value, BooleanSupplier isEffective)` `IN(value)`
`R`	`in(QueryWrapper queryWrapper)` `IN(value)`
`R`	`in(QueryWrapper queryWrapper, boolean isEffective)` `IN(value)`
`R`	`in(QueryWrapper queryWrapper, BooleanSupplier isEffective)` `IN(value)`
`<T> R`	`in(T[] value, Predicate<T[]> isEffective)` `IN(value)`
`<T extends Collection<?>> R`	`in(T value, Predicate<T> isEffective)` `IN(value)`
`default R`	`isNotNull()` `IS NOT NULL`
`R`	`isNotNull(boolean isEffective)` `IS NOT NULL`
`default R`	`isNotNull(BooleanSupplier isEffective)` `IS NOT NULL`
`default R`	`isNull()` `IS NULL`
`R`	`isNull(boolean isEffective)` `IS NULL`
`default R`	`isNull(BooleanSupplier isEffective)` `IS NULL`
`R`	`le(Object value)` 小于等于 `<=`
`R`	`le(Object value, boolean isEffective)` 小于等于 `<=`
`R`	`le(Object value, BooleanSupplier isEffective)` 小于等于 `<=`
`<T> R`	`le(T value, Predicate<T> isEffective)` 小于等于 `<=`
`R`	`like(Object value)` `LIKE %value%`
`R`	`like(Object value, boolean isEffective)` `LIKE %value%`
`R`	`like(Object value, BooleanSupplier isEffective)` `LIKE %value%`
`<T> R`	`like(T value, Predicate<T> isEffective)` `LIKE %value%`
`R`	`likeLeft(Object value)` `LIKE value%`
`R`	`likeLeft(Object value, boolean isEffective)` `LIKE value%`
`R`	`likeLeft(Object value, BooleanSupplier isEffective)` `LIKE value%`
`<T> R`	`likeLeft(T value, Predicate<T> isEffective)` `LIKE value%`
`R`	`likeRight(Object value)` `LIKE %value`
`R`	`likeRight(Object value, boolean isEffective)` `LIKE %value`
`R`	`likeRight(Object value, BooleanSupplier isEffective)` `LIKE %value`
`<T> R`	`likeRight(T value, Predicate<T> isEffective)` `LIKE %value`
`R`	`lt(Object value)` 小于 `<`
`R`	`lt(Object value, boolean isEffective)` 小于 `<`
`R`	`lt(Object value, BooleanSupplier isEffective)` 小于 `<`
`<T> R`	`lt(T value, Predicate<T> isEffective)` 小于 `<`
`R`	`ne(Object value)` 不等于 `!=`
`R`	`ne(Object value, boolean isEffective)` 不等于 `!=`
`R`	`ne(Object value, BooleanSupplier isEffective)` 不等于 `!=`
`<T> R`	`ne(T value, Predicate<T> isEffective)` 不等于 `!=`
`R`	`notBetween(Object[] values)` `NOT BETWEEN values[0] AND values[1]`
`R`	`notBetween(Object[] values, boolean isEffective)` `NOT BETWEEN values[0] AND values[1]`
`R`	`notBetween(Object start, Object end)` `NOT BETWEEN start AND end`
`R`	`notBetween(Object start, Object end, boolean isEffective)` `NOT BETWEEN start AND end`
`R`	`notBetween(Object start, Object end, BooleanSupplier isEffective)` `NOT BETWEEN start AND end`
`<S,E> R`	`notBetween(S start, E end, BiPredicate<S,E> isEffective)` `NOT BETWEEN start AND end`
`R`	`notIn(Collection<?> value)` `NOT IN(value)`
`R`	`notIn(Collection<?> value, boolean isEffective)` `NOT IN(value)`
`R`	`notIn(Collection<?> value, BooleanSupplier isEffective)` `NOT IN(value)`
`R`	`notIn(Object... value)` `NOT IN(value)`
`R`	`notIn(Object[] value, boolean isEffective)` `NOT IN(value)`
`R`	`notIn(Object[] value, BooleanSupplier isEffective)` `NOT IN(value)`
`R`	`notIn(QueryWrapper queryWrapper)` `NOT IN(value)`
`R`	`notIn(QueryWrapper queryWrapper, boolean isEffective)` `NOT IN(value)`
`R`	`notIn(QueryWrapper queryWrapper, BooleanSupplier isEffective)` `NOT IN(value)`
`<T> R`	`notIn(T[] value, Predicate<T[]> isEffective)` `NOT IN(value)`
`<T extends Collection<?>> R`	`notIn(T value, Predicate<T> isEffective)` `NOT IN(value)`
`R`	`notLike(Object value)` `NOT LIKE %value%`
`R`	`notLike(Object value, boolean isEffective)` `NOT LIKE %value%`
`R`	`notLike(Object value, BooleanSupplier isEffective)` `NOT LIKE %value%`
`<T> R`	`notLike(T value, Predicate<T> isEffective)` `NOT LIKE %value%`
`R`	`notLikeLeft(Object value)` `NOT LIKE value%`
`R`	`notLikeLeft(Object value, boolean isEffective)` `NOT LIKE value%`
`R`	`notLikeLeft(Object value, BooleanSupplier isEffective)` `NOT LIKE value%`
`<T> R`	`notLikeLeft(T value, Predicate<T> isEffective)` `NOT LIKE value%`
`R`	`notLikeRight(Object value)` `NOT LIKE %value`
`R`	`notLikeRight(Object value, boolean isEffective)` `NOT LIKE %value`
`R`	`notLikeRight(Object value, BooleanSupplier isEffective)` `NOT LIKE %value`
`<T> R`	`notLikeRight(T value, Predicate<T> isEffective)` `NOT LIKE %value`

- Method Detail
  - eq
```
R eq(Object value)
```
    等于 =
    
    Parameters:
    
    value - 条件的值
  - eq
```
R eq(Object value,
     boolean isEffective)
```
    等于 =
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - eq
```
R eq(Object value,
     BooleanSupplier isEffective)
```
    等于 =
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - eq
```
<T> R eq(T value,
         Predicate<T> isEffective)
```
    等于 =
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否生效
  - ne
```
R ne(Object value)
```
    不等于 !=
    
    Parameters:
    
    value - 条件的值
  - ne
```
R ne(Object value,
     boolean isEffective)
```
    不等于 !=
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - ne
```
R ne(Object value,
     BooleanSupplier isEffective)
```
    不等于 !=
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - ne
```
<T> R ne(T value,
         Predicate<T> isEffective)
```
    不等于 !=
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - gt
```
R gt(Object value)
```
    大于 >
    
    Parameters:
    
    value - 条件的值
  - gt
```
R gt(Object value,
     boolean isEffective)
```
    大于 >
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - gt
```
R gt(Object value,
     BooleanSupplier isEffective)
```
    大于 >
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - gt
```
<T> R gt(T value,
         Predicate<T> isEffective)
```
    大于 >
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - ge
```
R ge(Object value)
```
    大于等于 >=
    
    Parameters:
    
    value - 条件的值
  - ge
```
R ge(Object value,
     boolean isEffective)
```
    大于等于 >=
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - ge
```
R ge(Object value,
     BooleanSupplier isEffective)
```
    大于等于 >=
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - ge
```
<T> R ge(T value,
         Predicate<T> isEffective)
```
    大于等于 >=
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - lt
```
R lt(Object value)
```
    小于 <
    
    Parameters:
    
    value - 条件的值
  - lt
```
R lt(Object value,
     boolean isEffective)
```
    小于 <
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - lt
```
R lt(Object value,
     BooleanSupplier isEffective)
```
    小于 <
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - lt
```
<T> R lt(T value,
         Predicate<T> isEffective)
```
    小于 <
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - le
```
R le(Object value)
```
    小于等于 <=
    
    Parameters:
    
    value - 条件的值
  - le
```
R le(Object value,
     boolean isEffective)
```
    小于等于 <=
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - le
```
R le(Object value,
     BooleanSupplier isEffective)
```
    小于等于 <=
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - le
```
<T> R le(T value,
         Predicate<T> isEffective)
```
    小于等于 <=
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - in
```
R in(Object... value)
```
    IN(value)
    
    Parameters:
    
    value - 条件的值
  - in
```
R in(Object[] value,
     boolean isEffective)
```
    IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - in
```
R in(Object[] value,
     BooleanSupplier isEffective)
```
    IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - in
```
<T> R in(T[] value,
         Predicate<T[]> isEffective)
```
    IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - in
```
R in(Collection<?> value)
```
    IN(value)
    
    Parameters:
    
    value - 条件的值
  - in
```
R in(Collection<?> value,
     boolean isEffective)
```
    IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - in
```
R in(Collection<?> value,
     BooleanSupplier isEffective)
```
    IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - in
```
<T extends Collection<?>> R in(T value,
                               Predicate<T> isEffective)
```
    IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - in
```
R in(QueryWrapper queryWrapper)
```
    IN(value)
    
    Parameters:
    
    queryWrapper - 子查询值
  - in
```
R in(QueryWrapper queryWrapper,
     boolean isEffective)
```
    IN(value)
    
    Parameters:
    
    queryWrapper - 子查询值
    
    isEffective - 是否有效
  - in
```
R in(QueryWrapper queryWrapper,
     BooleanSupplier isEffective)
```
    IN(value)
    
    Parameters:
    
    queryWrapper - 子查询值
    
    isEffective - 是否有效
  - notIn
```
R notIn(Object... value)
```
    NOT IN(value)
    
    Parameters:
    
    value - 条件的值
  - notIn
```
R notIn(Object[] value,
        boolean isEffective)
```
    NOT IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notIn
```
R notIn(Object[] value,
        BooleanSupplier isEffective)
```
    NOT IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notIn
```
<T> R notIn(T[] value,
            Predicate<T[]> isEffective)
```
    NOT IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notIn
```
R notIn(Collection<?> value)
```
    NOT IN(value)
    
    Parameters:
    
    value - 条件的值
  - notIn
```
R notIn(Collection<?> value,
        boolean isEffective)
```
    NOT IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notIn
```
R notIn(Collection<?> value,
        BooleanSupplier isEffective)
```
    NOT IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notIn
```
<T extends Collection<?>> R notIn(T value,
                                  Predicate<T> isEffective)
```
    NOT IN(value)
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notIn
```
R notIn(QueryWrapper queryWrapper)
```
    NOT IN(value)
    
    Parameters:
    
    queryWrapper - 子查询值
  - notIn
```
R notIn(QueryWrapper queryWrapper,
        boolean isEffective)
```
    NOT IN(value)
    
    Parameters:
    
    queryWrapper - 子查询值
    
    isEffective - 是否有效
  - notIn
```
R notIn(QueryWrapper queryWrapper,
        BooleanSupplier isEffective)
```
    NOT IN(value)
    
    Parameters:
    
    queryWrapper - 子查询值
    
    isEffective - 是否有效
  - between
```
R between(Object[] values)
```
    BETWEEN values[0] AND values[1]
    
    Parameters:
    
    values - 范围值
  - between
```
R between(Object[] values,
          boolean isEffective)
```
    BETWEEN values[0] AND values[1]
    
    Parameters:
    
    values - 值
    
    isEffective - 是否有效
  - between
```
R between(Object start,
          Object end)
```
    BETWEEN start AND end
    
    Parameters:
    
    start - 开始的值
    
    end - 结束的值
  - between
```
R between(Object start,
          Object end,
          boolean isEffective)
```
    BETWEEN start AND end
    
    Parameters:
    
    start - 开始的值
    
    end - 结束的值
    
    isEffective - 是否有效
  - between
```
R between(Object start,
          Object end,
          BooleanSupplier isEffective)
```
    BETWEEN start AND end
    
    Parameters:
    
    start - 开始的值
    
    end - 结束的值
    
    isEffective - 是否有效
  - between
```
<S,E> R between(S start,
                E end,
                BiPredicate<S,E> isEffective)
```
    BETWEEN start AND end
    
    Parameters:
    
    start - 开始的值
    
    end - 结束的值
    
    isEffective - 是否有效
  - notBetween
```
R notBetween(Object[] values)
```
    NOT BETWEEN values[0] AND values[1]
    
    Parameters:
    
    values - 范围值
  - notBetween
```
R notBetween(Object[] values,
             boolean isEffective)
```
    NOT BETWEEN values[0] AND values[1]
    
    Parameters:
    
    values - 值
    
    isEffective - 是否有效
  - notBetween
```
R notBetween(Object start,
             Object end)
```
    NOT BETWEEN start AND end
    
    Parameters:
    
    start - 开始的值
    
    end - 结束的值
  - notBetween
```
R notBetween(Object start,
             Object end,
             boolean isEffective)
```
    NOT BETWEEN start AND end
    
    Parameters:
    
    start - 开始的值
    
    end - 结束的值
    
    isEffective - 是否有效
  - notBetween
```
R notBetween(Object start,
             Object end,
             BooleanSupplier isEffective)
```
    NOT BETWEEN start AND end
    
    Parameters:
    
    start - 开始的值
    
    end - 结束的值
    
    isEffective - 是否有效
  - notBetween
```
<S,E> R notBetween(S start,
                   E end,
                   BiPredicate<S,E> isEffective)
```
    NOT BETWEEN start AND end
    
    Parameters:
    
    start - 开始的值
    
    end - 结束的值
    
    isEffective - 是否有效
  - like
```
R like(Object value)
```
    LIKE %value%
    
    Parameters:
    
    value - 条件的值
  - like
```
R like(Object value,
       boolean isEffective)
```
    LIKE %value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - like
```
R like(Object value,
       BooleanSupplier isEffective)
```
    LIKE %value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - like
```
<T> R like(T value,
           Predicate<T> isEffective)
```
    LIKE %value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - likeLeft
```
R likeLeft(Object value)
```
    LIKE value%
    
    Parameters:
    
    value - 条件的值
  - likeLeft
```
R likeLeft(Object value,
           boolean isEffective)
```
    LIKE value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - likeLeft
```
R likeLeft(Object value,
           BooleanSupplier isEffective)
```
    LIKE value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - likeLeft
```
<T> R likeLeft(T value,
               Predicate<T> isEffective)
```
    LIKE value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - likeRight
```
R likeRight(Object value)
```
    LIKE %value
    
    Parameters:
    
    value - 条件的值
  - likeRight
```
R likeRight(Object value,
            boolean isEffective)
```
    LIKE %value
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - likeRight
```
R likeRight(Object value,
            BooleanSupplier isEffective)
```
    LIKE %value
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - likeRight
```
<T> R likeRight(T value,
                Predicate<T> isEffective)
```
    LIKE %value
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notLike
```
R notLike(Object value)
```
    NOT LIKE %value%
    
    Parameters:
    
    value - 条件的值
  - notLike
```
R notLike(Object value,
          boolean isEffective)
```
    NOT LIKE %value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notLike
```
R notLike(Object value,
          BooleanSupplier isEffective)
```
    NOT LIKE %value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notLike
```
<T> R notLike(T value,
              Predicate<T> isEffective)
```
    NOT LIKE %value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notLikeLeft
```
R notLikeLeft(Object value)
```
    NOT LIKE value%
    
    Parameters:
    
    value - 条件的值
  - notLikeLeft
```
R notLikeLeft(Object value,
              boolean isEffective)
```
    NOT LIKE value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notLikeLeft
```
R notLikeLeft(Object value,
              BooleanSupplier isEffective)
```
    NOT LIKE value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notLikeLeft
```
<T> R notLikeLeft(T value,
                  Predicate<T> isEffective)
```
    NOT LIKE value%
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notLikeRight
```
R notLikeRight(Object value)
```
    NOT LIKE %value
    
    Parameters:
    
    value - 条件的值
  - notLikeRight
```
R notLikeRight(Object value,
               boolean isEffective)
```
    NOT LIKE %value
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notLikeRight
```
R notLikeRight(Object value,
               BooleanSupplier isEffective)
```
    NOT LIKE %value
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - notLikeRight
```
<T> R notLikeRight(T value,
                   Predicate<T> isEffective)
```
    NOT LIKE %value
    
    Parameters:
    
    value - 条件的值
    
    isEffective - 是否有效
  - isNull
```
default R isNull()
```
    IS NULL
  - isNull
```
R isNull(boolean isEffective)
```
    IS NULL
    
    Parameters:
    
    isEffective - 是否有效
  - isNull
```
default R isNull(BooleanSupplier isEffective)
```
    IS NULL
    
    Parameters:
    
    isEffective - 是否有效
  - isNotNull
```
default R isNotNull()
```
    IS NOT NULL
  - isNotNull
```
R isNotNull(boolean isEffective)
```
    IS NOT NULL
    
    Parameters:
    
    isEffective - 是否有效
  - isNotNull
```
default R isNotNull(BooleanSupplier isEffective)
```
    IS NOT NULL
    
    Parameters:
    
    isEffective - 是否有效

Interface Conditional<R>

Method Summary

Method Detail

eq

eq

eq

eq

ne

ne

ne

ne

gt

gt

gt

gt

ge

ge

ge

ge

lt

lt

lt

lt

le

le

le

le

in

in

in

in

in

in

in

in

in

in

in

notIn

notIn

notIn

notIn

notIn

notIn

notIn

notIn

notIn

notIn

notIn

between

between

between

between

between

between

notBetween

notBetween

notBetween

notBetween

notBetween

notBetween

like

like

like

like

likeLeft

likeLeft

likeLeft

likeLeft

likeRight

likeRight

likeRight

likeRight

notLike

notLike

notLike

notLike

notLikeLeft

notLikeLeft

notLikeLeft