SqlBuilder (MyBatis Dynamic SQL 1.3.0 API)

```
public interface SqlBuilder
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class SqlBuilder.InsertIntoNextStep

Nested Classes
Modifier and Type	Interface and Description
`static class`	`SqlBuilder.InsertIntoNextStep`

Method Summary

All Methods Static Methods Default Methods
Modifier and Type	Method and Description
`static <T> Add<T>`	`add(BindableColumn<T> firstColumn, BasicColumn secondColumn, BasicColumn... subsequentColumns)`
`static JoinCriterion`	`and(BasicColumn joinColumn, JoinCondition joinCondition)`
`static <T> SqlCriterion`	`and(BindableColumn<T> column, VisitableCondition<T> condition)`
`static <T> SqlCriterion`	`and(BindableColumn<T> column, VisitableCondition<T> condition, SqlCriterion... subCriteria)`
`static SqlCriterion`	`and(ExistsPredicate existsPredicate)`
`static SqlCriterion`	`and(ExistsPredicate existsPredicate, SqlCriterion... subCriteria)`
`static <T> OperatorFunction<T>`	`applyOperator(String operator, BindableColumn<T> firstColumn, BasicColumn secondColumn, BasicColumn... subsequentColumns)`
`static <T> Avg<T>`	`avg(BindableColumn<T> column)`
`static <T> Concatenate<T>`	`concatenate(BindableColumn<T> firstColumn, BasicColumn secondColumn, BasicColumn... subsequentColumns)`
`static <T> Constant<T>`	`constant(String constant)`
`static CountAll`	`count()`
`static Count`	`count(BasicColumn column)`
`static CountDSL.FromGatherer<SelectModel>`	`countColumn(BasicColumn column)` Renders as select count(column) from table...
`static CountDistinct`	`countDistinct(BasicColumn column)`
`static CountDSL.FromGatherer<SelectModel>`	`countDistinctColumn(BasicColumn column)` Renders as select count(distinct column) from table...
`static CountDSL<SelectModel>`	`countFrom(SqlTable table)` Renders as select count(*) from table...
`static DeleteDSL<DeleteModel>`	`deleteFrom(SqlTable table)`
`static <T> Divide<T>`	`divide(BindableColumn<T> firstColumn, BasicColumn secondColumn, BasicColumn... subsequentColumns)`
`static EqualTo`	`equalTo(BasicColumn column)`
`static ExistsPredicate`	`exists(Buildable<SelectModel> selectModelBuilder)`
`static <T> InsertDSL.IntoGatherer<T>`	`insert(T row)`
`static <T> BatchInsertDSL.IntoGatherer<T>`	`insertBatch(Collection<T> records)` Insert a Batch of records.
`static <T> BatchInsertDSL.IntoGatherer<T>`	`insertBatch(T... records)` Insert a Batch of records.
`static SqlBuilder.InsertIntoNextStep`	`insertInto(SqlTable table)`
`static <T> MultiRowInsertDSL.IntoGatherer<T>`	`insertMultiple(Collection<T> records)` Insert multiple records in a single statement.
`static <T> MultiRowInsertDSL.IntoGatherer<T>`	`insertMultiple(T... records)` Insert multiple records in a single statement.
`static <T> IsBetween.Builder<T>`	`isBetween(Supplier<T> valueSupplier1)`
`static <T> IsBetween.Builder<T>`	`isBetween(T value1)`
`static <T> IsBetween.WhenPresentBuilder<T>`	`isBetweenWhenPresent(Supplier<T> valueSupplier1)`
`static <T> IsBetween.WhenPresentBuilder<T>`	`isBetweenWhenPresent(T value1)`
`static <T> IsEqualToColumn<T>`	`isEqualTo(BasicColumn column)`
`static <T> IsEqualToWithSubselect<T>`	`isEqualTo(Buildable<SelectModel> selectModelBuilder)`
`static <T> IsEqualTo<T>`	`isEqualTo(Supplier<T> valueSupplier)`
`static <T> IsEqualTo<T>`	`isEqualTo(T value)`
`static <T> IsEqualTo<T>`	`isEqualToWhenPresent(Supplier<T> valueSupplier)`
`static <T> IsEqualTo<T>`	`isEqualToWhenPresent(T value)`
`static IsEqualTo<Boolean>`	`isFalse()`
`static <T> IsGreaterThanColumn<T>`	`isGreaterThan(BasicColumn column)`
`static <T> IsGreaterThanWithSubselect<T>`	`isGreaterThan(Buildable<SelectModel> selectModelBuilder)`
`static <T> IsGreaterThan<T>`	`isGreaterThan(Supplier<T> valueSupplier)`
`static <T> IsGreaterThan<T>`	`isGreaterThan(T value)`
`static <T> IsGreaterThanOrEqualToColumn<T>`	`isGreaterThanOrEqualTo(BasicColumn column)`
`static <T> IsGreaterThanOrEqualToWithSubselect<T>`	`isGreaterThanOrEqualTo(Buildable<SelectModel> selectModelBuilder)`
`static <T> IsGreaterThanOrEqualTo<T>`	`isGreaterThanOrEqualTo(Supplier<T> valueSupplier)`
`static <T> IsGreaterThanOrEqualTo<T>`	`isGreaterThanOrEqualTo(T value)`
`static <T> IsGreaterThanOrEqualTo<T>`	`isGreaterThanOrEqualToWhenPresent(Supplier<T> valueSupplier)`
`static <T> IsGreaterThanOrEqualTo<T>`	`isGreaterThanOrEqualToWhenPresent(T value)`
`static <T> IsGreaterThan<T>`	`isGreaterThanWhenPresent(Supplier<T> valueSupplier)`
`static <T> IsGreaterThan<T>`	`isGreaterThanWhenPresent(T value)`
`static <T> IsInWithSubselect<T>`	`isIn(Buildable<SelectModel> selectModelBuilder)`
`static <T> IsIn<T>`	`isIn(Collection<T> values)`
`static <T> IsIn<T>`	`isIn(T... values)`
`static IsInCaseInsensitive`	`isInCaseInsensitive(Collection<String> values)`
`static IsInCaseInsensitive`	`isInCaseInsensitive(String... values)`
`static IsInCaseInsensitive`	`isInCaseInsensitiveWhenPresent(Collection<String> values)`
`static IsInCaseInsensitive`	`isInCaseInsensitiveWhenPresent(String... values)`
`static <T> IsIn<T>`	`isInWhenPresent(Collection<T> values)`
`static <T> IsIn<T>`	`isInWhenPresent(T... values)`
`static <T> IsLessThanColumn<T>`	`isLessThan(BasicColumn column)`
`static <T> IsLessThanWithSubselect<T>`	`isLessThan(Buildable<SelectModel> selectModelBuilder)`
`static <T> IsLessThan<T>`	`isLessThan(Supplier<T> valueSupplier)`
`static <T> IsLessThan<T>`	`isLessThan(T value)`
`static <T> IsLessThanOrEqualToColumn<T>`	`isLessThanOrEqualTo(BasicColumn column)`
`static <T> IsLessThanOrEqualToWithSubselect<T>`	`isLessThanOrEqualTo(Buildable<SelectModel> selectModelBuilder)`
`static <T> IsLessThanOrEqualTo<T>`	`isLessThanOrEqualTo(Supplier<T> valueSupplier)`
`static <T> IsLessThanOrEqualTo<T>`	`isLessThanOrEqualTo(T value)`
`static <T> IsLessThanOrEqualTo<T>`	`isLessThanOrEqualToWhenPresent(Supplier<T> valueSupplier)`
`static <T> IsLessThanOrEqualTo<T>`	`isLessThanOrEqualToWhenPresent(T value)`
`static <T> IsLessThan<T>`	`isLessThanWhenPresent(Supplier<T> valueSupplier)`
`static <T> IsLessThan<T>`	`isLessThanWhenPresent(T value)`
`static <T> IsLike<T>`	`isLike(Supplier<T> valueSupplier)`
`static <T> IsLike<T>`	`isLike(T value)`
`static IsLikeCaseInsensitive`	`isLikeCaseInsensitive(String value)`
`static IsLikeCaseInsensitive`	`isLikeCaseInsensitive(Supplier<String> valueSupplier)`
`static IsLikeCaseInsensitive`	`isLikeCaseInsensitiveWhenPresent(String value)`
`static IsLikeCaseInsensitive`	`isLikeCaseInsensitiveWhenPresent(Supplier<String> valueSupplier)`
`static <T> IsLike<T>`	`isLikeWhenPresent(Supplier<T> valueSupplier)`
`static <T> IsLike<T>`	`isLikeWhenPresent(T value)`
`static <T> IsNotBetween.Builder<T>`	`isNotBetween(Supplier<T> valueSupplier1)`
`static <T> IsNotBetween.Builder<T>`	`isNotBetween(T value1)`
`static <T> IsNotBetween.WhenPresentBuilder<T>`	`isNotBetweenWhenPresent(Supplier<T> valueSupplier1)`
`static <T> IsNotBetween.WhenPresentBuilder<T>`	`isNotBetweenWhenPresent(T value1)`
`static <T> IsNotEqualToColumn<T>`	`isNotEqualTo(BasicColumn column)`
`static <T> IsNotEqualToWithSubselect<T>`	`isNotEqualTo(Buildable<SelectModel> selectModelBuilder)`
`static <T> IsNotEqualTo<T>`	`isNotEqualTo(Supplier<T> valueSupplier)`
`static <T> IsNotEqualTo<T>`	`isNotEqualTo(T value)`
`static <T> IsNotEqualTo<T>`	`isNotEqualToWhenPresent(Supplier<T> valueSupplier)`
`static <T> IsNotEqualTo<T>`	`isNotEqualToWhenPresent(T value)`
`static <T> IsNotInWithSubselect<T>`	`isNotIn(Buildable<SelectModel> selectModelBuilder)`
`static <T> IsNotIn<T>`	`isNotIn(Collection<T> values)`
`static <T> IsNotIn<T>`	`isNotIn(T... values)`
`static IsNotInCaseInsensitive`	`isNotInCaseInsensitive(Collection<String> values)`
`static IsNotInCaseInsensitive`	`isNotInCaseInsensitive(String... values)`
`static IsNotInCaseInsensitive`	`isNotInCaseInsensitiveWhenPresent(Collection<String> values)`
`static IsNotInCaseInsensitive`	`isNotInCaseInsensitiveWhenPresent(String... values)`
`static <T> IsNotIn<T>`	`isNotInWhenPresent(Collection<T> values)`
`static <T> IsNotIn<T>`	`isNotInWhenPresent(T... values)`
`static <T> IsNotLike<T>`	`isNotLike(Supplier<T> valueSupplier)`
`static <T> IsNotLike<T>`	`isNotLike(T value)`
`static IsNotLikeCaseInsensitive`	`isNotLikeCaseInsensitive(String value)`
`static IsNotLikeCaseInsensitive`	`isNotLikeCaseInsensitive(Supplier<String> valueSupplier)`
`static IsNotLikeCaseInsensitive`	`isNotLikeCaseInsensitiveWhenPresent(String value)`
`static IsNotLikeCaseInsensitive`	`isNotLikeCaseInsensitiveWhenPresent(Supplier<String> valueSupplier)`
`static <T> IsNotLike<T>`	`isNotLikeWhenPresent(Supplier<T> valueSupplier)`
`static <T> IsNotLike<T>`	`isNotLikeWhenPresent(T value)`
`static <T> IsNotNull<T>`	`isNotNull()`
`static <T> IsNull<T>`	`isNull()`
`static IsEqualTo<Boolean>`	`isTrue()`
`static <T> Lower<T>`	`lower(BindableColumn<T> column)`
`static <T> Max<T>`	`max(BindableColumn<T> column)`
`static <T> Min<T>`	`min(BindableColumn<T> column)`
`static <T> Multiply<T>`	`multiply(BindableColumn<T> firstColumn, BasicColumn secondColumn, BasicColumn... subsequentColumns)`
`static ExistsPredicate`	`notExists(Buildable<SelectModel> selectModelBuilder)`
`static JoinCriterion`	`on(BasicColumn joinColumn, JoinCondition joinCondition)`
`static <T> SqlCriterion`	`or(BindableColumn<T> column, VisitableCondition<T> condition)`
`static <T> SqlCriterion`	`or(BindableColumn<T> column, VisitableCondition<T> condition, SqlCriterion... subCriteria)`
`static SqlCriterion`	`or(ExistsPredicate existsPredicate)`
`static SqlCriterion`	`or(ExistsPredicate existsPredicate, SqlCriterion... subCriteria)`
`static QueryExpressionDSL.FromGatherer<SelectModel>`	`select(BasicColumn... selectList)`
`static QueryExpressionDSL.FromGatherer<SelectModel>`	`select(Collection<BasicColumn> selectList)`
`static QueryExpressionDSL.FromGatherer<SelectModel>`	`selectDistinct(BasicColumn... selectList)`
`static QueryExpressionDSL.FromGatherer<SelectModel>`	`selectDistinct(Collection<BasicColumn> selectList)`
`static SortSpecification`	`sortColumn(String name)` Creates a sort specification based on a String.
`static SortSpecification`	`sortColumn(String tableAlias, SqlColumn<?> column)` Creates a sort specification based on a column and a table alias.
`static StringConstant`	`stringConstant(String constant)`
`static <T> Substring<T>`	`substring(BindableColumn<T> column, int offset, int length)`
`static <T> Subtract<T>`	`subtract(BindableColumn<T> firstColumn, BasicColumn secondColumn, BasicColumn... subsequentColumns)`
`static <T> Sum<T>`	`sum(BindableColumn<T> column)`
`static UpdateDSL<UpdateModel>`	`update(SqlTable table)`
`static <T> Upper<T>`	`upper(BindableColumn<T> column)`
`static WhereDSL`	`where()`
`static <T> WhereDSL`	`where(BindableColumn<T> column, VisitableCondition<T> condition)`
`static <T> WhereDSL`	`where(BindableColumn<T> column, VisitableCondition<T> condition, SqlCriterion... subCriteria)`
`static WhereDSL`	`where(ExistsPredicate existsPredicate)`
`static WhereDSL`	`where(ExistsPredicate existsPredicate, SqlCriterion... subCriteria)`

Method Detail

countDistinctColumn
```
static CountDSL.FromGatherer<SelectModel> countDistinctColumn(BasicColumn column)
```
Renders as select count(distinct column) from table...

Parameters:

column - the column to count

Returns:

the next step in the DSL

countColumn
```
static CountDSL.FromGatherer<SelectModel> countColumn(BasicColumn column)
```
Renders as select count(column) from table...

Parameters:

column - the column to count

Returns:

the next step in the DSL

countFrom
```
static CountDSL<SelectModel> countFrom(SqlTable table)
```
Renders as select count(*) from table...

Parameters:

table - the table to count

Returns:

the next step in the DSL

deleteFrom

static DeleteDSL<DeleteModel> deleteFrom(SqlTable table)

insert

static <T> InsertDSL.IntoGatherer<T> insert(T row)

insertBatch
```
@SafeVarargs
static <T> BatchInsertDSL.IntoGatherer<T> insertBatch(T... records)
```
Insert a Batch of records. The model object is structured to support bulk inserts with JDBC batch support.

Type Parameters:

T - the type of record to insert

Parameters:

records - records to insert

Returns:

the next step in the DSL

insertBatch
```
static <T> BatchInsertDSL.IntoGatherer<T> insertBatch(Collection<T> records)
```
Insert a Batch of records. The model object is structured to support bulk inserts with JDBC batch support.

Type Parameters:

T - the type of record to insert

Parameters:

records - records to insert

Returns:

the next step in the DSL

insertMultiple
```
@SafeVarargs
static <T> MultiRowInsertDSL.IntoGatherer<T> insertMultiple(T... records)
```
Insert multiple records in a single statement. The model object is structured as a single insert statement with multiple values clauses. This statement is suitable for use with a small number of records. It is not suitable for large bulk inserts as it is possible to exceed the limit of parameter markers in a prepared statement.
For large bulk inserts, see insertBatch(Object[])

Type Parameters:

T - the type of record to insert

Parameters:

records - records to insert

Returns:

the next step in the DSL

insertMultiple
```
static <T> MultiRowInsertDSL.IntoGatherer<T> insertMultiple(Collection<T> records)
```
Insert multiple records in a single statement. The model object is structured as a single insert statement with multiple values clauses. This statement is suitable for use with a small number of records. It is not suitable for large bulk inserts as it is possible to exceed the limit of parameter markers in a prepared statement.
For large bulk inserts, see insertBatch(Collection)

Type Parameters:

T - the type of record to insert

Parameters:

records - records to insert

Returns:

the next step in the DSL

insertInto

static SqlBuilder.InsertIntoNextStep insertInto(SqlTable table)

select

static QueryExpressionDSL.FromGatherer<SelectModel> select(BasicColumn... selectList)

select

static QueryExpressionDSL.FromGatherer<SelectModel> select(Collection<BasicColumn> selectList)

selectDistinct

static QueryExpressionDSL.FromGatherer<SelectModel> selectDistinct(BasicColumn... selectList)

selectDistinct

static QueryExpressionDSL.FromGatherer<SelectModel> selectDistinct(Collection<BasicColumn> selectList)

update

static UpdateDSL<UpdateModel> update(SqlTable table)

where
```
static WhereDSL where()
```

where

static <T> WhereDSL where(BindableColumn<T> column,
                          VisitableCondition<T> condition)

where

static <T> WhereDSL where(BindableColumn<T> column,
                          VisitableCondition<T> condition,
                          SqlCriterion... subCriteria)

where

static WhereDSL where(ExistsPredicate existsPredicate)

where

static WhereDSL where(ExistsPredicate existsPredicate,
                      SqlCriterion... subCriteria)

or

static <T> SqlCriterion or(BindableColumn<T> column,
                           VisitableCondition<T> condition)

or

static <T> SqlCriterion or(BindableColumn<T> column,
                           VisitableCondition<T> condition,
                           SqlCriterion... subCriteria)

or

static SqlCriterion or(ExistsPredicate existsPredicate)

or

static SqlCriterion or(ExistsPredicate existsPredicate,
                       SqlCriterion... subCriteria)

and

static <T> SqlCriterion and(BindableColumn<T> column,
                            VisitableCondition<T> condition)

and

static <T> SqlCriterion and(BindableColumn<T> column,
                            VisitableCondition<T> condition,
                            SqlCriterion... subCriteria)

and

static SqlCriterion and(ExistsPredicate existsPredicate)

and

static SqlCriterion and(ExistsPredicate existsPredicate,
                        SqlCriterion... subCriteria)

and

static JoinCriterion and(BasicColumn joinColumn,
                         JoinCondition joinCondition)

on

static JoinCriterion on(BasicColumn joinColumn,
                        JoinCondition joinCondition)

equalTo

static EqualTo equalTo(BasicColumn column)

count
```
static CountAll count()
```

count

static Count count(BasicColumn column)

countDistinct

static CountDistinct countDistinct(BasicColumn column)

max

static <T> Max<T> max(BindableColumn<T> column)

min

static <T> Min<T> min(BindableColumn<T> column)

avg

static <T> Avg<T> avg(BindableColumn<T> column)

sum

static <T> Sum<T> sum(BindableColumn<T> column)

constant

static <T> Constant<T> constant(String constant)

stringConstant

static StringConstant stringConstant(String constant)

add

static <T> Add<T> add(BindableColumn<T> firstColumn,
                      BasicColumn secondColumn,
                      BasicColumn... subsequentColumns)

divide

static <T> Divide<T> divide(BindableColumn<T> firstColumn,
                            BasicColumn secondColumn,
                            BasicColumn... subsequentColumns)

multiply

static <T> Multiply<T> multiply(BindableColumn<T> firstColumn,
                                BasicColumn secondColumn,
                                BasicColumn... subsequentColumns)

subtract

static <T> Subtract<T> subtract(BindableColumn<T> firstColumn,
                                BasicColumn secondColumn,
                                BasicColumn... subsequentColumns)

concatenate

static <T> Concatenate<T> concatenate(BindableColumn<T> firstColumn,
                                      BasicColumn secondColumn,
                                      BasicColumn... subsequentColumns)

applyOperator

static <T> OperatorFunction<T> applyOperator(String operator,
                                             BindableColumn<T> firstColumn,
                                             BasicColumn secondColumn,
                                             BasicColumn... subsequentColumns)

lower

static <T> Lower<T> lower(BindableColumn<T> column)

substring

static <T> Substring<T> substring(BindableColumn<T> column,
                                  int offset,
                                  int length)

upper

static <T> Upper<T> upper(BindableColumn<T> column)

exists

static ExistsPredicate exists(Buildable<SelectModel> selectModelBuilder)

notExists

static ExistsPredicate notExists(Buildable<SelectModel> selectModelBuilder)

isNull
```
static <T> IsNull<T> isNull()
```

isNotNull
```
static <T> IsNotNull<T> isNotNull()
```

isEqualTo

static <T> IsEqualTo<T> isEqualTo(T value)

isEqualTo

static <T> IsEqualTo<T> isEqualTo(Supplier<T> valueSupplier)

isEqualTo

static <T> IsEqualToWithSubselect<T> isEqualTo(Buildable<SelectModel> selectModelBuilder)

isEqualTo

static <T> IsEqualToColumn<T> isEqualTo(BasicColumn column)

isEqualToWhenPresent

static <T> IsEqualTo<T> isEqualToWhenPresent(T value)

isEqualToWhenPresent

static <T> IsEqualTo<T> isEqualToWhenPresent(Supplier<T> valueSupplier)

isNotEqualTo

static <T> IsNotEqualTo<T> isNotEqualTo(T value)

isNotEqualTo

static <T> IsNotEqualTo<T> isNotEqualTo(Supplier<T> valueSupplier)

isNotEqualTo

static <T> IsNotEqualToWithSubselect<T> isNotEqualTo(Buildable<SelectModel> selectModelBuilder)

isNotEqualTo

static <T> IsNotEqualToColumn<T> isNotEqualTo(BasicColumn column)

isNotEqualToWhenPresent

static <T> IsNotEqualTo<T> isNotEqualToWhenPresent(T value)

isNotEqualToWhenPresent

static <T> IsNotEqualTo<T> isNotEqualToWhenPresent(Supplier<T> valueSupplier)

isGreaterThan

static <T> IsGreaterThan<T> isGreaterThan(T value)

isGreaterThan

static <T> IsGreaterThan<T> isGreaterThan(Supplier<T> valueSupplier)

isGreaterThan

static <T> IsGreaterThanWithSubselect<T> isGreaterThan(Buildable<SelectModel> selectModelBuilder)

isGreaterThan

static <T> IsGreaterThanColumn<T> isGreaterThan(BasicColumn column)

isGreaterThanWhenPresent

static <T> IsGreaterThan<T> isGreaterThanWhenPresent(T value)

isGreaterThanWhenPresent

static <T> IsGreaterThan<T> isGreaterThanWhenPresent(Supplier<T> valueSupplier)

isGreaterThanOrEqualTo

static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(T value)

isGreaterThanOrEqualTo

static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(Supplier<T> valueSupplier)

isGreaterThanOrEqualTo

static <T> IsGreaterThanOrEqualToWithSubselect<T> isGreaterThanOrEqualTo(Buildable<SelectModel> selectModelBuilder)

isGreaterThanOrEqualTo

static <T> IsGreaterThanOrEqualToColumn<T> isGreaterThanOrEqualTo(BasicColumn column)

isGreaterThanOrEqualToWhenPresent

static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualToWhenPresent(T value)

isGreaterThanOrEqualToWhenPresent

static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualToWhenPresent(Supplier<T> valueSupplier)

isLessThan

static <T> IsLessThan<T> isLessThan(T value)

isLessThan

static <T> IsLessThan<T> isLessThan(Supplier<T> valueSupplier)

isLessThan

static <T> IsLessThanWithSubselect<T> isLessThan(Buildable<SelectModel> selectModelBuilder)

isLessThan

static <T> IsLessThanColumn<T> isLessThan(BasicColumn column)

isLessThanWhenPresent

static <T> IsLessThan<T> isLessThanWhenPresent(T value)

isLessThanWhenPresent

static <T> IsLessThan<T> isLessThanWhenPresent(Supplier<T> valueSupplier)

isLessThanOrEqualTo

static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualTo(T value)

isLessThanOrEqualTo

static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualTo(Supplier<T> valueSupplier)

isLessThanOrEqualTo

static <T> IsLessThanOrEqualToWithSubselect<T> isLessThanOrEqualTo(Buildable<SelectModel> selectModelBuilder)

isLessThanOrEqualTo

static <T> IsLessThanOrEqualToColumn<T> isLessThanOrEqualTo(BasicColumn column)

isLessThanOrEqualToWhenPresent

static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualToWhenPresent(T value)

isLessThanOrEqualToWhenPresent

static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualToWhenPresent(Supplier<T> valueSupplier)

isIn

@SafeVarargs
static <T> IsIn<T> isIn(T... values)

isIn

static <T> IsIn<T> isIn(Collection<T> values)

isIn

static <T> IsInWithSubselect<T> isIn(Buildable<SelectModel> selectModelBuilder)

isInWhenPresent

@SafeVarargs
static <T> IsIn<T> isInWhenPresent(T... values)

isInWhenPresent

static <T> IsIn<T> isInWhenPresent(Collection<T> values)

isNotIn

@SafeVarargs
static <T> IsNotIn<T> isNotIn(T... values)

isNotIn

static <T> IsNotIn<T> isNotIn(Collection<T> values)

isNotIn

static <T> IsNotInWithSubselect<T> isNotIn(Buildable<SelectModel> selectModelBuilder)

isNotInWhenPresent

@SafeVarargs
static <T> IsNotIn<T> isNotInWhenPresent(T... values)

isNotInWhenPresent

static <T> IsNotIn<T> isNotInWhenPresent(Collection<T> values)

isBetween

static <T> IsBetween.Builder<T> isBetween(T value1)

isBetween

static <T> IsBetween.Builder<T> isBetween(Supplier<T> valueSupplier1)

isBetweenWhenPresent

static <T> IsBetween.WhenPresentBuilder<T> isBetweenWhenPresent(T value1)

isBetweenWhenPresent

static <T> IsBetween.WhenPresentBuilder<T> isBetweenWhenPresent(Supplier<T> valueSupplier1)

isNotBetween

static <T> IsNotBetween.Builder<T> isNotBetween(T value1)

isNotBetween

static <T> IsNotBetween.Builder<T> isNotBetween(Supplier<T> valueSupplier1)

isNotBetweenWhenPresent

static <T> IsNotBetween.WhenPresentBuilder<T> isNotBetweenWhenPresent(T value1)

isNotBetweenWhenPresent

static <T> IsNotBetween.WhenPresentBuilder<T> isNotBetweenWhenPresent(Supplier<T> valueSupplier1)

isLike

static <T> IsLike<T> isLike(T value)

isLike

static <T> IsLike<T> isLike(Supplier<T> valueSupplier)

isLikeWhenPresent

static <T> IsLike<T> isLikeWhenPresent(T value)

isLikeWhenPresent

static <T> IsLike<T> isLikeWhenPresent(Supplier<T> valueSupplier)

isNotLike

static <T> IsNotLike<T> isNotLike(T value)

isNotLike

static <T> IsNotLike<T> isNotLike(Supplier<T> valueSupplier)

isNotLikeWhenPresent

static <T> IsNotLike<T> isNotLikeWhenPresent(T value)

isNotLikeWhenPresent

static <T> IsNotLike<T> isNotLikeWhenPresent(Supplier<T> valueSupplier)

isTrue
```
static IsEqualTo<Boolean> isTrue()
```

isFalse
```
static IsEqualTo<Boolean> isFalse()
```

isLikeCaseInsensitive

static IsLikeCaseInsensitive isLikeCaseInsensitive(String value)

isLikeCaseInsensitive

static IsLikeCaseInsensitive isLikeCaseInsensitive(Supplier<String> valueSupplier)

isLikeCaseInsensitiveWhenPresent

static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(String value)

isLikeCaseInsensitiveWhenPresent

static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(Supplier<String> valueSupplier)

isNotLikeCaseInsensitive

static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(String value)

isNotLikeCaseInsensitive

static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(Supplier<String> valueSupplier)

isNotLikeCaseInsensitiveWhenPresent

static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(String value)

isNotLikeCaseInsensitiveWhenPresent

static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(Supplier<String> valueSupplier)

isInCaseInsensitive

static IsInCaseInsensitive isInCaseInsensitive(String... values)

isInCaseInsensitive

static IsInCaseInsensitive isInCaseInsensitive(Collection<String> values)

isInCaseInsensitiveWhenPresent

static IsInCaseInsensitive isInCaseInsensitiveWhenPresent(String... values)

isInCaseInsensitiveWhenPresent

static IsInCaseInsensitive isInCaseInsensitiveWhenPresent(Collection<String> values)

isNotInCaseInsensitive

static IsNotInCaseInsensitive isNotInCaseInsensitive(String... values)

isNotInCaseInsensitive

static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection<String> values)

isNotInCaseInsensitiveWhenPresent

static IsNotInCaseInsensitive isNotInCaseInsensitiveWhenPresent(String... values)

isNotInCaseInsensitiveWhenPresent

static IsNotInCaseInsensitive isNotInCaseInsensitiveWhenPresent(Collection<String> values)

sortColumn
```
static SortSpecification sortColumn(String name)
```
Creates a sort specification based on a String. This is useful when a column has been aliased in the select list. For example:
```
     select(foo.as("bar"))
     .from(baz)
     .orderBy(sortColumn("bar"))
 
```
Parameters:

name - the string to use as a sort specification

Returns:

a sort specification

sortColumn
```
static SortSpecification sortColumn(String tableAlias,
                                    SqlColumn<?> column)
```
Creates a sort specification based on a column and a table alias. This can be useful in a join where the desired sort order is based on a column not in the select list. This will likely fail in union queries depending on database support.

Parameters:

tableAlias - the table alias

column - the column

Returns:

a sort specification

Interface SqlBuilder

Nested Class Summary

Method Summary

Method Detail

countDistinctColumn

countColumn

countFrom

deleteFrom

insert

insertBatch

insertBatch

insertMultiple

insertMultiple

insertInto

select

select

selectDistinct

selectDistinct

update

where

where

where

where

where

or

or

or

or

and

and

and

and

and

on

equalTo

count

count

countDistinct

max

min

avg

sum

constant

stringConstant

add

divide

multiply

subtract

concatenate

applyOperator

lower

substring

upper

exists

notExists

isNull

isNotNull

isEqualTo

isEqualTo

isEqualTo

isEqualTo

isEqualToWhenPresent

isEqualToWhenPresent

isNotEqualTo

isNotEqualTo

isNotEqualTo

isNotEqualTo

isNotEqualToWhenPresent

isNotEqualToWhenPresent

isGreaterThan

isGreaterThan

isGreaterThan

isGreaterThan

isGreaterThanWhenPresent

isGreaterThanWhenPresent

isGreaterThanOrEqualTo

isGreaterThanOrEqualTo

isGreaterThanOrEqualTo

isGreaterThanOrEqualTo

isGreaterThanOrEqualToWhenPresent