java.lang.Object

cn.dinodev.spring.data.sql.builder.WhereSql<T>

All Implemented Interfaces:: SqlBuilder

Direct Known Subclasses:: DeleteSqlBuilder, SelectSqlBuilder, UpdateSqlBuilder

public abstract class WhereSql<T extends SqlBuilder> extends Object implements SqlBuilder

Author:: Cody Lu

Field Summary

Fields

Modifier and Type

Field

Description

protected static final Object[]

EMPTY_PARAMS

protected List<String>

tables

protected List<String>

whereColumns

protected List<Object>

whereParams

protected String

withName

protected SqlBuilder

withSql
Constructor Summary

Constructors

Constructor

Description

WhereSql()
Method Summary

Modifier and Type

Method

Description

T

and(String expr)

where 表达式，用 AND 连接，如下写法都是合法的：

T

and(String column, Oper op, Object value)

where 表达式，用 AND 连接，例如：

T

and(String expr, Object... values)

where 表达式，带参数值，用 AND 连接，如下写法都是合法的：

T

andIf(boolean cnd, String column, Oper op, Object value)

where 表达式，用 AND 连接，根据传入条件，当为false时，则忽略此查询条件

T

andIf(boolean cnd, String expr, Object... values)

where 表达式，用 AND 连接，根据传入条件，当为false时，则忽略此查询条件

T

andIfNotNull(String column, Oper op, Object value)

where 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：

T

andIfNotNull(String expr, Object value)

where 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：

T

any(String column, T subQuery)

where 表达式中的 ANY 函数，其参数为一个子查询，如下：

T

any(String column, T subQuery, Logic logic)

where 表达式中的 ANY 函数，其参数为一个子查询，如下：

T

between(String column, cn.dinodev.spring.commons.data.Range<?> range)

where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：

T

between(String column, Number start, Number end)

where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：

T

endWith(String column, String value)

where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：

T

endWith(String column, String value, Logic logic)

where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：

T

eq(String column, Object value)

where eq 表达式，用 AND 连接，例如：

T

eqIf(boolean cnd, String column, Object value)

where eq 表达式，用 AND 连接，根据传入条件，当为false时，则忽略此查询条件

T

eqIfNotBlank(String column, String value)

where eq 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：

T

eqIfNotNull(String column, Object value)

where eq 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：

T

in(String column, Object[] values)

where 表达式中的 IN 语句，其参数为数组，按照如下处理逻辑：

T

in(String column, Object[] values, Logic logic)

where 表达式中的 IN 语句，其参数为数组，按照如下处理逻辑：

T

in(String column, Collection<?> values)

where 表达式中的 IN 语句，其参数为数组，按照如下处理逻辑：

T

in(String column, Collection<?> values, Logic logic)

where 表达式中的 IN 语句，其参数为数组，按照如下处理逻辑：

T

inIf(boolean cnd, String column, Object[] values)

where 表达式中的 IN 语句，根据传入条件，当为false时，则忽略此查询条件.

T

inIf(boolean cnd, String column, Collection<?> values)

where 表达式中的 IN 语句，根据传入条件，当为false时，则忽略此查询条件.

T

isNotNull(String column)

[AND] column IS NOT NULL

T

isNotNull(String column, Logic logic)

[AND|OR] column IS NOT NULL

T

isNotNullIf(boolean cnd, String column)

如果条件成立，则为[AND] column IS NOT NULL，否则忽略

T

isNotNullIf(boolean cnd, String column, Logic logic)

如果条件成立，则为[AND|OR] column IS NOT NULL，否则忽略

T

isNull(String column)

[AND] column IS NULL

T

isNull(String column, Logic logic)

[AND|OR] column IS NULL

T

isNullIf(boolean cnd, String column)

如果条件成立，则为[AND] column IS NULL，否则忽略

T

isNullIf(boolean cnd, String column, Logic logic)

如果条件成立，则为[AND|OR] column IS NULL，否则忽略

T

like(String column, String value)

where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：

T

like(String column, String value, Logic logic)

where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：

T

ne(String column, Object value)

where ne 表达式，用 AND 连接，例如：

T

neIf(boolean cnd, String column, Object value)

where ne 表达式，用 AND 连接，根据传入条件，当为false时，则忽略此查询条件

T

neIfNotBlank(String column, String value)

where ne 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：

T

neIfNotNull(String column, Object value)

where ne 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：

T

notIn(String column, Object[] values)

where 表达式中的 NOT IN 语句，其参数为数组，按照如下处理逻辑：

T

notIn(String column, Object[] values, Logic logic)

where 表达式中的 IN 语句，其参数为数组，按照如下处理逻辑：

T

notIn(String column, Collection<?> values)

where 表达式中的 NOT IN 语句，其参数为数组，按照如下处理逻辑：

T

notIn(String column, Collection<?> values, Logic logic)

where 表达式中的 NOT IN 语句，其参数为数组，按照如下处理逻辑：

T

or(String expr)

where 表达式，用OR连接，如下写法都是合法的：

T

or(String column, Oper op, Object value)

where 表达式，用 OR 连接，例如：

T

or(String expr, Object... values)

where 表达式，带参数值，用 OR 连接，如下写法都是合法的：

T

orIf(boolean cnd, String column, Oper op, Object value)

where 表达式，用 OR 连接，根据传入条件，当为false时，则忽略此查询条件

T

orIf(boolean cnd, String expr, Object... values)

where 表达式，用 OR 连接，根据传入条件，当为false时，则忽略此查询条件

T

orIfNotNull(String column, Oper op, Object value)

where 表达式，用 OR 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：

T

orIfNotNull(String expr, Object value)

where 表达式，用 OR 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：

protected void

setThat(T that)

T

some(String[] columns, Oper op, Object value)

AND 任意列LIKE %value%:

T

some(String[] columns, Oper op, Object value, Logic logic)

任意列LIKE %value%：

T

someEndWith(String[] columns, String value)

AND 任意列LIKE %value:

T

someEndWith(String[] columns, String value, Logic logic)

任意列LIKE %value：

T

someIf(boolean cnd, String[] columns, Oper op, Object value, Logic logic)

任意列LIKE %value%：

T

someIf(boolean cnd, String[] columns, Oper op, String value)

AND 任意列 [op] [value]:

T

someLike(String[] columns, String value)

AND 任意列LIKE %value%:

T

someLike(String[] columns, String value, Logic logic)

任意列LIKE %value%：

T

someStartWith(String[] columns, String value)

AND 任意列LIKE value%:

T

someStartWith(String[] columns, String value, Logic logic)

任意列LIKE value%：

T

startWith(String column, String value)

where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：

T

startWith(String column, String value, Logic logic)

where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：

T

table(String... tables)

设置要查询的表，可以是多个表，如下用法都是正确的：

T

where(String expr)

where 表达式，如下写法都是合法的：

T

where(String column, Oper op, Object value)

where 表达式，例如：

T

where(String expr, Object... values)

where 表达式，带参数值，如下写法都是合法的：

T

whereIf(boolean cnd, String column, Oper op, Object value)

where 表达式，根据传入条件，当为false时，则忽略此查询条件

T

whereIf(boolean cnd, String expr, Object... values)

where 表达式，根据传入条件，当为false时，则忽略此查询条件

T

whereIfNotNull(String column, Oper op, Object value)

where 表达式，判断值不为null时，表达式才被采用，否则表达式会被丢弃：

T

whereIfNotNull(String expr, Object value)

where 表达式，判断值不为null时，表达式才被采用，否则表达式会被丢弃：

T

with(SqlBuilder subQuery, String alias)

with 语句支持，并将子查询自动添加到from中：

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface cn.dinodev.spring.data.sql.SqlBuilder
appendList, appendList, getParams, getSql

Field Details
- EMPTY_PARAMS
  
  protected static final Object[] EMPTY_PARAMS
- tables
  
  protected List<String> tables
- whereColumns
  
  protected List<String> whereColumns
- whereParams
  
  protected List<Object> whereParams
- withSql
  
  protected SqlBuilder withSql
- withName
  
  protected String withName
Constructor Details
- WhereSql
  
  public WhereSql()
Method Details
- setThat
  
  protected void setThat(T that)
- table
  
  public T table(String... tables)
  
  设置要查询的表，可以是多个表，如下用法都是正确的：
  - from("table1, table2");
  - from("table1", "table2");
  
  Parameters:
  
  tables -
  
  Returns:
- with
  
  public T with(SqlBuilder subQuery, String alias)
  
  with 语句支持，并将子查询自动添加到from中：
  - with #alias AS ( #subQuery语句 ); select colums from #alias
  
  Parameters:
  
  subQuery - 子查询
  
  alias - 临时查询的别名
  
  Returns:
- where
  
  public T where(String expr)
  
  where 表达式，如下写法都是合法的：
  - where("status = 1")
  - where("status = 1 and id = ?")
  
  Parameters:
  
  expr -
  
  Returns:
- where
  
  public T where(String expr, Object... values)
  
  where 表达式，带参数值，如下写法都是合法的：
  - where("id = ?", id)
  - where("status = 1 and classId = ? and score > ?", classId, 60)
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  
  Parameters:
  
  expr -
  
  values -
  
  Returns:
- where
  
  public T where(String column, Oper op, Object value)
  
  where 表达式，例如：
  - where("col1", Oper.EQ, val)
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  
  Parameters:
  
  column -
  
  op -
  
  value -
  
  Returns:
- whereIfNotNull
  
  public T whereIfNotNull(String expr, Object value)
  
  where 表达式，判断值不为null时，表达式才被采用，否则表达式会被丢弃：
  - whereIfNotNull("type = ?", null); 则会忽略这个表达式，不会根据type字段筛选。
  - whereIfNotNull("type = ?", 1);
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  
  Parameters:
  
  expr -
  
  value -
  
  Returns:
- whereIfNotNull
  
  public T whereIfNotNull(String column, Oper op, Object value)
  
  where 表达式，判断值不为null时，表达式才被采用，否则表达式会被丢弃：
  - whereIfNotNull("type", Oper.EQ, null); 则会忽略这个表达式，不会根据type字段筛选。
  - whereIfNotNull("type", Oper.EQ, 1);
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  
  Parameters:
  
  column -
  
  op -
  
  value -
  
  Returns:
- whereIf
  
  public T whereIf(boolean cnd, String expr, Object... values)
  
  where 表达式，根据传入条件，当为false时，则忽略此查询条件
  - whereIf(false, "type=?", 1); 则会忽略这个表达式，不会根据type字段筛选。
  - whereIf(true, "type=? or type=?", 1, 2); type= 1||2的记录会被筛选出来。
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  
  Parameters:
  
  cnd -
  
  expr -
  
  values -
  
  Returns:
- whereIf
  
  public T whereIf(boolean cnd, String column, Oper op, Object value)
  
  where 表达式，根据传入条件，当为false时，则忽略此查询条件
  - whereIf(false, "type", “=”, 1); 则会忽略这个表达式，不会根据type字段筛选。
  - whereIf(true, "type", Oper.EQ, 1, 2); type= 1||2的记录会被筛选出来。
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  
  Parameters:
  
  cnd -
  
  column -
  
  op -
  
  value -
  
  Returns:
- and
  
  public T and(String expr)
  
  where 表达式，用 AND 连接，如下写法都是合法的：
  - and("status = 1")
  - and("status = 1 and id = ?")
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  expr -
  
  Returns:
- and
  
  public T and(String expr, Object... values)
  
  where 表达式，带参数值，用 AND 连接，如下写法都是合法的：
  - and("id = ?", id)
  - and("status = 1 and classId = ? and score > ?", classId, 60)
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  expr -
  
  values -
  
  Returns:
- and
  
  public T and(String column, Oper op, Object value)
  
  where 表达式，用 AND 连接，例如：
  - and("col1", Oper.EQ, val)
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  column -
  
  op -
  
  value -
  
  Returns:
- andIf
  
  public T andIf(boolean cnd, String expr, Object... values)
  
  where 表达式，用 AND 连接，根据传入条件，当为false时，则忽略此查询条件
  - andIf(false, "type=?", 1); 则会忽略这个表达式，不会根据type字段筛选。
  - andIf(true, "type=? or type=?", 1, 2); type= 1||2的记录会被筛选出来。
  in表达式请使用 #in(String, List, String)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  cnd -
  
  expr -
  
  values -
  
  Returns:
- andIf
  
  public T andIf(boolean cnd, String column, Oper op, Object value)
  
  where 表达式，用 AND 连接，根据传入条件，当为false时，则忽略此查询条件
  - andIf(false, "type", “=”, 1); 则会忽略这个表达式，不会根据type字段筛选。
  - andIf(true, "type", Oper.EQ, 1); type= 1的记录会被筛选出来。
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  cnd -
  
  column -
  
  op -
  
  value -
  
  Returns:
- andIfNotNull
  
  public T andIfNotNull(String expr, Object value)
  
  where 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：
  - andIfNotNull("type = ?", null); 则会忽略这个表达式，不会根据type字段筛选。
  - andIfNotNull("type = ?", 1);
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  expr -
  
  value -
  
  Returns:
- andIfNotNull
  
  public T andIfNotNull(String column, Oper op, Object value)
  
  where 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：
  - andIfNotNull("type", Oper.EQ, null); 则会忽略这个表达式，不会根据type字段筛选。
  - andIfNotNull("type", Oper.EQ, 1);
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  column -
  
  op -
  
  value -
  
  Returns:
- eq
  
  public T eq(String column, Object value)
  
  where eq 表达式，用 AND 连接，例如：
  - and("col1", val)
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  column -
  
  op -
  
  value -
  
  Returns:
- eqIf
  
  public T eqIf(boolean cnd, String column, Object value)
  
  where eq 表达式，用 AND 连接，根据传入条件，当为false时，则忽略此查询条件
  - eqIf(false, "type", 1); 则会忽略这个表达式，不会根据type字段筛选。
  - eqIf(true, "type", 1); type= 1的记录会被筛选出来。
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  cnd -
  
  column -
  
  value -
  
  Returns:
- eqIfNotNull
  
  public T eqIfNotNull(String column, Object value)
  
  where eq 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：
  - eqIfNotNull("type", null); 则会忽略这个表达式，不会根据type字段筛选。
  - eqIfNotNull("type", 1);
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  column -
  
  value -
  
  Returns:
- eqIfNotBlank
  
  public T eqIfNotBlank(String column, String value)
  
  where eq 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：
  - eqIfNotNull("type", null); 则会忽略这个表达式，不会根据type字段筛选。
  - eqIfNotNull("type", 1);
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  column -
  
  value -
  
  Returns:
- ne
  
  public T ne(String column, Object value)
  
  where ne 表达式，用 AND 连接，例如：
  - and("col1", val)
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  column -
  
  op -
  
  value -
  
  Returns:
- neIf
  
  public T neIf(boolean cnd, String column, Object value)
  
  where ne 表达式，用 AND 连接，根据传入条件，当为false时，则忽略此查询条件
  - neIf(false, "type", 1); 则会忽略这个表达式，不会根据type字段筛选。
  - neIf(true, "type", 1); type= 1的记录会被筛选出来。
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  cnd -
  
  column -
  
  value -
  
  Returns:
- neIfNotNull
  
  public T neIfNotNull(String column, Object value)
  
  where ne 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：
  - neIfNotNull("type", null); 则会忽略这个表达式，不会根据type字段筛选。
  - nqIfNotNull("type", 1); 如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  column -
  
  value -
  
  Returns:
- neIfNotBlank
  
  public T neIfNotBlank(String column, String value)
  
  where ne 表达式，用 AND 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：
  - neIfNotNull("type", null); 则会忽略这个表达式，不会根据type字段筛选。
  - neIfNotNull("type", 1); 如果前面没有其他表达式，则 AND 会被忽略
  
  Parameters:
  
  column -
  
  value -
  
  Returns:
- or
  
  public T or(String expr)
  
  where 表达式，用OR连接，如下写法都是合法的：
  - or("status = 1")
  - or("status = 1 and id = ?")
  如果前面没有其他表达式，则 OR 会被忽略
  
  Parameters:
  
  expr -
  
  Returns:
- or
  
  public T or(String expr, Object... values)
  
  where 表达式，带参数值，用 OR 连接，如下写法都是合法的：
  - or("id = ?", id)
  - or("status = 1 and classId = ? and score > ?", classId, 60)
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 OR 会被忽略
  
  Parameters:
  
  expr -
  
  values -
  
  Returns:
- or
  
  public T or(String column, Oper op, Object value)
  
  where 表达式，用 OR 连接，例如：
  - or("col1", Oper.EQ, val)
  in表达式请使用 #in(String, List, String)
  like表达式请使用 #like(String, String, String)
  如果前面没有其他表达式，则 OR 会被忽略
  
  Parameters:
  
  column -
  
  op -
  
  value -
  
  Returns:
- orIf
  
  public T orIf(boolean cnd, String expr, Object... values)
  
  where 表达式，用 OR 连接，根据传入条件，当为false时，则忽略此查询条件
  - orIf(false, "type=?", 1); 则会忽略这个表达式，不会根据type字段筛选。
  - orIf(true, "type=? or type=?", 1, 2); type= 1||2的记录会被筛选出来。
  in表达式请使用 #in(String, List, String)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 OR 会被忽略
  
  Parameters:
  
  cnd -
  
  expr -
  
  values -
  
  Returns:
- orIf
  
  public T orIf(boolean cnd, String column, Oper op, Object value)
  
  where 表达式，用 OR 连接，根据传入条件，当为false时，则忽略此查询条件
  - orIf(false, "type", “=”, 1); 则会忽略这个表达式，不会根据type字段筛选。
  - orIf(true, "type", Oper.EQ, 1, 2); type= 1||2的记录会被筛选出来。
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 OR 会被忽略
  
  Parameters:
  
  cnd -
  
  column -
  
  op -
  
  value -
  
  Returns:
- orIfNotNull
  
  public T orIfNotNull(String expr, Object value)
  
  where 表达式，用 OR 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：
  - orIfNotNull("type = ?", null); 则会忽略这个表达式，不会根据type字段筛选。
  - orIfNotNull("type = ?", 1);
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 OR 会被忽略
  
  Parameters:
  
  expr -
  
  value -
  
  Returns:
- orIfNotNull
  
  public T orIfNotNull(String column, Oper op, Object value)
  
  where 表达式，用 OR 连接，判断值不为null时，表达式才被采用，否则表达式会被丢弃：
  - orIfNotNull("type", Oper.EQ, null); 则会忽略这个表达式，不会根据type字段筛选。
  - orIfNotNull("type", Oper.EQ, 1);
  in表达式请使用 #in(String, List)
  like表达式请使用 like(String, String)
  如果前面没有其他表达式，则 OR 会被忽略
  
  Parameters:
  
  column -
  
  op -
  
  value -
  
  Returns:
- between
  
  public T between(String column, Number start, Number end)
  
  where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：
  - 如果value为blank，则会忽略此条件
  - like("name", "abc");生成的sql为：
  [AND] name like '%abc%';
  默认使用 AND 连接
  部分匹配请使用 startWith(String, String) 或 endWith(String, String)
  
  Parameters:
  
  column -
  
  start -
  
  end -
  
  Returns:
- between
  
  public T between(String column, cn.dinodev.spring.commons.data.Range<?> range)
  
  where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：
  - 如果value为blank，则会忽略此条件
  - like("name", "abc");生成的sql为：
  [AND] name like '%abc%';
  默认使用 AND 连接
  部分匹配请使用 startWith(String, String) 或 endWith(String, String)
  
  Parameters:
  
  column -
  
  start -
  
  end -
  
  Returns:
- any
  
  public T any(String column, T subQuery)
  
  where 表达式中的 ANY 函数，其参数为一个子查询，如下：
  - any("id", "select id from student where classId=1"),生成的sql为：
  [AND] id = any(subquery sql)
  默认使用 AND 连接
  
  Parameters:
  
  column -
  
  subQuery -
  
  Returns:
- any
  
  public T any(String column, T subQuery, Logic logic)
  
  where 表达式中的 ANY 函数，其参数为一个子查询，如下：
  - any("id", "select id from student where classId=1", "OR"),生成的sql为：
  [OR] id = any(subquery sql)
  使用 logic 逻辑符连接，如果前面没有任何条件表达式，则 logic 会被忽略
  
  Parameters:
  
  column -
  
  subQuery -
  
  logic -
  
  Returns:
- some
  
  public T some(String[] columns, Oper op, Object value, Logic logic)
  
  任意列LIKE %value%：
  - 如果value为blank，则会忽略此条件
  
  - 如 some(["col1", "col2"], Oper.EQ "a", Logic.AND) 则转化为 AND ( col1 = 'a' OR col2 = 'a')
  
  - 如 some(["col1", "col2"], Oper.EQ, "a", Logic.OR) 则转化为 OR ( col1 = 'a' OR col2 = 'a')
  
  Parameters:
  
  columns - 多个列
  
  op - 操作符
  
  value - 关键字
  
  logic - 外围逻辑
  
  Returns:
- some
  
  public T some(String[] columns, Oper op, Object value)
  
  AND 任意列LIKE %value%:
  - 如果value为blank，则会忽略此条件
  
  - 如 some(["col1", "col2"], Oper.EQ, "a") 则转化为 AND ( col1 = 'a' OR col2 = 'a')
  
  Parameters:
  
  columns - 多个列
  
  op - 操作符
  
  value - 关键字
  
  Returns:
- someIf
  
  public T someIf(boolean cnd, String[] columns, Oper op, Object value, Logic logic)
  
  任意列LIKE %value%：
  - 如果value为blank，则会忽略此条件
  
  - 如 some(["col1", "col2"], Oper.EQ "a", Logic.AND) 则转化为 AND ( col1 = 'a' OR col2 = 'a')
  
  - 如 some(["col1", "col2"], Oper.EQ, "a", Logic.OR) 则转化为 OR ( col1 = 'a' OR col2 = 'a')
  
  Parameters:
  
  cnd - 条件
  
  columns - 多个列
  
  op - 操作符
  
  value - 关键字
  
  logic - 外围逻辑
  
  Returns:
- someIf
  
  public T someIf(boolean cnd, String[] columns, Oper op, String value)
  
  AND 任意列 [op] [value]:
  - 如果value为blank，则会忽略此条件
  
  - 如 some(["col1", "col2"], Oper.EQ, "a") 则转化为 AND ( col1 = 'a' OR col2 = 'a')
  
  Parameters:
  
  cnd - 条件
  
  columns - 多个列
  
  op - 操作符
  
  value - 关键字
  
  Returns:
- in
  
  public T in(String column, Collection<?> values)
  
  where 表达式中的 IN 语句，其参数为数组，按照如下处理逻辑：
  - 如果数组为空，则会忽略此条件
  - 如果数组长度为1，则用=操作符替代
  - in("type", typesList);
  默认使用 AND 连接
  
  Parameters:
  
  column -
  
  values -
  
  Returns:
- inIf
  
  public T inIf(boolean cnd, String column, Collection<?> values)
  
  where 表达式中的 IN 语句，根据传入条件，当为false时，则忽略此查询条件. 其参数为数组，按照如下处理逻辑：
  - 如果数组为空，则会忽略此条件
  - 如果数组长度为1，则用=操作符替代
  - inIf(true, "type", typesList);
  默认使用 AND 连接
  
  Parameters:
  
  cnd -
  
  column -
  
  values -
  
  Returns:
- in
  
  public T in(String column, Collection<?> values, Logic logic)
  
  where 表达式中的 IN 语句，其参数为数组，按照如下处理逻辑：
  - 如果数组为空，则会忽略此条件
  - 如果数组长度为1，则用=操作符替代
  - in("type", typesList, "OR");
  使用 logic 逻辑符连接，如果前面没有任何条件表达式，则 logic 会被忽略
  
  Parameters:
  
  column -
  
  values -
  
  logic -
  
  Returns:
- in
  
  public T in(String column, Object[] values)
  
  where 表达式中的 IN 语句，其参数为数组，按照如下处理逻辑：
  - 如果数组为空，则会忽略此条件
  - 如果数组长度为1，则用=操作符替代
  - in("type", typesArray);
  默认使用 AND 连接
  
  Parameters:
  
  column -
  
  values -
  
  Returns:
- inIf
  
  public T inIf(boolean cnd, String column, Object[] values)
  
  where 表达式中的 IN 语句，根据传入条件，当为false时，则忽略此查询条件. 其参数为数组，按照如下处理逻辑：
  - 如果数组为空，则会忽略此条件
  - 如果数组长度为1，则用=操作符替代
  - inIf(true, "type", typesArray);
  默认使用 AND 连接
  
  Parameters:
  
  cnd -
  
  column -
  
  values -
  
  Returns:
- in
  
  public T in(String column, Object[] values, Logic logic)
  
  where 表达式中的 IN 语句，其参数为数组，按照如下处理逻辑：
  - 如果数组为空，则会忽略此条件
  - 如果数组长度为1，则用=操作符替代
  - in("type", typesArray, "OR");
  使用 logic 逻辑符连接，如果前面没有任何条件表达式，则 logic 会被忽略
  
  Parameters:
  
  column -
  
  values -
  
  logic -
  
  Returns:
- notIn
  
  public T notIn(String column, Collection<?> values)
  
  where 表达式中的 NOT IN 语句，其参数为数组，按照如下处理逻辑：
  - 如果数组为空，则会忽略此条件
  - 如果数组长度为1，则用=操作符替代
  - not in("type", typesList);
  默认使用 AND 连接
  
  Parameters:
  
  column -
  
  values -
  
  Returns:
- notIn
  
  public T notIn(String column, Collection<?> values, Logic logic)
  
  where 表达式中的 NOT IN 语句，其参数为数组，按照如下处理逻辑：
  - 如果数组为空，则会忽略此条件
  - 如果数组长度为1，则用=操作符替代
  - not in("type", typesList, "OR");
  使用 logic 逻辑符连接，如果前面没有任何条件表达式，则 logic 会被忽略
  
  Parameters:
  
  column -
  
  values -
  
  logic -
  
  Returns:
- notIn
  
  public T notIn(String column, Object[] values)
  
  where 表达式中的 NOT IN 语句，其参数为数组，按照如下处理逻辑：
  - 如果数组为空，则会忽略此条件
  - 如果数组长度为1，则用!=操作符替代
  - notIn("type", typesArray);
  默认使用 AND 连接
  
  Parameters:
  
  column -
  
  values -
  
  Returns:
- notIn
  
  public T notIn(String column, Object[] values, Logic logic)
  
  where 表达式中的 IN 语句，其参数为数组，按照如下处理逻辑：
  - 如果数组为空，则会忽略此条件
  - 如果数组长度为1，则用!=操作符替代
  - notIn("type", typesArray, "OR");
  使用 logic 逻辑符连接，如果前面没有任何条件表达式，则 logic 会被忽略
  
  Parameters:
  
  column -
  
  values -
  
  logic -
  
  Returns:
- isNull
  
  public T isNull(String column)
  
  [AND] column IS NULL
  
  Parameters:
  
  column - 列名
  
  Returns:
- isNull
  
  public T isNull(String column, Logic logic)
  
  [AND|OR] column IS NULL
  
  Parameters:
  
  column - 列名
  
  logic - 外部逻辑符
  
  Returns:
- isNullIf
  
  public T isNullIf(boolean cnd, String column)
  
  如果条件成立，则为[AND] column IS NULL，否则忽略
  
  Parameters:
  
  cnd - 条件
  
  column - 列名
  
  Returns:
- isNullIf
  
  public T isNullIf(boolean cnd, String column, Logic logic)
  
  如果条件成立，则为[AND|OR] column IS NULL，否则忽略
  
  Parameters:
  
  cnd - 条件
  
  column - 列名
  
  logic - 外部逻辑符
  
  Returns:
- isNotNull
  
  public T isNotNull(String column)
  
  [AND] column IS NOT NULL
  
  Parameters:
  
  column - 列名
  
  Returns:
- isNotNull
  
  public T isNotNull(String column, Logic logic)
  
  [AND|OR] column IS NOT NULL
  
  Parameters:
  
  column - 列名
  
  logic - 外部逻辑符
  
  Returns:
- isNotNullIf
  
  public T isNotNullIf(boolean cnd, String column)
  
  如果条件成立，则为[AND] column IS NOT NULL，否则忽略
  
  Parameters:
  
  cnd - 条件
  
  column - 列名
  
  Returns:
- isNotNullIf
  
  public T isNotNullIf(boolean cnd, String column, Logic logic)
  
  如果条件成立，则为[AND|OR] column IS NOT NULL，否则忽略
  
  Parameters:
  
  cnd - 条件
  
  column - 列名
  
  logic - 外部逻辑符
  
  Returns:
- like
  
  public T like(String column, String value)
  
  where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：
  - 如果value为blank，则会忽略此条件
  - like("name", "abc");生成的sql为：
  [AND] name like '%abc%';
  默认使用 AND 连接
  部分匹配请使用 startWith(String, String) 或 endWith(String, String)
  
  Parameters:
  
  column -
  
  value -
  
  Returns:
- like
  
  public T like(String column, String value, Logic logic)
  
  where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：
  - 如果value为blank，则会忽略此条件
  - like("name", "abc", "OR");生成的sql为：
  [OR] name like '%abc%';
  使用 logic 逻辑符连接，如果前面没有任何条件表达式，则 logic 会被忽略
  部分匹配请使用 startWith(String, String) 或 endWith(String, String)
  
  Parameters:
  
  column -
  
  value -
  
  logic -
  
  Returns:
- someLike
  
  public T someLike(String[] columns, String value, Logic logic)
  
  任意列LIKE %value%：
  - 如果value为blank，则会忽略此条件
  
  - 如 someLike(["col1", "col2", "a", Logic.AND]) 则转化为 AND ( col1 LIKE '%a%' OR col2 LIKE '%a%')
  
  - 如 someLike(["col1", "col2", "a", Logic.OR]) 则转化为 OR ( col1 LIKE '%a%' OR col2 LIKE '%a%')
  
  Parameters:
  
  columns - 多个列
  
  value - 关键字
  
  logic - 外围逻辑
  
  Returns:
- someLike
  
  public T someLike(String[] columns, String value)
  
  AND 任意列LIKE %value%:
  - 如果value为blank，则会忽略此条件
  
  如 someLike(["col1", "col2", "a") 则转化为 AND ( col1 LIKE '%a%' OR col2 LIKE '%a%')
  
  Parameters:
  
  columns - 多个列
  
  value - 关键字
  
  Returns:
- startWith
  
  public T startWith(String column, String value)
  
  where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：
  - 如果value为blank，则会忽略此条件
  - startWith("name", "abc");生成的sql为：
  [AND] name like 'abc%';
  默认使用 AND 连接
  全匹配或部分匹配请使用 like(String, String) 或 endWith(String, String)
  
  Parameters:
  
  column -
  
  value -
  
  Returns:
- startWith
  
  public T startWith(String column, String value, Logic logic)
  
  where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：
  - 如果value为blank，则会忽略此条件
  - startWith("name", "abc", "OR");生成的sql为：
  [OR] name like 'abc%';
  使用 logic 逻辑符连接，如果前面没有任何条件表达式，则 logic 会被忽略
  全匹配或部分匹配请使用 like(String, String) 或 endWith(String, String)
  
  Parameters:
  
  column -
  
  value -
  
  logic -
  
  Returns:
- someStartWith
  
  public T someStartWith(String[] columns, String value, Logic logic)
  
  任意列LIKE value%：
  - 如果value为blank，则会忽略此条件
  
  - 如 someStartWith(["col1", "col2", "a", Logic.AND]) 则转化为 AND ( col1 LIKE 'a%' OR col2 LIKE 'a%')
  
  - 如 someStartWith(["col1", "col2", "a", Logic.OR]) 则转化为 OR ( col1 LIKE 'a%' OR col2 LIKE 'a%')
  
  Parameters:
  
  columns - 多个列
  
  value - 关键字
  
  logic - 外围逻辑
  
  Returns:
- someStartWith
  
  public T someStartWith(String[] columns, String value)
  
  AND 任意列LIKE value%:
  - 如果value为blank，则会忽略此条件
  
  如 someStartWith(["col1", "col2", "a") 则转化为 AND ( col1 LIKE 'a%' OR col2 LIKE 'a%')
  
  Parameters:
  
  columns - 多个列
  
  value - 关键字
  
  Returns:
- endWith
  
  public T endWith(String column, String value)
  
  where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：
  - 如果value为blank，则会忽略此条件
  - endWith("name", "abc"); //生成的sql为：
  [AND] name like '%abc';
  默认使用 AND 连接
  全匹配或部分匹配请使用 like(String, String) 或 startWith(String, String)
  
  Parameters:
  
  column -
  
  value -
  
  Returns:
- endWith
  
  public T endWith(String column, String value, Logic logic)
  
  where 表达式中的 LIKE 语句，其参数为数组，按照如下处理逻辑：
  - 如果value为blank，则会忽略此条件
  - endWith("name", "abc", "OR"); //生成的sql为：
  [OR] name like '%abc';
  使用 logic 逻辑符连接，如果前面没有任何条件表达式，则 logic 会被忽略
  全匹配或部分匹配请使用 like(String, String) 或 startWith(String, String)
  
  Parameters:
  
  column -
  
  value -
  
  logic -
  
  Returns:
- someEndWith
  
  public T someEndWith(String[] columns, String value, Logic logic)
  
  任意列LIKE %value：
  - 如果value为blank，则会忽略此条件
  
  - 如 someEndWith(["col1", "col2", "a", Logic.AND]) 则转化为 AND ( col1 LIKE '%a' OR col2 LIKE '%a')
  
  - 如 someEndWith(["col1", "col2", "a", Logic.OR]) 则转化为 OR ( col1 LIKE '%a' OR col2 LIKE '%a')
  
  Parameters:
  
  columns - 多个列
  
  value - 关键字
  
  logic - 外围逻辑
  
  Returns:
- someEndWith
  
  public T someEndWith(String[] columns, String value)
  
  AND 任意列LIKE %value:
  - 如果value为blank，则会忽略此条件
  
  如 someEndWith(["col1", "col2", "a") 则转化为 AND ( col1 LIKE '%a' OR col2 LIKE '%a')
  
  Parameters:
  
  columns - 多个列
  
  value - 关键字
  
  Returns:

Class WhereSql<T extends SqlBuilder>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface cn.dinodev.spring.data.sql.SqlBuilder

Field Details

EMPTY_PARAMS

tables

whereColumns

whereParams

withSql

withName

Constructor Details

WhereSql

Method Details

setThat

table

with

where

where

where

whereIfNotNull

whereIfNotNull

whereIf

whereIf

and

and

and

andIf

andIf

andIfNotNull

andIfNotNull

eq

eqIf

eqIfNotNull

eqIfNotBlank

ne

neIf

neIfNotNull

neIfNotBlank

or

or

or

orIf

orIf

orIfNotNull

orIfNotNull

between

between

any

any

some

some

someIf

someIf

in

inIf

in

in

inIf

in

notIn

notIn

notIn

notIn

isNull

isNull

isNullIf

isNullIf

isNotNull

isNotNull

isNotNullIf

isNotNullIf

like

like

someLike

someLike

startWith

startWith