Uses of Class org.jooq.Support (jOOQ 2.6.4 API)

Packages that use Support
Package	Description
org.jooq	The `org.jooq` package contains jOOQ's public API This package mostly contains interfaces that are implemented by the `org.jooq.impl` package.
org.jooq.impl	The `org.jooq.impl` package contains jOOQ's implementation classes This package provides implementations for the jOOQ API from `org.jooq`, whose interfaces are constructed mostly through the `Factory` class, which hides implementation facts from the public API
org.jooq.util.oracle	The `org.jooq.util.ase` package contains classes related to the `SQLDialect.MYSQL` dialect

Uses of Support in org.jooq

Modifier and Type Method and Description

Field<T>

Field.abs()

This method is part of the pre-2.0 API.

Field<BigDecimal>

Field.acos()

This method is part of the pre-2.0 API.

Field<T>

Field.add(Field<?> value)

An arithmetic expression to add value to this.

Field<T>

Field.add(Number value)

An arithmetic expression adding this to value.

void

UpdateQuery.addConditions(Collection<Condition> conditions)

Adds new conditions to the query, connecting them to existing conditions with Operator.AND

void

SimpleSelectQuery.addConditions(Collection<Condition> conditions)

Adds new conditions to the query, connecting them to existing conditions with Operator.AND

void

SelectQuery.addConditions(Collection<Condition> conditions)

Adds new conditions to the query, connecting them to existing conditions with Operator.AND

void

DeleteQuery.addConditions(Collection<Condition> conditions)

Adds new conditions to the query, connecting them to existing conditions with Operator.AND

void

ConditionProvider.addConditions(Collection<Condition> conditions)

Deprecated.

Adds new conditions to the query, connecting them to existing conditions with Operator.AND

void

UpdateQuery.addConditions(Condition... conditions)

Adds new conditions to the query, connecting them to existing conditions with Operator.AND

void

SimpleSelectQuery.addConditions(Condition... conditions)

Adds new conditions to the query, connecting them to existing conditions with Operator.AND

void

SelectQuery.addConditions(Condition... conditions)

Adds new conditions to the query, connecting them to existing conditions with Operator.AND

void

DeleteQuery.addConditions(Condition... conditions)

Adds new conditions to the query, connecting them to existing conditions with Operator.AND

void

ConditionProvider.addConditions(Condition... conditions)

Deprecated.

Adds new conditions to the query, connecting them to existing conditions with Operator.AND

void

UpdateQuery.

addConditions(Operator operator,
             Collection<Condition> conditions)

Adds new conditions to the query, connecting them to existing conditions with the provided operator

void

SimpleSelectQuery.

addConditions(Operator operator,
             Collection<Condition> conditions)

Adds new conditions to the query, connecting them to existing conditions with the provided operator

void

SelectQuery.

addConditions(Operator operator,
             Collection<Condition> conditions)

Adds new conditions to the query, connecting them to existing conditions with the provided operator

void

DeleteQuery.

addConditions(Operator operator,
             Collection<Condition> conditions)

Adds new conditions to the query, connecting them to existing conditions with the provided operator

void

ConditionProvider.

addConditions(Operator operator,
             Collection<Condition> conditions)

Deprecated.

Adds new conditions to the query, connecting them to existing conditions with the provided operator

void

UpdateQuery.

addConditions(Operator operator,
             Condition... conditions)

Adds new conditions to the query, connecting them to existing conditions with the provided operator

void

SimpleSelectQuery.

addConditions(Operator operator,
             Condition... conditions)

Adds new conditions to the query, connecting them to existing conditions with the provided operator

void

SelectQuery.

addConditions(Operator operator,
             Condition... conditions)

Adds new conditions to the query, connecting them to existing conditions with the provided operator

void

DeleteQuery.

addConditions(Operator operator,
             Condition... conditions)

Adds new conditions to the query, connecting them to existing conditions with the provided operator

void

ConditionProvider.

addConditions(Operator operator,
             Condition... conditions)

Deprecated.

Adds new conditions to the query, connecting them to existing conditions with the provided operator

void

SelectQuery.addConnectBy(Condition condition)

Add an Oracle-specific CONNECT BY clause to the query

void

SelectQuery.addConnectByNoCycle(Condition condition)

Add an Oracle-specific CONNECT BY NOCYCLE clause to the query

void

SelectQuery.addFrom(Collection<? extends TableLike<?>> from)

Add tables to the table product

void

SelectQuery.addFrom(TableLike<?>... from)

Add tables to the table product

void

SelectQuery.addGroupBy(Collection<? extends Field<?>> fields)

Adds grouping fields Calling this with an empty argument list will result in an empty GROUP BY () clause being rendered.

void

SelectQuery.addGroupBy(Field<?>... fields)

Adds grouping fields Calling this with an empty argument list will result in an empty GROUP BY () clause being rendered.

void

SelectQuery.addHaving(Collection<Condition> conditions)

Adds new conditions to the having clause of the query, connecting it to existing conditions with the and operator.

void

SelectQuery.addHaving(Condition... conditions)

Adds new conditions to the having clause of the query, connecting it to existing conditions with the and operator.

void

SelectQuery.

addHaving(Operator operator,
         Collection<Condition> conditions)

Adds new conditions to the having clause of query, connecting them to existing conditions with the provided operator

void

SelectQuery.

addHaving(Operator operator,
         Condition... conditions)

Adds new conditions to the having clause of query, connecting them to existing conditions with the provided operator

void

SelectQuery.addHint(String hint)

Add an Oracle-style hint to the select clause Example:


 Factory create = new Factory();

 create.select(field1, field2)
       .hint("/*+ALL_ROWS*/")
       .from(table1)
       .execute();

void

SelectQuery.

addJoin(TableLike<?> table,
       Condition... conditions)

Joins the existing table product to a new table using a condition

void

SelectQuery.

addJoin(TableLike<?> table,
       JoinType type,
       Condition... conditions)

Joins the existing table product to a new table using a condition

void

SelectQuery.

addJoin(TableLike<?> table,
       JoinType type,
       Condition[] conditions,
       Field<?>[] partitionBy)

Joins the existing table product to a new table using a condition This adds a PARTITION BY clause to the right hand side of a OUTER JOIN expression.

void

SelectQuery.

addJoinOnKey(TableLike<?> table,
            JoinType type)

Joins the existing table product to a new table using a foreign key

void

SelectQuery.

addJoinOnKey(TableLike<?> table,
            JoinType type,
            ForeignKey<?,?> key)

Joins the existing table product to a new table using a foreign key

void

SelectQuery.

addJoinOnKey(TableLike<?> table,
            JoinType type,
            TableField<?,?>... keyFields)

Joins the existing table product to a new table using a foreign key

void

SelectQuery.

addJoinUsing(TableLike<?> table,
            Collection<? extends Field<?>> fields)

Joins the existing table product to a new table with a USING clause If this is not supported by your RDBMS, then jOOQ will try to simulate this behaviour using the information provided in this query.

void

SelectQuery.

addJoinUsing(TableLike<?> table,
            JoinType type,
            Collection<? extends Field<?>> fields)

void

SimpleSelectQuery.addLimit(int numberOfRows)

Limit the results of this select This is the same as calling OrderProvider.addLimit(int, int) with offset = 0

void

SelectQuery.addLimit(int numberOfRows)

Limit the results of this select This is the same as calling OrderProvider.addLimit(int, int) with offset = 0

void

OrderProvider.addLimit(int numberOfRows)

Deprecated.

Limit the results of this select This is the same as calling OrderProvider.addLimit(int, int) with offset = 0

void

SimpleSelectQuery.

addLimit(int offset,
        int numberOfRows)

Limit the results of this select Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

SelectQuery.

addLimit(int offset,
        int numberOfRows)

Limit the results of this select Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

OrderProvider.

addLimit(int offset,
        int numberOfRows)

Deprecated.

Limit the results of this select Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

SimpleSelectQuery.

addLimit(int offset,
        Param<Integer> numberOfRows)

Limit the results of this select using named parameters Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

SelectQuery.

addLimit(int offset,
        Param<Integer> numberOfRows)

Limit the results of this select using named parameters Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

OrderProvider.

addLimit(int offset,
        Param<Integer> numberOfRows)

Deprecated.

Limit the results of this select using named parameters Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

SimpleSelectQuery.addLimit(Param<Integer> numberOfRows)

Limit the results of this select using named parameters Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

SelectQuery.addLimit(Param<Integer> numberOfRows)

Limit the results of this select using named parameters Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

OrderProvider.addLimit(Param<Integer> numberOfRows)

Deprecated.

Limit the results of this select using named parameters Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

SimpleSelectQuery.

addLimit(Param<Integer> offset,
        int numberOfRows)

Limit the results of this select Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

SelectQuery.

addLimit(Param<Integer> offset,
        int numberOfRows)

Limit the results of this select Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

OrderProvider.

addLimit(Param<Integer> offset,
        int numberOfRows)

Deprecated.

Limit the results of this select Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

SimpleSelectQuery.

addLimit(Param<Integer> offset,
        Param<Integer> numberOfRows)

Limit the results of this select using named parameters Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

SelectQuery.

addLimit(Param<Integer> offset,
        Param<Integer> numberOfRows)

Limit the results of this select using named parameters Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

OrderProvider.

addLimit(Param<Integer> offset,
        Param<Integer> numberOfRows)

Deprecated.

Limit the results of this select using named parameters Note that some dialects do not support bind values at all in LIMIT or TOP clauses!

void

SimpleSelectQuery.addOrderBy(Collection<SortField<?>> fields)

Adds ordering fields

void

SelectQuery.addOrderBy(Collection<SortField<?>> fields)

Adds ordering fields

void

OrderProvider.addOrderBy(Collection<SortField<?>> fields)

Deprecated.

Adds ordering fields

void

SimpleSelectQuery.addOrderBy(Field<?>... fields)

Adds ordering fields, ordering by the default sort order

void

SelectQuery.addOrderBy(Field<?>... fields)

Adds ordering fields, ordering by the default sort order

void

OrderProvider.addOrderBy(Field<?>... fields)

Deprecated.

Adds ordering fields, ordering by the default sort order

void

SimpleSelectQuery.addOrderBy(int... fieldIndexes)

Adds ordering fields Indexes start at 1 in SQL!

void

SelectQuery.addOrderBy(int... fieldIndexes)

Adds ordering fields Indexes start at 1 in SQL!

void

OrderProvider.addOrderBy(int... fieldIndexes)

Deprecated.

Adds ordering fields Indexes start at 1 in SQL!

void

SimpleSelectQuery.addOrderBy(SortField<?>... fields)

Adds ordering fields

void

SelectQuery.addOrderBy(SortField<?>... fields)

Adds ordering fields

void

OrderProvider.addOrderBy(SortField<?>... fields)

Deprecated.

Adds ordering fields

void

InsertQuery.addRecord(R record)

Short for calling


 newRecord();
 setRecord(record);

void

SelectQuery.addSelect(Collection<? extends Field<?>> fields)

Add a list of select fields

void

SelectQuery.addSelect(Field<?>... fields)

Add a list of select fields

<T> void

StoreQuery.

addValue(Field<T> field,
        Field<T> value)

Add a value to the store statement

<T> void

StoreQuery.

addValue(Field<T> field,
        T value)

Add a value to the store statement

<A extends ArrayRecord<T>,T> 
void

StoreQuery.

addValueAsArray(Field<A> field,
               List<T> value)

Add a value to the store statement

<A extends ArrayRecord<T>,T> 
void

StoreQuery.

addValueAsArray(Field<A> field,
               T... value)

Add a value to the store statement

<T> void

InsertQuery.

addValueForUpdate(Field<T> field,
                 Field<T> value)

Add a value to the ON DUPLICATE KEY UPDATE clause of this INSERT statement, where this is supported.

<T> void

InsertQuery.

addValueForUpdate(Field<T> field,
                 T value)

Add a value to the ON DUPLICATE KEY UPDATE clause of this INSERT statement, where this is supported.

void

StoreQuery.addValues(Map<? extends Field<?>,?> map)

Add multiple values to the store statement.

void

InsertQuery.addValuesForUpdate(Map<? extends Field<?>,?> map)

Add multiple values to the ON DUPLICATE KEY UPDATE clause of this INSERT statement, where this is supported.

UpdateConditionStep<R>

UpdateConditionStep.and(Condition condition)

Combine the currently assembled conditions with another one using the Operator.AND operator

TableOnConditionStep

TableOnConditionStep.and(Condition condition)

Combine the currently assembled conditions with another one using the Operator.AND operator.

SimpleSelectConditionStep<R>

SimpleSelectConditionStep.and(Condition condition)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectOnConditionStep

SelectOnConditionStep.and(Condition condition)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectHavingConditionStep

SelectHavingConditionStep.and(Condition condition)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectConnectByConditionStep

SelectConnectByConditionStep.and(Condition condition)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectConditionStep

SelectConditionStep.and(Condition condition)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

MergeOnConditionStep<R>

MergeOnConditionStep.and(Condition condition)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

DivideByOnConditionStep

DivideByOnConditionStep.and(Condition condition)

Combine the currently assembled conditions with another one using the Operator.AND operator.

DeleteConditionStep<R>

DeleteConditionStep.and(Condition condition)

Combine the currently assembled conditions with another one using the Operator.AND operator

Condition

Condition.and(Condition other)

Combine this condition with another one using the Operator.AND operator.

UpdateConditionStep<R>

UpdateConditionStep.and(String sql)

Combine the currently assembled conditions with another one using the Operator.AND operator NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

TableOnConditionStep

TableOnConditionStep.and(String sql)

Combine the currently assembled conditions with another one using the Operator.AND operator.

SimpleSelectConditionStep<R>

SimpleSelectConditionStep.and(String sql)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectOnConditionStep

SelectOnConditionStep.and(String sql)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectHavingConditionStep

SelectHavingConditionStep.and(String sql)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectConnectByConditionStep

SelectConnectByConditionStep.and(String sql)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectConditionStep

SelectConditionStep.and(String sql)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

MergeOnConditionStep<R>

MergeOnConditionStep.and(String sql)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

DivideByOnConditionStep

DivideByOnConditionStep.and(String sql)

Combine the currently assembled conditions with another one using the Operator.AND operator.

Condition

Condition.and(String sql)

Combine this condition with another one using the Operator.AND operator.

UpdateConditionStep<R>

UpdateConditionStep.

and(String sql,
   Object... bindings)

Combine the currently assembled conditions with another one using the Operator.AND operator NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

TableOnConditionStep

TableOnConditionStep.

and(String sql,
   Object... bindings)

Combine the currently assembled conditions with another one using the Operator.AND operator.

SimpleSelectConditionStep<R>

SimpleSelectConditionStep.

and(String sql,
   Object... bindings)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectOnConditionStep

SelectOnConditionStep.

and(String sql,
   Object... bindings)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectHavingConditionStep

SelectHavingConditionStep.

and(String sql,
   Object... bindings)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectConnectByConditionStep

SelectConnectByConditionStep.

and(String sql,
   Object... bindings)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectConditionStep

SelectConditionStep.

and(String sql,
   Object... bindings)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

MergeOnConditionStep<R>

MergeOnConditionStep.

and(String sql,
   Object... bindings)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

DivideByOnConditionStep

DivideByOnConditionStep.

and(String sql,
   Object... bindings)

Combine the currently assembled conditions with another one using the Operator.AND operator.

Condition

Condition.

and(String sql,
   Object... bindings)

Combine this condition with another one using the Operator.AND operator.

UpdateConditionStep<R>

UpdateConditionStep.

and(String sql,
   QueryPart... parts)

Combine the currently assembled conditions with another one using the Operator.AND operator NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

TableOnConditionStep

TableOnConditionStep.

and(String sql,
   QueryPart... parts)

Combine the currently assembled conditions with another one using the Operator.AND operator.

SimpleSelectConditionStep<R>

SimpleSelectConditionStep.

and(String sql,
   QueryPart... parts)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectOnConditionStep

SelectOnConditionStep.

and(String sql,
   QueryPart... parts)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectHavingConditionStep

SelectHavingConditionStep.

and(String sql,
   QueryPart... parts)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectConnectByConditionStep

SelectConnectByConditionStep.

and(String sql,
   QueryPart... parts)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

SelectConditionStep

SelectConditionStep.

and(String sql,
   QueryPart... parts)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

MergeOnConditionStep<R>

MergeOnConditionStep.

and(String sql,
   QueryPart... parts)

Combine the currently assembled conditions with another one using the Operator.AND operator and proceed to the next step.

DivideByOnConditionStep

DivideByOnConditionStep.

and(String sql,
   QueryPart... parts)

Combine the currently assembled conditions with another one using the Operator.AND operator.

Condition

Condition.

and(String sql,
   QueryPart... parts)

Combine this condition with another one using the Operator.AND operator.

WindowFinalStep<T>

WindowRowsAndStep.andCurrentRow()

Add a ...

UpdateConditionStep<R>

UpdateConditionStep.andExists(Select<?> select)

Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator

TableOnConditionStep

TableOnConditionStep.andExists(Select<?> select)

Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator.

SimpleSelectConditionStep<R>

SimpleSelectConditionStep.andExists(Select<?> select)

Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator and proceed to the next step.

SelectOnConditionStep

SelectOnConditionStep.andExists(Select<?> select)

Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator and proceed to the next step.

SelectHavingConditionStep

SelectHavingConditionStep.andExists(Select<?> select)

Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator and proceed to the next step.

SelectConditionStep

SelectConditionStep.andExists(Select<?> select)

Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator and proceed to the next step.

MergeOnConditionStep<R>

MergeOnConditionStep.andExists(Select<?> select)

Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator and proceed to the next step.

DivideByOnConditionStep

DivideByOnConditionStep.andExists(Select<?> select)

Combine the currently assembled conditions with an EXISTS clause using the Operator.AND operator.

Condition

Condition.andExists(Select<?> select)

Combine this condition with an EXISTS clause using the Operator.AND operator.

WindowFinalStep<T>

WindowRowsAndStep.andFollowing(int number)

Add a ...

UpdateConditionStep<R>

UpdateConditionStep.andNot(Condition condition)

Combine the currently assembled conditions with a negated other one using the Operator.AND operator

TableOnConditionStep

TableOnConditionStep.andNot(Condition condition)

Combine the currently assembled conditions with a negated other one using the Operator.AND operator.

SimpleSelectConditionStep<R>

SimpleSelectConditionStep.andNot(Condition condition)

Combine the currently assembled conditions with a negated other one using the Operator.AND operator and proceed to the next step.

SelectOnConditionStep

SelectOnConditionStep.andNot(Condition condition)

Combine the currently assembled conditions with a negated other one using the Operator.AND operator and proceed to the next step.

SelectHavingConditionStep

SelectHavingConditionStep.andNot(Condition condition)

Combine the currently assembled conditions with a negated other one using the Operator.AND operator and proceed to the next step.

SelectConditionStep

SelectConditionStep.andNot(Condition condition)

Combine the currently assembled conditions with a negated other one using the Operator.AND operator and proceed to the next step.

MergeOnConditionStep<R>

MergeOnConditionStep.andNot(Condition condition)

Combine the currently assembled conditions with a negated other one using the Operator.AND operator and proceed to the next step.

DivideByOnConditionStep

DivideByOnConditionStep.andNot(Condition condition)

Combine the currently assembled conditions with a negated other one using the Operator.AND operator.

Condition

Condition.andNot(Condition other)

Combine this condition with a negated other one using the Operator.AND operator.

UpdateConditionStep<R>

UpdateConditionStep.andNotExists(Select<?> select)

Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator

TableOnConditionStep

TableOnConditionStep.andNotExists(Select<?> select)

Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator.

SimpleSelectConditionStep<R>

SimpleSelectConditionStep.andNotExists(Select<?> select)

Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator and proceed to the next step.

SelectOnConditionStep

SelectOnConditionStep.andNotExists(Select<?> select)

Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator and proceed to the next step.

SelectHavingConditionStep

SelectHavingConditionStep.andNotExists(Select<?> select)

Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator and proceed to the next step.

SelectConditionStep

SelectConditionStep.andNotExists(Select<?> select)

Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator and proceed to the next step.

MergeOnConditionStep<R>

MergeOnConditionStep.andNotExists(Select<?> select)

Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator and proceed to the next step.

DivideByOnConditionStep

DivideByOnConditionStep.andNotExists(Select<?> select)

Combine the currently assembled conditions with a NOT EXISTS clause using the Operator.AND operator.

Condition

Condition.andNotExists(Select<?> select)

Combine this condition with a NOT EXIST clause using the Operator.AND operator.

WindowFinalStep<T>

WindowRowsAndStep.andPreceding(int number)

Add a ...

WindowFinalStep<T>

WindowRowsAndStep.andUnboundedFollowing()

Add a ...

WindowFinalStep<T>

WindowRowsAndStep.andUnboundedPreceding()

Add a ...

Table<R>

Table.as(String alias)

Create an alias for this table

Field<T>

Field.as(String alias)

Create an alias for this field

Z

AliasProvider.as(String alias)

Deprecated.

Get an aliased QueryPart.

SortField<T>

Field.asc()

Create an ascending sort field from this field This is the same as calling Field.sort(SortOrder) with SortOrder.ASC

Field<Integer>

Field.ascii()

This method is part of the pre-2.0 API.

Field<BigDecimal>

Field.asin()

This method is part of the pre-2.0 API.

Field<BigDecimal>

Field.atan()

This method is part of the pre-2.0 API.

Field<BigDecimal>

Field.atan2(Field<? extends Number> y)

This method is part of the pre-2.0 API.

Field<BigDecimal>

Field.atan2(Number y)

This method is part of the pre-2.0 API.

Field<BigDecimal>

Field.avg()

This method is part of the pre-2.0 API.

WindowPartitionByStep<BigDecimal>

Field.avgOver()

This method is part of the pre-2.0 API.

Batch

FactoryOperations.batch(Collection<? extends Query> queries)

Execute a set of queries in batch mode (without bind values).

Batch

FactoryOperations.batch(Query... queries)

Execute a set of queries in batch mode (without bind values).

BatchBindStep

FactoryOperations.batch(Query query)

Execute a set of queries in batch mode (with bind values).

BetweenAndStep<T>

Field.between(Field<T> minValue)

Create a condition to check this field against some bounds SQL: this between minValue and maxValue

Condition

Field.

between(Field<T> minValue,
       Field<T> maxValue)

Create a condition to check this field against some bounds This is the same as calling between(minValue).and(maxValue) SQL: this between minValue and maxValue

BetweenAndStep<T>

Field.between(T minValue)

Create a condition to check this field against some bounds SQL: this between minValue and maxValue

Condition

Field.

between(T minValue,
       T maxValue)

Create a condition to check this field against some bounds This is the same as calling between(minValue).and(maxValue) SQL: this between minValue and maxValue

BetweenAndStep<T>

Field.betweenSymmetric(Field<T> minValue)

Create a condition to check this field against some bounds SQL: this between symmetric minValue and maxValue

Condition

Field.

betweenSymmetric(Field<T> minValue,
                Field<T> maxValue)

Create a condition to check this field against some bounds This is the same as calling betweenSymmetric(minValue).and(maxValue) SQL: this between symmetric minValue and maxValue

BetweenAndStep<T>

Field.betweenSymmetric(T minValue)

Create a condition to check this field against some bounds SQL: this between symmetric minValue and maxValue

Condition

Field.

betweenSymmetric(T minValue,
                T maxValue)

Create a condition to check this field against some bounds This is the same as calling betweenSymmetric(minValue).and(maxValue) SQL: this between symmetric minValue and maxValue

Field<Integer>

Field.bitLength()

This method is part of the pre-2.0 API.

<Z> Field<Z>

Field.cast(Class<? extends Z> type)

Cast this field to another type The actual cast may not be accurate as the DataType has to be "guessed" from the jOOQ-configured data types.

<Z> Field<Z>

Field.cast(DataType<Z> type)

Cast this field to a dialect-specific data type.

<Z> Field<Z>

Field.cast(Field<Z> field)

Cast this field to the type of another field.

Field<T>

Field.ceil()

This method is part of the pre-2.0 API.

Field<Integer>

Field.charLength()

This method is part of the pre-2.0 API.

Field<T>

Field.

coalesce(Field<T> option,
        Field<?>... options)

This method is part of the pre-2.0 API.

Field<T>

Field.

coalesce(T option,
        T... options)

This method is part of the pre-2.0 API.

LoaderOptionsStep<R>

LoaderOptionsStep.commitAfter(int number)

Commit after a certain number of inserted records.

LoaderOptionsStep<R>

LoaderOptionsStep.commitAll()

Commit only after inserting all records.

LoaderOptionsStep<R>

LoaderOptionsStep.commitEach()

Commit each loaded record.

LoaderOptionsStep<R>

LoaderOptionsStep.commitNone()

Leave committing / rollbacking up to client code.

Condition

Field.

compare(Comparator comparator,
       Field<T> field)

Compare this field with another field using a dynamic comparator

Condition

Field.

compare(Comparator comparator,
       T value)

Compare this field with a value using a dynamic comparator

Field<String>

Field.concat(Field<?>... fields)

This method is part of the pre-2.0 API.

Field<String>

Field.concat(String... values)

This method is part of the pre-2.0 API.

SelectConnectByConditionStep

SelectConnectByStep.connectBy(Condition condition)

Add an Oracle-specific CONNECT BY clause to the query

SelectConnectByConditionStep

SelectConnectByStep.connectBy(String sql)

Add an Oracle-specific CONNECT BY clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

SelectConnectByConditionStep

SelectConnectByStep.

connectBy(String sql,
         Object... bindings)

Add an Oracle-specific CONNECT BY clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

SelectConnectByConditionStep

SelectConnectByStep.

connectBy(String sql,
         QueryPart... parts)

Add an Oracle-specific CONNECT BY clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

SelectConnectByConditionStep

SelectConnectByStep.connectByNoCycle(Condition condition)

Add an Oracle-specific CONNECT BY NOCYCLE clause to the query

SelectConnectByConditionStep

SelectConnectByStep.connectByNoCycle(String sql)

Add an Oracle-specific CONNECT BY NOCYCLE clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

SelectConnectByConditionStep

SelectConnectByStep.

connectByNoCycle(String sql,
                Object... bindings)

Add an Oracle-specific CONNECT BY NOCYCLE clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

SelectConnectByConditionStep

SelectConnectByStep.

connectByNoCycle(String sql,
                QueryPart... parts)

Add an Oracle-specific CONNECT BY NOCYCLE clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

Condition

Field.contains(Field<T> value)

Convenience method for Field.like(String, char) including proper adding of wildcards and escaping SQL: this like ('%' || escape(value, '\') || '%') escape '\' Note: This also works with numbers, for instance val(1133).contains(13) If you're using SQLDialect.POSTGRES, then you can use this method also to express the "ARRAY contains" operator.

Condition

Field.contains(T value)

Field<BigDecimal>

Field.cos()

This method is part of the pre-2.0 API.

Field<BigDecimal>

Field.cosh()

This method is part of the pre-2.0 API.

Field<BigDecimal>

Field.cot()

This method is part of the pre-2.0 API.

Field<BigDecimal>

Field.coth()

This method is part of the pre-2.0 API.

Field<Integer>

Field.count()

This method is part of the pre-2.0 API.

Field<Integer>

Field.countDistinct()

This method is part of the pre-2.0 API.

WindowPartitionByStep<Integer>

Field.countOver()

This method is part of the pre-2.0 API.

Table<Record>

Table.crossJoin(String sql)

CROSS JOIN a table to this table.

SelectJoinStep

SelectJoinStep.crossJoin(String sql)

Convenience method to CROSS JOIN a table to the last table added to the FROM clause using Table.crossJoin(String) If this syntax is unavailable, it is simulated with a regular INNER JOIN.

Table<Record>

Table.

crossJoin(String sql,
         Object... bindings)

CROSS JOIN a table to this table.

SelectJoinStep

SelectJoinStep.

crossJoin(String sql,
         Object... bindings)

Convenience method to CROSS JOIN a table to the last table added to the FROM clause using Table.crossJoin(String, Object...)

Table<Record>

Table.

crossJoin(String sql,
         QueryPart... parts)

CROSS JOIN a table to this table.

SelectJoinStep

SelectJoinStep.

crossJoin(String sql,
         QueryPart... parts)

Convenience method to CROSS JOIN a table to the last table added to the FROM clause using Table.crossJoin(String, QueryPart...)

Table<Record>

Table.crossJoin(TableLike<?> table)

CROSS JOIN a table to this table.

SelectJoinStep

SelectJoinStep.crossJoin(TableLike<?> table)

Convenience method to CROSS JOIN a table to the last table added to the FROM clause using Table.crossJoin(TableLike) If this syntax is unavailable, it is simulated with a regular INNER JOIN.

Field<T>

Sequence.currval()

Get the current value of this sequence

<T extends Number> 
T

FactoryOperations.currval(Sequence<T> sequence)

Convenience method to fetch the CURRVAL for a sequence directly from this Factory's underlying JDBC Connection

<Z> Field<Z>

Field.

decode(Field<T> search,
      Field<Z> result)

This method is part of the pre-2.0 API.

<Z> Field<Z>

Field.

decode(Field<T> search,
      Field<Z> result,
      Field<?>... more)

This method is part of the pre-2.0 API.

<Z> Field<Z>

Field.

decode(T search,
      Z result)

This method is part of the pre-2.0 API.

<Z> Field<Z>

Field.

decode(T search,
      Z result,
      Object... more)

This method is part of the pre-2.0 API.

Field<BigDecimal>

Field.deg()

This method is part of the pre-2.0 API.

<R extends Record> 
DeleteWhereStep<R>

FactoryOperations.delete(Table<R> table)

Create a new DSL delete statement.

<R extends Record> 
DeleteQuery<R>

FactoryOperations.deleteQuery(Table<R> table)

Create a new DeleteQuery

MergeNotMatchedStep<R>

MergeMatchedDeleteStep.deleteWhere(Condition condition)

Add an additional DELETE WHERE clause to the preceding WHEN MATCHED THEN UPDATE clause.

SortField<T>

Field.desc()

Create a descending sort field from this field This is the same as calling Field.sort(SortOrder) with SortOrder.DESC

Field<T>

Field.div(Field<? extends Number> value)

An arithmetic expression dividing this by value If this is a numeric field, then the result is a number of the same type as this field.

Field<T>

Field.div(Number value)

An arithmetic expression dividing this by value If this is a numeric field, then the result is a number of the same type as this field.

DivideByOnStep

Table.divideBy(Table<?> divisor)

Create a new TABLE reference from this table, applying relational division.

Condition

Field.endsWith(Field<T> value)

Convenience method for Field.like(String, char) including proper adding of wildcards and escaping SQL: this like ('%' || escape(value, '\')) escape '\' Note: This also works with numbers, for instance val(1133).endsWith(33)

Condition

Field.endsWith(T value)

Condition

RowN.eq(Field<?>... values)

Compare this row value expression with another row value expression for equality Row equality comparison predicates can be simulated in those databases that do not support such predicates natively: (A, B) = (1, 2) is equivalent to A = 1 AND B = 2

Condition

Field.eq(Field<T> field)

this = field

Condition

Row1.eq(Field<T1> t1)

Condition

Row2.

eq(Field<T1> t1,
  Field<T2> t2)

Condition

Row3.

eq(Field<T1> t1,
  Field<T2> t2,
  Field<T3> t3)

Condition

Row4.

eq(Field<T1> t1,
  Field<T2> t2,
  Field<T3> t3,
  Field<T4> t4)

Condition

Row5.

eq(Field<T1> t1,
  Field<T2> t2,
  Field<T3> t3,
  Field<T4> t4,
  Field<T5> t5)

Condition

Row6.

eq(Field<T1> t1,
  Field<T2> t2,
  Field<T3> t3,
  Field<T4> t4,
  Field<T5> t5,
  Field<T6> t6)

Condition

Row7.

eq(Field<T1> t1,
  Field<T2> t2,
  Field<T3> t3,
  Field<T4> t4,
  Field<T5> t5,
  Field<T6> t6,
  Field<T7> t7)

Condition

Row8.

eq(Field<T1> t1,
  Field<T2> t2,
  Field<T3> t3,
  Field<T4> t4,
  Field<T5> t5,
  Field<T6> t6,
  Field<T7> t7,
  Field<T8> t8)

Condition

RowN.eq(Object... values)

Condition

Row1.eq(Row1<T1> row)

Condition

Row2.eq(Row2<T1,T2> row)

Condition

Row3.eq(Row3<T1,T2,T3> row)

Condition

Row4.eq(Row4<T1,T2,T3,T4> row)

Condition

Row5.eq(Row5<T1,T2,T3,T4,T5> row)

Condition

Row6.eq(Row6<T1,T2,T3,T4,T5,T6> row)

Condition

Row7.eq(Row7<T1,T2,T3,T4,T5,T6,T7> row)

Condition

Row8.eq(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)

Condition

RowN.eq(RowN row)

Condition

Field.eq(Select<?> query)

this = (Select

Condition

Field.eq(T value)

this = value If value == null, then this will return a condition equivalent to Field.isNull() for convenience.

Condition

Row1.eq(T1 t1)

Condition

Row2.

eq(T1 t1,
  T2 t2)

Condition

Row3.

eq(T1 t1,
  T2 t2,
  T3 t3)

Condition

Row4.

eq(T1 t1,
  T2 t2,
  T3 t3,
  T4 t4)

Condition

Row5.

eq(T1 t1,
  T2 t2,
  T3 t3,
  T4 t4,
  T5 t5)

Condition

Row6.

eq(T1 t1,
  T2 t2,
  T3 t3,
  T4 t4,
  T5 t5,
  T6 t6)

Condition

Row7.

eq(T1 t1,
  T2 t2,
  T3 t3,
  T4 t4,
  T5 t5,
  T6 t6,
  T7 t7)

Condition

Row8.

eq(T1 t1,
  T2 t2,
  T3 t3,
  T4 t4,
  T5 t5,
  T6 t6,
  T7 t7,
  T8 t8)

Condition

RowN.equal(Field<?>... fields)

Condition

Field.equal(Field<T> field)

this = field

Condition

Row1.equal(Field<T1> t1)

Condition

Row2.

equal(Field<T1> t1,
     Field<T2> t2)

Condition

Row3.

equal(Field<T1> t1,
     Field<T2> t2,
     Field<T3> t3)

Condition

Row4.

equal(Field<T1> t1,
     Field<T2> t2,
     Field<T3> t3,
     Field<T4> t4)

Condition

Row5.

equal(Field<T1> t1,
     Field<T2> t2,
     Field<T3> t3,
     Field<T4> t4,
     Field<T5> t5)

Condition

Row6.

equal(Field<T1> t1,
     Field<T2> t2,
     Field<T3> t3,
     Field<T4> t4,
     Field<T5> t5,
     Field<T6> t6)

Condition

Row7.

equal(Field<T1> t1,
     Field<T2> t2,
     Field<T3> t3,
     Field<T4> t4,
     Field<T5> t5,
     Field<T6> t6,
     Field<T7> t7)

Condition

Row8.

equal(Field<T1> t1,
     Field<T2> t2,
     Field<T3> t3,
     Field<T4> t4,
     Field<T5> t5,
     Field<T6> t6,
     Field<T7> t7,
     Field<T8> t8)

Condition

RowN.equal(Object... values)

Condition

Row1.equal(Row1<T1> row)

Condition

Row2.equal(Row2<T1,T2> row)

Condition

Row3.equal(Row3<T1,T2,T3> row)

Condition

Row4.equal(Row4<T1,T2,T3,T4> row)

Condition

Row5.equal(Row5<T1,T2,T3,T4,T5> row)

Condition

Row6.equal(Row6<T1,T2,T3,T4,T5,T6> row)

Condition

Row7.equal(Row7<T1,T2,T3,T4,T5,T6,T7> row)

Condition

Row8.equal(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)

Condition

RowN.equal(RowN row)

Condition

Field.equal(Select<?> query)

this = (Select

Condition

Field.equal(T value)

this = value If value == null, then this will return a condition equivalent to Field.isNull() for convenience.

Condition

Row1.equal(T1 t1)

Condition

Row2.

equal(T1 t1,
     T2 t2)

Condition

Row3.

equal(T1 t1,
     T2 t2,
     T3 t3)

Condition

Row4.

equal(T1 t1,
     T2 t2,
     T3 t3,
     T4 t4)

Condition

Row5.

equal(T1 t1,
     T2 t2,
     T3 t3,
     T4 t4,
     T5 t5)

Condition

Row6.

equal(T1 t1,
     T2 t2,
     T3 t3,
     T4 t4,
     T5 t5,
     T6 t6)

Condition

Row7.

equal(T1 t1,
     T2 t2,
     T3 t3,
     T4 t4,
     T5 t5,
     T6 t6,
     T7 t7)

Condition

Row8.

equal(T1 t1,
     T2 t2,
     T3 t3,
     T4 t4,
     T5 t5,
     T6 t6,
     T7 t7,
     T8 t8)

Condition

Field.equalAll(Field<T[]> array)

this = all (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.equalAll(Select<?> query)

this = all (Select

Condition

Field.equalAll(T... array)

this = all (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.equalAny(Field<T[]> array)

this = any (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.equalAny(Select<?> query)

this = any (Select

Condition

Field.equalAny(T... array)

this = any (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.equalIgnoreCase(Field<String> value)

lower(this) = lower(value)

Condition

Field.equalIgnoreCase(String value)

lower(this) = lower(value)

Condition

Field.equalSome(Select<?> query)

Deprecated.

- 2.0.2 - Use Field.equalAny(Select) instead

Select<R>

Select.except(Select<R> select)

Combine with other selects

Loader<R>

LoaderLoadStep.execute()

Execute the load.

int

FactoryOperations.execute(String sql)

Execute a query holding plain SQL.

int

FactoryOperations.

execute(String sql,
       Object... bindings)

Execute a new query holding plain SQL.

int

FactoryOperations.

execute(String sql,
       QueryPart... parts)

Execute a new query holding plain SQL.

<R extends UpdatableRecord<R>> 
int

FactoryOperations.executeDelete(R record)

Delete a record from a table DELETE FROM [table] WHERE [record is supplied record]

<R extends TableRecord<R>,T> 
int

FactoryOperations.

executeDelete(R record,
             Condition condition)

Delete a record from a table DELETE FROM [table] WHERE [condition]

<R extends TableRecord<R>> 
int

FactoryOperations.executeDelete(Table<R> table)

Deprecated.

- 2.5.0 [#1692] - The semantics of FactoryOperations.executeDelete(TableRecord, Condition) has changed. This method here is no longer necessary.

<R extends TableRecord<R>,T> 
int

FactoryOperations.

executeDelete(Table<R> table,
             Condition condition)

Deprecated.

- 2.5.0 [#1692] - The semantics of FactoryOperations.executeDelete(TableRecord, Condition) has changed. This method here is no longer necessary.

<R extends TableRecord<R>> 
int

FactoryOperations.executeDeleteOne(Table<R> table)

Deprecated.

- 2.5.0 [#1692] - The semantics of FactoryOperations.executeDelete(TableRecord, Condition) has changed. This method here is no longer necessary.

<R extends TableRecord<R>,T> 
int

FactoryOperations.

executeDeleteOne(Table<R> table,
                Condition condition)

Deprecated.

- 2.5.0 [#1692] - The semantics of FactoryOperations.executeDelete(TableRecord, Condition) has changed. This method here is no longer necessary.

<R extends TableRecord<R>> 
int

FactoryOperations.executeInsert(R record)

Insert one record This executes something like the following statement: INSERT INTO [table] ...

<R extends TableRecord<R>> 
int

FactoryOperations.

executeInsert(Table<R> table,
             R record)

Deprecated.

- 2.5.0 [#1692] - Use FactoryOperations.executeInsert(TableRecord) instead

<R extends UpdatableRecord<R>> 
int

FactoryOperations.executeUpdate(R record)

Update a table UPDATE [table] SET [modified values in record] WHERE [record is supplied record]

<R extends TableRecord<R>,T> 
int

FactoryOperations.

executeUpdate(R record,
             Condition condition)

Update a table UPDATE [table] SET [modified values in record] WHERE [condition]

<R extends TableRecord<R>> 
int

FactoryOperations.

executeUpdate(Table<R> table,
             R record)

Deprecated.

- 2.5.0 [#1692] - This "mass" update is no longer supported

<R extends TableRecord<R>,T> 
int

FactoryOperations.

executeUpdate(Table<R> table,
             R record,
             Condition condition)

Deprecated.

- 2.5.0 [#1692] - Use FactoryOperations.executeUpdate(TableRecord, Condition) instead

<R extends TableRecord<R>> 
int

FactoryOperations.

executeUpdateOne(Table<R> table,
                R record)

Deprecated.

- 2.5.0 [#1692] - This "mass" update is no longer supported

<R extends TableRecord<R>,T> 
int

FactoryOperations.

executeUpdateOne(Table<R> table,
                R record,
                Condition condition)

Deprecated.

- 2.5.0 [#1692] - The semantics of FactoryOperations.executeUpdate(TableRecord, Condition) has changed. This method here is no longer necessary.

Field<BigDecimal>

Field.exp()

This method is part of the pre-2.0 API.

Field<Integer>

Field.extract(DatePart datePart)

This method is part of the pre-2.0 API.

Result<R>

InsertResultStep.fetch()

The result holding returned values as specified by the InsertReturningStep This currently only works well for DB2, HSQLDB, MySQL, and Postgres

Result<Record>

FactoryOperations.fetch(ResultSet rs)

Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.

Result<Record>

FactoryOperations.fetch(String sql)

Execute a new query holding plain SQL.

Result<Record>

FactoryOperations.

fetch(String sql,
     Object... bindings)

Execute a new query holding plain SQL.

Result<Record>

FactoryOperations.

fetch(String sql,
     QueryPart... parts)

Execute a new query holding plain SQL.

<R extends Record> 
Result<R>

FactoryOperations.fetch(Table<R> table)

Execute and return all records for SELECT * FROM [table] The result and its contained records are attached to this Configuration by default.

<R extends Record> 
Result<R>

FactoryOperations.

fetch(Table<R> table,
     Condition condition)

Execute and return all records for SELECT * FROM [table] WHERE [condition] The result and its contained records are attached to this Configuration by default.

<R extends Record> 
R

FactoryOperations.fetchAny(Table<R> table)

Execute and return zero or one record for SELECT * FROM [table] LIMIT 1 The resulting record is attached to this Configuration by default.

Cursor<Record>

FactoryOperations.fetchLazy(ResultSet rs)

Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.

Cursor<Record>

FactoryOperations.fetchLazy(String sql)

Execute a new query holding plain SQL and "lazily" return the generated result.

Cursor<Record>

FactoryOperations.

fetchLazy(String sql,
         Object... bindings)

Execute a new query holding plain SQL and "lazily" return the generated result.

Cursor<Record>

FactoryOperations.

fetchLazy(String sql,
         QueryPart... parts)

Execute a new query holding plain SQL and "lazily" return the generated result.

List<Result<Record>>

FactoryOperations.fetchMany(String sql)

Execute a new query holding plain SQL, possibly returning several result sets Example (Sybase ASE):


 String sql = "sp_help 'my_table'";

NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

List<Result<Record>>

FactoryOperations.

fetchMany(String sql,
         Object... bindings)

Execute a new query holding plain SQL, possibly returning several result sets.

List<Result<Record>>

FactoryOperations.

fetchMany(String sql,
         QueryPart... parts)

Execute a new query holding plain SQL, possibly returning several result sets.

R

InsertResultStep.fetchOne()

The record holding returned values as specified by the InsertReturningStep

Record

FactoryOperations.fetchOne(String sql)

Execute a new query holding plain SQL.

Record

FactoryOperations.

fetchOne(String sql,
        Object... bindings)

Execute a new query holding plain SQL.

Record

FactoryOperations.

fetchOne(String sql,
        QueryPart... parts)

Execute a new query holding plain SQL.

<R extends Record> 
R

FactoryOperations.fetchOne(Table<R> table)

Execute and return zero or one record for SELECT * FROM [table] The resulting record is attached to this Configuration by default.

<R extends Record> 
R

FactoryOperations.

fetchOne(Table<R> table,
        Condition condition)

Execute and return zero or one record for SELECT * FROM [table] WHERE [condition] The resulting record is attached to this Configuration by default.

LoaderCSVOptionsStep<R>

LoaderCSVStep.fields(Collection<? extends Field<?>> fields)

Specify the the fields to be loaded into the table in the correct order.

LoaderCSVOptionsStep<R>

LoaderCSVStep.fields(Field<?>... fields)

Specify the the fields to be loaded into the table in the correct order.

WindowIgnoreNullsStep<T>

Field.firstValue()

This method is part of the pre-2.0 API.

Field<T>

Field.floor()

This method is part of the pre-2.0 API.

SimpleSelectFinalStep<R>

SimpleSelectForUpdateStep.forShare()

Add a FOR SHARE clause to the end of the query.

SelectFinalStep

SelectForUpdateStep.forShare()

Add a FOR SHARE clause to the end of the query.

SimpleSelectForUpdateOfStep<R>

SimpleSelectForUpdateStep.forUpdate()

Add a FOR UPDATE clause to the end of the query.

SelectForUpdateOfStep

SelectForUpdateStep.forUpdate()

Add a FOR UPDATE clause to the end of the query.

SelectJoinStep

SelectFromStep.from(Collection<? extends TableLike<?>> tables)

Add a FROM clause to the query

SelectJoinStep

SelectFromStep.from(String sql)

Add a FROM clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

SelectJoinStep

SelectFromStep.

from(String sql,
    Object... bindings)

Add a FROM clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

SelectJoinStep

SelectFromStep.

from(String sql,
    QueryPart... parts)

Add a FROM clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

SelectJoinStep

SelectFromStep.from(TableLike<?>... table)

Add a FROM clause to the query

TableOnStep

Table.fullOuterJoin(String sql)

FULL OUTER JOIN a table to this table.

SelectOnStep

SelectJoinStep.fullOuterJoin(String sql)

Convenience method to FULL OUTER JOIN a table to the last table added to the FROM clause using Table.fullOuterJoin(String) This is only possible where the underlying RDBMS supports it NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

TableOnStep

Table.

fullOuterJoin(String sql,
             Object... bindings)

FULL OUTER JOIN a table to this table.

SelectOnStep

SelectJoinStep.

fullOuterJoin(String sql,
             Object... bindings)

Convenience method to FULL OUTER JOIN a tableto the last table added to the FROM clause using Table.fullOuterJoin(String, Object...)

TableOnStep

Table.

fullOuterJoin(String sql,
             QueryPart... parts)

FULL OUTER JOIN a table to this table.

SelectOnStep

SelectJoinStep.

fullOuterJoin(String sql,
             QueryPart... parts)

Convenience method to FULL OUTER JOIN a tableto the last table added to the FROM clause using Table.fullOuterJoin(String, QueryPart...)

TableOnStep

Table.fullOuterJoin(TableLike<?> table)

FULL OUTER JOIN a table to this table.

SelectOnStep

SelectJoinStep.fullOuterJoin(TableLike<?> table)

Convenience method to FULL OUTER JOIN a table to the last table added to the FROM clause using Table.fullOuterJoin(TableLike) This is only possible where the underlying RDBMS supports it

Condition

Field.ge(Field<T> field)

this >= field

Condition

Field.ge(Select<?> query)

this >= (Select

Condition

Field.ge(T value)

this >= value

R

InsertQuery.getReturnedRecord()

The record holding returned values as specified by any of the InsertQuery.setReturning() methods.

Result<R>

InsertQuery.getReturnedRecords()

The records holding returned values as specified by any of the InsertQuery.setReturning() methods.

Condition

Field.greaterOrEqual(Field<T> field)

this >= field

Condition

Field.greaterOrEqual(Select<?> query)

this >= (Select

Condition

Field.greaterOrEqual(T value)

this >= value

Condition

Field.greaterOrEqualAll(Field<T[]> array)

this >= all (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.greaterOrEqualAll(Select<?> query)

this >= all (Select

Condition

Field.greaterOrEqualAll(T... array)

this >= all (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.greaterOrEqualAny(Field<T[]> array)

this >= any (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.greaterOrEqualAny(Select<?> query)

this >= any (Select

Condition

Field.greaterOrEqualAny(T... array)

this >= any (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.greaterOrEqualSome(Select<?> query)

Deprecated.

- 2.0.2 - Use Field.greaterOrEqualAny(Select) instead

Condition

Field.greaterThan(Field<T> field)

this > field

Condition

Field.greaterThan(Select<?> query)

this > (Select

Condition

Field.greaterThan(T value)

this > value

Condition

Field.greaterThanAll(Field<T[]> array)

this > all (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.greaterThanAll(Select<?> query)

this > all (Select

Condition

Field.greaterThanAll(T... array)

this > all (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.greaterThanAny(Field<T[]> array)

this > any (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.greaterThanAny(Select<?> query)

this > any (Select

Condition

Field.greaterThanAny(T... array)

this > any (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.greaterThanSome(Select<?> query)

Deprecated.

- 2.0.2 - Use Field.greaterThanAny(Select) instead

Field<T>

Field.greatest(Field<?>... others)

This method is part of the pre-2.0 API.

Field<T>

Field.greatest(T... others)

This method is part of the pre-2.0 API.

SelectHavingStep

SelectGroupByStep.groupBy(Collection<? extends Field<?>> fields)

Add a GROUP BY clause to the query Calling this with an empty argument list will result in an empty GROUP BY () clause being rendered.

SelectHavingStep

SelectGroupByStep.groupBy(Field<?>... fields)

Add a GROUP BY clause to the query Calling this with an empty argument list will result in an empty GROUP BY () clause being rendered.

Condition

Field.gt(Field<T> field)

this > field

Condition

Field.gt(Select<?> query)

this > (Select

Condition

Field.gt(T value)

this > value

SelectHavingConditionStep

SelectHavingStep.having(Collection<Condition> conditions)

Add a HAVING clause to the query

SelectHavingConditionStep

SelectHavingStep.having(Condition... conditions)

Add a HAVING clause to the query

SelectHavingConditionStep

SelectHavingStep.having(String sql)

Add a HAVING clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

SelectHavingConditionStep

SelectHavingStep.

having(String sql,
      Object... bindings)

Add a HAVING clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

SelectHavingConditionStep

SelectHavingStep.

having(String sql,
      QueryPart... parts)

Add a HAVING clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

SelectFromStep

SelectFromStep.hint(String hint)

Add an Oracle-style hint to the preceding select clause Example:


 Factory create = new Factory();

 create.select(field1, field2)
       .hint("/*+ALL_ROWS*/")
       .from(table1)
       .execute();

WindowOverStep<T>

WindowIgnoreNullsStep.ignoreNulls()

Add an IGNORE NULLS clause to the window function.

LoaderCSVOptionsStep<R>

LoaderCSVOptionsStep.ignoreRows(int number)

Specify that a certain number of rows should be ignored from the CSV file.

Table<Record>

PivotInStep.in(Collection<? extends Field<T>> fields)

Specify the acceptable values for pivoting This clause is generally only supported by SQLDialect.ORACLE.

Condition

Row1.in(Collection<? extends Row1<T1>> row)

Compare this row value expression with a set of row value expressions for equality Row IN predicates can be simulated in those databases that do not support such predicates natively: (A, B) IN ((1, 2), (3, 4)) is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)), which is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)

Condition

Row2.in(Collection<? extends Row2<T1,T2>> rows)

Condition

Row3.in(Collection<? extends Row3<T1,T2,T3>> rows)

Condition

Row4.in(Collection<? extends Row4<T1,T2,T3,T4>> rows)

Condition

Row5.in(Collection<? extends Row5<T1,T2,T3,T4,T5>> rows)

Condition

Row6.in(Collection<? extends Row6<T1,T2,T3,T4,T5,T6>> rows)

Condition

Row7.in(Collection<? extends Row7<T1,T2,T3,T4,T5,T6,T7>> rows)

Condition

Row8.in(Collection<? extends Row8<T1,T2,T3,T4,T5,T6,T7,T8>> rows)

Condition

RowN.in(Collection<? extends RowN> rows)

Condition

Field.in(Collection<T> values)

Create a condition to check this field against several values SQL: this in (values...)

Table<Record>

PivotInStep.in(Field<?>... fields)

Specify the acceptable values for pivoting This clause is generally only supported by SQLDialect.ORACLE.

Condition

Field.in(Field<?>... values)

Create a condition to check this field against several values SQL: this in (values...)

Condition

Row1.in(Row1<T1>... rows)

Condition

Row2.in(Row2<T1,T2>... rows)

Condition

Row3.in(Row3<T1,T2,T3>... rows)

Condition

Row4.in(Row4<T1,T2,T3,T4>... rows)

Condition

Row5.in(Row5<T1,T2,T3,T4,T5>... rows)

Condition

Row6.in(Row6<T1,T2,T3,T4,T5,T6>... rows)

Condition

Row7.in(Row7<T1,T2,T3,T4,T5,T6,T7>... rows)

Condition

Row8.in(Row8<T1,T2,T3,T4,T5,T6,T7,T8>... rows)

Condition

RowN.in(RowN... rows)

Condition

Row.in(Select<?> select)

Compare this row value expression with a subselect for equality Note that the subquery must return a table of the same degree as this row value expression.

Condition

Field.in(Select<?> query)

Create a condition to check this field against a subquery Note that the subquery must return exactly one field.

Table<Record>

PivotInStep.in(T... values)

Specify the acceptable values for pivoting

Condition

Field.in(T... values)

Create a condition to check this field against several values SQL: this in (values...)

<R extends Record> 
InsertSetStep<R>

FactoryOperations.insertInto(Table<R> into)

Create a new DSL insert statement.

<R extends Record> 
InsertValuesStep<R>

FactoryOperations.

insertInto(Table<R> into,
          Collection<? extends Field<?>> fields)

Create a new DSL insert statement.

<R extends Record> 
InsertValuesStep<R>

FactoryOperations.

insertInto(Table<R> into,
          Field<?>... fields)

Create a new DSL insert statement.

<R extends Record> 
Insert<R>

FactoryOperations.

insertInto(Table<R> into,
          Select<?> select)

Deprecated.

- 2.0.3 - Use any of these methods instead:

FactoryOperations.insertInto(Table) and InsertSetStep.select(Select)

FactoryOperations.insertInto(Table, Field...) and InsertValuesStep.select(Select)

FactoryOperations.insertInto(Table, Collection) and InsertValuesStep.select(Select)

<R extends Record> 
InsertQuery<R>

FactoryOperations.insertQuery(Table<R> into)

Create a new InsertQuery

Select<R>

Select.intersect(Select<R> select)

Combine with other selects

boolean

Parameter.isDefaulted()

Whether this parameter has a default value Procedures and functions with defaulted parameters behave slightly different from ones without defaulted parameters.

Condition

Field.isDistinctFrom(Field<T> field)

Create a condition to check if this field is DISTINCT from another field If this is not supported by the underlying database, jOOQ will render this instead:


 CASE WHEN [this] IS     NULL AND [field] IS     NULL THEN FALSE
      WHEN [this] IS     NULL AND [field] IS NOT NULL THEN TRUE
      WHEN [this] IS NOT NULL AND [field] IS     NULL THEN TRUE
      WHEN [this] =               [field]             THEN FALSE
      ELSE                                                 TRUE
 END

SQL: this is distinct from field

Condition

Field.isDistinctFrom(T value)

Create a condition to check if this field is DISTINCT from another value If this is not supported by the underlying database, jOOQ will render this instead:


 CASE WHEN [this] IS     NULL AND [value] IS     NULL THEN FALSE
      WHEN [this] IS     NULL AND [value] IS NOT NULL THEN TRUE
      WHEN [this] IS NOT NULL AND [value] IS     NULL THEN TRUE
      WHEN [this] =               [value]             THEN FALSE
      ELSE                                                 TRUE
 END

SQL: this is distinct from value

Condition

Field.isFalse()

Create a condition to check this field against known string literals for false SQL: lcase(this) in ("0", "n", "no", "false", "off", "disabled")

Condition

Field.isNotDistinctFrom(Field<T> field)

Create a condition to check if this field is NOT DISTINCT from another field If this is not supported by the underlying database, jOOQ will render this instead:


 CASE WHEN [this] IS     NULL AND [field] IS     NULL THEN TRUE
      WHEN [this] IS     NULL AND [field] IS NOT NULL THEN FALSE
      WHEN [this] IS NOT NULL AND [field] IS     NULL THEN FALSE
      WHEN [this] =               [value]             THEN TRUE
      ELSE                                                 FALSE
 END

SQL: this is not distinct from field

Condition

Field.isNotDistinctFrom(T value)

Create a condition to check if this field is NOT DISTINCT from another value If this is not supported by the underlying database, jOOQ will render this instead:


 CASE WHEN [this] IS     NULL AND [value] IS     NULL THEN TRUE
      WHEN [this] IS     NULL AND [value] IS NOT NULL THEN FALSE
      WHEN [this] IS NOT NULL AND [value] IS     NULL THEN FALSE
      WHEN [this] =               [value]             THEN TRUE
      ELSE                                                 FALSE
 END

SQL: this is not distinct from value

Condition

Field.isNotNull()

Create a condition to check this field against null.

Condition

Field.isNull()

Create a condition to check this field against null.

Condition

Field.isTrue()

Create a condition to check this field against known string literals for true SQL: lcase(this) in ("1", "y", "yes", "true", "on", "enabled")

TableOnStep

Table.join(String sql)

INNER JOIN a table to this table.

SelectOnStep

SelectJoinStep.join(String sql)

Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(String) NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

TableOnStep

Table.

join(String sql,
    Object... bindings)

INNER JOIN a table to this table.

SelectOnStep

SelectJoinStep.

join(String sql,
    Object... bindings)

Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(String, Object...)

TableOnStep

Table.

join(String sql,
    QueryPart... parts)

INNER JOIN a table to this table.

SelectOnStep

SelectJoinStep.

join(String sql,
    QueryPart... parts)

Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(String, QueryPart...)

TableOnStep

Table.join(TableLike<?> table)

INNER JOIN a table to this table.

SelectOnStep

SelectJoinStep.join(TableLike<?> table)

Convenience method to INNER JOIN a table to the last table added to the FROM clause using Table.join(TableLike)

TableOptionalOnStep

Table.

join(TableLike<?> table,
    JoinType type)

Join a table to this table using a JoinType Depending on the JoinType, a subsequent TableOnStep.on(Condition...) or TableOnStep.using(Field...) clause is required.

SelectOptionalOnStep

SelectJoinStep.

join(TableLike<?> table,
    JoinType type)

Convenience method to join a table to the last table added to the FROM clause using Table.join(TableLike, JoinType) Depending on the JoinType, a subsequent SelectOnStep.on(Condition...) or SelectOnStep.using(Field...) clause is required.

WindowBeforeOverStep<T>

AggregateFunction.keepDenseRankFirstOrderBy(Collection<SortField<?>> fields)

Restrict this aggregate function to FIRST values An example:


 MAX(ID) KEEP (DENSE_RANK FIRST ORDER BY 1)

This clause is only available on MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.

WindowBeforeOverStep<T>

AggregateFunction.keepDenseRankFirstOrderBy(Field<?>... fields)

Restrict this aggregate function to FIRST values An example:


 MAX(ID) KEEP (DENSE_RANK FIRST ORDER BY 1)

This clause is only available on MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.

WindowBeforeOverStep<T>

AggregateFunction.keepDenseRankFirstOrderBy(SortField<?>... fields)

Restrict this aggregate function to FIRST values An example:


 MAX(ID) KEEP (DENSE_RANK FIRST ORDER BY 1)

This clause is only available on MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.

WindowBeforeOverStep<T>

AggregateFunction.keepDenseRankLastOrderBy(Collection<SortField<?>> fields)

Restrict this aggregate function to FIRST values An example:


 MAX(ID) KEEP (DENSE_RANK LAST ORDER BY 1)

This clause is only available on MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.

WindowBeforeOverStep<T>

AggregateFunction.keepDenseRankLastOrderBy(Field<?>... fields)

Restrict this aggregate function to FIRST values An example:


 MAX(ID) KEEP (DENSE_RANK LAST ORDER BY 1)

This clause is only available on MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.

WindowBeforeOverStep<T>

AggregateFunction.keepDenseRankLastOrderBy(SortField<?>... fields)

Restrict this aggregate function to FIRST values An example:


 MAX(ID) KEEP (DENSE_RANK LAST ORDER BY 1)

This clause is only available on MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.

MergeValuesStep<R>

MergeKeyStep.key(Collection<? extends Field<?>> keys)

Specify an optional KEY clause.

MergeValuesStep<R>

MergeKeyStep.key(Field<?>... keys)

Specify an optional KEY clause.

WindowIgnoreNullsStep<T>

Field.lag()

This method is part of the pre-2.0 API.

WindowIgnoreNullsStep<T>

Field.lag(int offset)

This method is part of the pre-2.0 API.

WindowIgnoreNullsStep<T>

Field.

lag(int offset,
   Field<T> defaultValue)

This method is part of the pre-2.0 API.

WindowIgnoreNullsStep<T>

Field.

lag(int offset,
   T defaultValue)

This method is part of the pre-2.0 API.

BigInteger

FactoryOperations.lastID()

Retrieve the last inserted ID.

WindowIgnoreNullsStep<T>

Field.lastValue()

This method is part of the pre-2.0 API.

Condition

Field.le(Field<T> field)

this <= field

Condition

Field.le(Select<?> query)

this <= (Select

Condition

Field.le(T value)

this <= value

WindowIgnoreNullsStep<T>

Field.lead()

This method is part of the pre-2.0 API.

WindowIgnoreNullsStep<T>

Field.lead(int offset)

This method is part of the pre-2.0 API.

WindowIgnoreNullsStep<T>

Field.

lead(int offset,
    Field<T> defaultValue)

This method is part of the pre-2.0 API.

WindowIgnoreNullsStep<T>

Field.

lead(int offset,
    T defaultValue)

This method is part of the pre-2.0 API.

Field<T>

Field.least(Field<?>... others)

This method is part of the pre-2.0 API.

Field<T>

Field.least(T... others)

This method is part of the pre-2.0 API.

TablePartitionByStep

Table.leftOuterJoin(String sql)

LEFT OUTER JOIN a table to this table.

SelectJoinPartitionByStep

SelectJoinStep.leftOuterJoin(String sql)

Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(String) NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.

TablePartitionByStep

Table.

leftOuterJoin(String sql,
             Object... bindings)

LEFT OUTER JOIN a table to this table.

SelectJoinPartitionByStep

SelectJoinStep.

leftOuterJoin(String sql,
             Object... bindings)

Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(String, Object...)

TablePartitionByStep

Table.

leftOuterJoin(String sql,
             QueryPart... parts)

LEFT OUTER JOIN a table to this table.

SelectJoinPartitionByStep

SelectJoinStep.

leftOuterJoin(String sql,
             QueryPart... parts)

Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(String, QueryPart...)

TablePartitionByStep

Table.leftOuterJoin(TableLike<?> table)

LEFT OUTER JOIN a table to this table.

SelectJoinPartitionByStep

SelectJoinStep.leftOuterJoin(TableLike<?> table)

Convenience method to LEFT OUTER JOIN a table to the last table added to the FROM clause using Table.leftOuterJoin(TableLike)

Field<Integer>

Field.length()

This method is part of the pre-2.0 API.

Condition

Field.lessOrEqual(Field<T> field)

this <= field

Condition

Field.lessOrEqual(Select<?> query)

this <= (Select

Condition

Field.lessOrEqual(T value)

this <= value

Condition

Field.lessOrEqualAll(Field<T[]> array)

this <= all (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.lessOrEqualAll(Select<?> query)

this <= all (Select

Condition

Field.lessOrEqualAll(T... array)

this <= all (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.lessOrEqualAny(Field<T[]> array)

this <= any (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.lessOrEqualAny(Select<?> query)

this <= any (Select

Condition

Field.lessOrEqualAny(T... array)

this <= any (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.lessOrEqualSome(Select<?> query)

Deprecated.

- 2.0.2 - Use Field.lessOrEqualAny(Select) instead

Condition

Field.lessThan(Field<T> field)

this < field

Condition

Field.lessThan(Select<?> query)

this < (Select

Condition

Field.lessThan(T value)

this < value

Condition

Field.lessThanAll(Field<T[]> array)

this < all (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.lessThanAll(Select<?> query)

this < all (Select

Condition

Field.lessThanAll(T... array)

this < all (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.lessThanAny(Field<T[]> array)

this < any (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.lessThanAny(Select<?> query)

this < any (Select

Condition

Field.lessThanAny(T... array)

this < any (array) This is natively supported by SQLDialect.POSTGRES.

Condition

Field.lessThanSome(Select<?> query)

Deprecated.

- 2.0.2 - Use Field.lessThanAny(Select) instead

Condition

Field.like(Field<String> value)

Create a condition to pattern-check this field against a value SQL: this like value

Condition

Field.

like(Field<String> value,
    char escape)

Create a condition to pattern-check this field against a value SQL: this like value escape 'e'

Condition

Field.like(String value)

Create a condition to pattern-check this field against a value SQL: this like value

Condition

Field.

like(String value,
    char escape)

Create a condition to pattern-check this field against a value SQL: this like value escape 'e'

Condition

Field.likeIgnoreCase(Field<String> field)

Create a condition to case-insensitively pattern-check this field against a field This translates to this ilike field in SQLDialect.POSTGRES, or to lower(this) like lower(field) in all other dialects.

Condition

Field.

likeIgnoreCase(Field<String> field,
              char escape)

Condition

Field.likeIgnoreCase(String value)

Create a condition to case-insensitively pattern-check this field against a value This translates to this ilike value in SQLDialect.POSTGRES, or to lower(this) like lower(value) in all other dialects.

Condition

Field.

likeIgnoreCase(String value,
              char escape)

Condition

Field.likeRegex(Field<String> pattern)

Create a condition to regex-pattern-check this field against a pattern See Field.likeRegex(String) for more details

Condition

Field.likeRegex(String pattern)

Create a condition to regex-pattern-check this field against a pattern The SQL:2008 standard specifies a <regex like predicate> of the following form:


 <regex like predicate> ::=
   <row value predicand> <regex like predicate part 2>

 <regex like predicate part 2> ::=
  [ NOT ] LIKE_REGEX <XQuery pattern> [ FLAG <XQuery option flag> ]

This particular LIKE_REGEX operator comes in several flavours for various databases. jOOQ supports regular expressions as follows: SQL dialect SQL syntax Pattern syntax Documentation SQLDialect.ASE - - - SQLDialect.CUBRID[search] REGEXP [pattern] POSIX http://www.cubrid.org/manual/841/en/REGEXP Conditional Expression SQLDialect.DB2 - - - SQLDialect.DERBY - - - SQLDialect.H2[search] REGEXP [pattern] Java http ://www.h2database.com/html/grammar.html#condition_right_hand_side SQLDialect.HSQLDB

REGEXP_MATCHES([search], [pattern])
 Java
 http://hsqldb.org/doc/guide/builtinfunctions-chapt.html#N13577
 
 
 SQLDialect.INGRES
 -
 -
 -
 
 
 SQLDialect.MYSQL
 [search] REGEXP [pattern]
 POSIX
 http://dev.mysql.com/doc/refman/5.6/en/regexp.html
 
 
 SQLDialect.ORACLE
 REGEXP_LIKE([search], [pattern])
 POSIX
 http://docs.oracle.com/cd/E14072_01/server.112/e10592/conditions007.htm#
 sthref1994
 
 
 SQLDialect.POSTGRES
 [search] ~ [pattern]
 POSIX
 http://www.postgresql.org/docs/9.1/static/functions-matching.html#
 FUNCTIONS-POSIX-REGEXP
 
 
 SQLDialect.SQLITE
 [search] REGEXP [pattern]
 ?

`SimpleSelectOffsetStep<R>`	SimpleSelectLimitStep.`limit(int numberOfRows)` Add a `LIMIT` clause to the query If there is no `LIMIT` or `TOP` clause in your RDBMS, this may be simulated with a `ROW_NUMBER()` window function and nested `SELECT` statements.
`SelectOffsetStep`	SelectLimitStep.`limit(int numberOfRows)` Add a `LIMIT` clause to the query If there is no `LIMIT` or `TOP` clause in your RDBMS, this may be simulated with a `ROW_NUMBER()` window function and nested `SELECT` statements.
`SimpleSelectForUpdateStep<R>`	SimpleSelectLimitStep.`limit(int offset, int numberOfRows)` Add a `LIMIT` clause to the query Note that some dialects do not support bind values at all in `LIMIT` or `TOP` clauses!
`SelectForUpdateStep`	SelectLimitStep.`limit(int offset, int numberOfRows)` Add a `LIMIT` clause to the query Note that some dialects do not support bind values at all in `LIMIT` or `TOP` clauses!
`SimpleSelectForUpdateStep<R>`	SimpleSelectLimitStep.`limit(int offset, Param<Integer> numberOfRows)` Add a `LIMIT` clause to the query using named parameters Note that some dialects do not support bind values at all in `LIMIT` or `TOP` clauses!
`SelectForUpdateStep`	SelectLimitStep.`limit(int offset, Param<Integer> numberOfRows)` Add a `LIMIT` clause to the query using named parameters Note that some dialects do not support bind values at all in `LIMIT` or `TOP` clauses!
`SimpleSelectOffsetStep<R>`	SimpleSelectLimitStep.`limit(Param<Integer> numberOfRows)` Add a `LIMIT` clause to the query using named parameters Note that some dialects do not support bind values at all in `LIMIT` or `TOP` clauses!
`SelectOffsetStep`	SelectLimitStep.`limit(Param<Integer> numberOfRows)` Add a `LIMIT` clause to the query using named parameters Note that some dialects do not support bind values at all in `LIMIT` or `TOP` clauses!
`SimpleSelectForUpdateStep<R>`	SimpleSelectLimitStep.`limit(Param<Integer> offset, int numberOfRows)` Add a `LIMIT` clause to the query using named parameters Note that some dialects do not support bind values at all in `LIMIT` or `TOP` clauses!
`SelectForUpdateStep`	SelectLimitStep.`limit(Param<Integer> offset, int numberOfRows)` Add a `LIMIT` clause to the query using named parameters Note that some dialects do not support bind values at all in `LIMIT` or `TOP` clauses!
`SimpleSelectForUpdateStep<R>`	SimpleSelectLimitStep.`limit(Param<Integer> offset, Param<Integer> numberOfRows)` Add a `LIMIT` clause to the query using named parameters Note that some dialects do not support bind values at all in `LIMIT` or `TOP` clauses!
`SelectForUpdateStep`	SelectLimitStep.`limit(Param<Integer> offset, Param<Integer> numberOfRows)` Add a `LIMIT` clause to the query using named parameters Note that some dialects do not support bind values at all in `LIMIT` or `TOP` clauses!
`Field<BigDecimal>`	Field.`ln()` This method is part of the pre-2.0 API.
`LoaderCSVStep<R>`	LoaderSourceStep.`loadCSV(File file)` Load CSV data
`LoaderCSVStep<R>`	LoaderSourceStep.`loadCSV(InputStream stream)` Load CSV data
`LoaderCSVStep<R>`	LoaderSourceStep.`loadCSV(Reader reader)` Load CSV data
`LoaderCSVStep<R>`	LoaderSourceStep.`loadCSV(String data)` Load CSV data
`<R extends TableRecord<R>> LoaderOptionsStep<R>`	FactoryOperations.`loadInto(Table<R> table)` Create a new `Loader` object to load data from a CSV or XML source
`LoaderXMLStep<R>`	LoaderSourceStep.`loadXML(File file)` Load XML data
`LoaderXMLStep<R>`	LoaderSourceStep.`loadXML(InputSource source)` Load XML data
`LoaderXMLStep<R>`	LoaderSourceStep.`loadXML(InputStream stream)` Load XML data
`LoaderXMLStep<R>`	LoaderSourceStep.`loadXML(Reader reader)` Load XML data
`LoaderXMLStep<R>`	LoaderSourceStep.`loadXML(String data)` Load XML data
`Field<BigDecimal>`	Field.`log(int base)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`lower()` This method is part of the pre-2.0 API.
`Field<String>`	Field.`lpad(Field<? extends Number> length)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`lpad(Field<? extends Number> length, Field<String> character)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`lpad(int length)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`lpad(int length, char character)` This method is part of the pre-2.0 API.
`Condition`	Field.`lt(Field<T> field)` `this < field`
`Condition`	Field.`lt(Select<?> query)` `this < (Select`
`Condition`	Field.`lt(T value)` `this < value`
`Field<String>`	Field.`ltrim()` This method is part of the pre-2.0 API.
`Field<T>`	Field.`max()` This method is part of the pre-2.0 API.
`WindowPartitionByStep<T>`	Field.`maxOver()` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	Field.`median()` This method is part of the pre-2.0 API.
`<R extends Record> MergeUsingStep<R>`	FactoryOperations.`mergeInto(Table<R> table)` Create a new DSL SQL standard MERGE statement.
`<R extends Record> MergeKeyStep<R>`	FactoryOperations.`mergeInto(Table<R> table, Collection<? extends Field<?>> fields)` Create a new DSL merge statement (H2-specific syntax)
`<R extends Record> MergeKeyStep<R>`	FactoryOperations.`mergeInto(Table<R> table, Field<?>... fields)` Create a new DSL merge statement (H2-specific syntax) This statement is available from DSL syntax only.
`Field<T>`	Field.`min()` This method is part of the pre-2.0 API.
`WindowPartitionByStep<T>`	Field.`minOver()` This method is part of the pre-2.0 API.
`Field<T>`	Field.`mod(Field<? extends Number> value)` An arithmetic expression getting the modulo of this divided by value This renders the modulo operation where available: `[this] % [value]` ... or the modulo function elsewhere: `mod([this], [value])`
`Field<T>`	Field.`mod(Number value)` An arithmetic expression getting the modulo of this divided by value This renders the modulo operation where available: `[this] % [value]` ... or the modulo function elsewhere: `mod([this], [value])`
`Field<T>`	Field.`mul(Field<? extends Number> value)` An arithmetic expression multiplying this with value If this is a numeric field, then the result is a number of the same type as this field.
`Field<T>`	Field.`mul(Number value)` An arithmetic expression multiplying this with value If this is a numeric field, then the result is a number of the same type as this field.
`Table<Record>`	Table.`naturalJoin(String sql)` `NATURAL JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalJoin(String sql)` Convenience method to `NATURAL JOIN` a table to the last table added to the `FROM` clause using `Table.naturalJoin(String)` Natural joins are supported by most RDBMS.
`Table<Record>`	Table.`naturalJoin(String sql, Object... bindings)` `NATURAL JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalJoin(String sql, Object... bindings)` Convenience method to `NATURAL JOIN` a table to the last table added to the `FROM` clause using `Table.naturalJoin(String, Object...)`
`Table<Record>`	Table.`naturalJoin(String sql, QueryPart... parts)` `NATURAL JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalJoin(String sql, QueryPart... parts)` Convenience method to `NATURAL JOIN` a table to the last table added to the `FROM` clause using `Table.naturalJoin(String, QueryPart...)`
`Table<Record>`	Table.`naturalJoin(TableLike<?> table)` `NATURAL JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalJoin(TableLike<?> table)` Convenience method to `NATURAL JOIN` a table to the last table added to the `FROM` clause using `Table.naturalJoin(TableLike)` Natural joins are supported by most RDBMS.
`Table<Record>`	Table.`naturalLeftOuterJoin(String sql)` `NATURAL LEFT OUTER JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalLeftOuterJoin(String sql)` Convenience method to `NATURAL LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalLeftOuterJoin(String)` Natural joins are supported by most RDBMS.
`Table<Record>`	Table.`naturalLeftOuterJoin(String sql, Object... bindings)` `NATURAL LEFT OUTER JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalLeftOuterJoin(String sql, Object... bindings)` Convenience method to `NATURAL LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalLeftOuterJoin(String, Object...)`
`Table<Record>`	Table.`naturalLeftOuterJoin(String sql, QueryPart... parts)` `NATURAL LEFT OUTER JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalLeftOuterJoin(String sql, QueryPart... parts)` Convenience method to `NATURAL LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalLeftOuterJoin(String, QueryPart...)`
`Table<Record>`	Table.`naturalLeftOuterJoin(TableLike<?> table)` `NATURAL LEFT OUTER JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalLeftOuterJoin(TableLike<?> table)` Convenience method to `NATURAL LEFT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalLeftOuterJoin(TableLike)` Natural joins are supported by most RDBMS.
`Table<Record>`	Table.`naturalRightOuterJoin(String sql)` `NATURAL RIGHT OUTER JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalRightOuterJoin(String sql)` Convenience method to `NATURAL RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalRightOuterJoin(String)` Natural joins are supported by most RDBMS.
`Table<Record>`	Table.`naturalRightOuterJoin(String sql, Object... bindings)` `NATURAL RIGHT OUTER JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalRightOuterJoin(String sql, Object... bindings)` Convenience method to `NATURAL RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalRightOuterJoin(String, Object...)`
`Table<Record>`	Table.`naturalRightOuterJoin(String sql, QueryPart... parts)` `NATURAL RIGHT OUTER JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalRightOuterJoin(String sql, QueryPart... parts)` Convenience method to `NATURAL RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalRightOuterJoin(String, QueryPart...)`
`Table<Record>`	Table.`naturalRightOuterJoin(TableLike<?> table)` `NATURAL RIGHT OUTER JOIN` a table to this table.
`SelectJoinStep`	SelectJoinStep.`naturalRightOuterJoin(TableLike<?> table)` Convenience method to `NATURAL RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.naturalRightOuterJoin(TableLike)` Natural joins are supported by most RDBMS.
`Condition`	RowN.`ne(Field<?>... values)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Field.`ne(Field<T> field)` `this !`
`Condition`	Row1.`ne(Field<T1> t1)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row2.`ne(Field<T1> t1, Field<T2> t2)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row3.`ne(Field<T1> t1, Field<T2> t2, Field<T3> t3)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row4.`ne(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row5.`ne(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row6.`ne(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row7.`ne(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row8.`ne(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	RowN.`ne(Object... values)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row1.`ne(Row1<T1> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row2.`ne(Row2<T1,T2> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row3.`ne(Row3<T1,T2,T3> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row4.`ne(Row4<T1,T2,T3,T4> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row5.`ne(Row5<T1,T2,T3,T4,T5> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row6.`ne(Row6<T1,T2,T3,T4,T5,T6> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row7.`ne(Row7<T1,T2,T3,T4,T5,T6,T7> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row8.`ne(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	RowN.`ne(RowN row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Field.`ne(Select<?> query)` `this !`
`Condition`	Field.`ne(T value)` `this !`
`Condition`	Row1.`ne(T1 t1)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row2.`ne(T1 t1, T2 t2)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row3.`ne(T1 t1, T2 t2, T3 t3)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row4.`ne(T1 t1, T2 t2, T3 t3, T4 t4)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row5.`ne(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row6.`ne(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row7.`ne(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row8.`ne(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Field<T>`	Field.`neg()` Negate this field to get its negative value.
`InsertSetStep<R>`	InsertSetMoreStep.`newRecord()` Add an additional record to the `INSERT` statement
`void`	InsertQuery.`newRecord()` Adds a new Record to the insert statement for multi-record inserts Calling this method will cause subsequent calls to `StoreQuery.addValue(Field, Object)` (and similar) to fill the next record.
`Field<T>`	Sequence.`nextval()` Increment the sequence and get the next value
`<T extends Number> T`	FactoryOperations.`nextval(Sequence<T> sequence)` Convenience method to fetch the NEXTVAL for a sequence directly from this `Factory`'s underlying JDBC `Connection`
`Condition`	Condition.`not()` Invert this condition This is the same as calling `Factory.not(Condition)`
`BetweenAndStep<T>`	Field.`notBetween(Field<T> minValue)` Create a condition to check this field against some bounds SQL: `this not between minValue and maxValue`
`Condition`	Field.`notBetween(Field<T> minValue, Field<T> maxValue)` Create a condition to check this field against some bounds This is the same as calling `notBetween(minValue).and(maxValue)` SQL: `this not between minValue and maxValue`
`BetweenAndStep<T>`	Field.`notBetween(T minValue)` Create a condition to check this field against some bounds SQL: `this not between minValue and maxValue`
`Condition`	Field.`notBetween(T minValue, T maxValue)` Create a condition to check this field against some bounds This is the same as calling `notBetween(minValue).and(maxValue)` SQL: `this not between minValue and maxValue`
`BetweenAndStep<T>`	Field.`notBetweenSymmetric(Field<T> minValue)` Create a condition to check this field against some bounds SQL: `this not between symmetric minValue and maxValue`
`Condition`	Field.`notBetweenSymmetric(Field<T> minValue, Field<T> maxValue)` Create a condition to check this field against some bounds This is the same as calling `notBetweenSymmetric(minValue).and(maxValue)` SQL: `this not between symmetric minValue and maxValue`
`BetweenAndStep<T>`	Field.`notBetweenSymmetric(T minValue)` Create a condition to check this field against some bounds SQL: `this not between symmetric minValue and maxValue`
`Condition`	Field.`notBetweenSymmetric(T minValue, T maxValue)` Create a condition to check this field against some bounds This is the same as calling `notBetweenSymmetric(minValue).and(maxValue)` SQL: `this not between symmetric minValue and maxValue`
`Condition`	RowN.`notEqual(Field<?>... values)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Field.`notEqual(Field<T> field)` `this !`
`Condition`	Row1.`notEqual(Field<T1> t1)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row2.`notEqual(Field<T1> t1, Field<T2> t2)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row3.`notEqual(Field<T1> t1, Field<T2> t2, Field<T3> t3)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row4.`notEqual(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row5.`notEqual(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row6.`notEqual(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row7.`notEqual(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row8.`notEqual(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5, Field<T6> t6, Field<T7> t7, Field<T8> t8)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	RowN.`notEqual(Object... values)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row1.`notEqual(Row1<T1> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row2.`notEqual(Row2<T1,T2> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row3.`notEqual(Row3<T1,T2,T3> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row4.`notEqual(Row4<T1,T2,T3,T4> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row5.`notEqual(Row5<T1,T2,T3,T4,T5> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row6.`notEqual(Row6<T1,T2,T3,T4,T5,T6> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row7.`notEqual(Row7<T1,T2,T3,T4,T5,T6,T7> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row8.`notEqual(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	RowN.`notEqual(RowN row)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Field.`notEqual(Select<?> query)` `this !`
`Condition`	Field.`notEqual(T value)` `this !`
`Condition`	Row1.`notEqual(T1 t1)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row2.`notEqual(T1 t1, T2 t2)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row3.`notEqual(T1 t1, T2 t2, T3 t3)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row4.`notEqual(T1 t1, T2 t2, T3 t3, T4 t4)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row5.`notEqual(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row6.`notEqual(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row7.`notEqual(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Row8.`notEqual(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)` Compare this row value expression with another row value expression for non-equality Row non-equality comparison predicates can be simulated in those databases that do not support such predicates natively: `(A, B) <> (1, 2)` is equivalent to `NOT(A = 1 AND B = 2)`
`Condition`	Field.`notEqualAll(Field<T[]> array)` `this !`
`Condition`	Field.`notEqualAll(Select<?> query)` `this !`
`Condition`	Field.`notEqualAll(T... array)` `this !`
`Condition`	Field.`notEqualAny(Field<T[]> array)` `this !`
`Condition`	Field.`notEqualAny(Select<?> query)` `this !`
`Condition`	Field.`notEqualAny(T... array)` `this !`
`Condition`	Field.`notEqualIgnoreCase(Field<String> value)` `lower(this) !`
`Condition`	Field.`notEqualIgnoreCase(String value)` `lower(this) !`
`Condition`	Field.`notEqualSome(Select<?> query)` Deprecated. - 2.0.2 - Use `Field.notEqualAny(Select)` instead
`Condition`	Row1.`notIn(Collection<? extends Row1<T1>> row)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row2.`notIn(Collection<? extends Row2<T1,T2>> rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row3.`notIn(Collection<? extends Row3<T1,T2,T3>> rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row4.`notIn(Collection<? extends Row4<T1,T2,T3,T4>> rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row5.`notIn(Collection<? extends Row5<T1,T2,T3,T4,T5>> rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row6.`notIn(Collection<? extends Row6<T1,T2,T3,T4,T5,T6>> rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row7.`notIn(Collection<? extends Row7<T1,T2,T3,T4,T5,T6,T7>> rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row8.`notIn(Collection<? extends Row8<T1,T2,T3,T4,T5,T6,T7,T8>> rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	RowN.`notIn(Collection<? extends RowN> rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Field.`notIn(Collection<T> values)` Create a condition to check this field against several values Note that if any of the passed values is `NULL`, then the condition will be `NULL` (or `false`, depending on the dialect) as well.
`Condition`	Field.`notIn(Field<?>... values)` Create a condition to check this field against several values Note that if any of the passed values is `NULL`, then the condition will be `NULL` (or `false`, depending on the dialect) as well.
`Condition`	Row1.`notIn(Row1<T1>... rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row2.`notIn(Row2<T1,T2>... rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row3.`notIn(Row3<T1,T2,T3>... rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row4.`notIn(Row4<T1,T2,T3,T4>... rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row5.`notIn(Row5<T1,T2,T3,T4,T5>... rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row6.`notIn(Row6<T1,T2,T3,T4,T5,T6>... rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row7.`notIn(Row7<T1,T2,T3,T4,T5,T6,T7>... rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row8.`notIn(Row8<T1,T2,T3,T4,T5,T6,T7,T8>... rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	RowN.`notIn(RowN... rows)` Compare this row value expression with a set of row value expressions for equality Row NOT IN predicates can be simulated in those databases that do not support such predicates natively: `(A, B) NOT IN ((1, 2), (3, 4))` is equivalent to `NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4)))`, which is equivalent to `NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))`
`Condition`	Row.`notIn(Select<?> select)` Compare this row value expression with a subselect for non-equality Note that the subquery must return a table of the same degree as this row value expression.
`Condition`	Field.`notIn(Select<?> query)` Create a condition to check this field against a subquery Note that the subquery must return exactly one field.
`Condition`	Field.`notIn(T... values)` Create a condition to check this field against several values Note that if any of the passed values is `NULL`, then the condition will be `NULL` (or `false`, depending on the dialect) as well.
`Condition`	Field.`notLike(Field<String> field)` Create a condition to pattern-check this field against a field SQL: `this not like field`
`Condition`	Field.`notLike(Field<String> field, char escape)` Create a condition to pattern-check this field against a field SQL: `this not like field escape 'e'`
`Condition`	Field.`notLike(String value)` Create a condition to pattern-check this field against a value SQL: `this not like value`
`Condition`	Field.`notLike(String value, char escape)` Create a condition to pattern-check this field against a value SQL: `this not like value escape 'e'`
`Condition`	Field.`notLikeIgnoreCase(Field<String> field)` Create a condition to case-insensitively pattern-check this field against a field This translates to `this not ilike field` in `SQLDialect.POSTGRES`, or to `lower(this) not like lower(field)` in all other dialects.
`Condition`	Field.`notLikeIgnoreCase(Field<String> field, char escape)` Create a condition to case-insensitively pattern-check this field against a field This translates to `this not ilike field` in `SQLDialect.POSTGRES`, or to `lower(this) not like lower(field)` in all other dialects.
`Condition`	Field.`notLikeIgnoreCase(String value)` Create a condition to case-insensitively pattern-check this field against a value This translates to `this not ilike value` in `SQLDialect.POSTGRES`, or to `lower(this) not like lower(value)` in all other dialects.
`Condition`	Field.`notLikeIgnoreCase(String value, char escape)` Create a condition to case-insensitively pattern-check this field against a value This translates to `this not ilike value` in `SQLDialect.POSTGRES`, or to `lower(this) not like lower(value)` in all other dialects.
`Condition`	Field.`notLikeRegex(Field<String> pattern)` Create a condition to regex-pattern-check this field against a pattern See `Field.likeRegex(String)` for more details
`Condition`	Field.`notLikeRegex(String pattern)` Create a condition to regex-pattern-check this field against a pattern See `Field.likeRegex(String)` for more details
`SimpleSelectFinalStep<R>`	SimpleSelectForUpdateWaitStep.`noWait()` Add a `WAIT` clause to the `FOR UPDATE` clause at the end of the query.
`SelectFinalStep`	SelectForUpdateWaitStep.`noWait()` Add a `WAIT` clause to the `FOR UPDATE` clause at the end of the query.
`Field<T>`	Field.`nullif(Field<T> other)` This method is part of the pre-2.0 API.
`Field<T>`	Field.`nullif(T other)` This method is part of the pre-2.0 API.
`SortField<T>`	SortField.`nullsFirst()` Add a `NULLS FIRST` clause to this sort field
`SortField<T>`	SortField.`nullsLast()` Add a `NULLS LAST` clause to this sort field
`LoaderCSVOptionsStep<R>`	LoaderCSVOptionsStep.`nullString(String nullString)` Specify the input string representation of `NULL`.
`Field<T>`	Field.`nvl(Field<T> defaultValue)` This method is part of the pre-2.0 API.
`Field<T>`	Field.`nvl(T defaultValue)` This method is part of the pre-2.0 API.
`<Z> Field<Z>`	Field.`nvl2(Field<Z> valueIfNotNull, Field<Z> valueIfNull)` This method is part of the pre-2.0 API.
`<Z> Field<Z>`	Field.`nvl2(Z valueIfNotNull, Z valueIfNull)` This method is part of the pre-2.0 API.
`Field<Integer>`	Field.`octetLength()` This method is part of the pre-2.0 API.
`SimpleSelectForUpdateWaitStep<R>`	SimpleSelectForUpdateOfStep.`of(Collection<Field<?>> fields)` Add an `OF` clause to the `FOR UPDATE` clause at the end of the query.
`SelectForUpdateWaitStep`	SelectForUpdateOfStep.`of(Collection<Field<?>> fields)` Add an `OF` clause to the `FOR UPDATE` clause at the end of the query.
`SimpleSelectForUpdateWaitStep<R>`	SimpleSelectForUpdateOfStep.`of(Field<?>... fields)` Add an `OF` clause to the `FOR UPDATE` clause at the end of the query.
`SelectForUpdateWaitStep`	SelectForUpdateOfStep.`of(Field<?>... fields)` Add an `OF` clause to the `FOR UPDATE` clause at the end of the query.
`SimpleSelectForUpdateWaitStep<R>`	SimpleSelectForUpdateOfStep.`of(Table<?>... tables)` Add an `OF` clause to the `FOR UPDATE` clause at the end of the query.
`SelectForUpdateWaitStep`	SelectForUpdateOfStep.`of(Table<?>... tables)` Add an `OF` clause to the `FOR UPDATE` clause at the end of the query.
`SimpleSelectForUpdateStep<R>`	SimpleSelectOffsetStep.`offset(int offset)` Add an `OFFSET` clause to the query If there is no `LIMIT ..`
`SelectForUpdateStep`	SelectOffsetStep.`offset(int offset)` Add an `OFFSET` clause to the query If there is no `LIMIT ..`
`SimpleSelectForUpdateStep<R>`	SimpleSelectOffsetStep.`offset(Param<Integer> offset)` Add an `OFFSET` clause to the query using a named parameter If there is no `LIMIT ..`
`SelectForUpdateStep`	SelectOffsetStep.`offset(Param<Integer> offset)` Add an `OFFSET` clause to the query using a named parameter If there is no `LIMIT ..`
`TableOnConditionStep`	TableOnStep.`on(Condition... conditions)` Add an `ON` clause to the `JOIN`
`SelectOnConditionStep`	SelectOnStep.`on(Condition... conditions)` Add an `ON` clause to the previous `JOIN`
`MergeOnConditionStep<R>`	MergeOnStep.`on(Condition... conditions)` Provide join conditions and proceed to the next step
`DivideByOnConditionStep`	DivideByOnStep.`on(Condition... conditions)` Add a division condition to the `DIVIDE BY` clause
`<T> PivotInStep<T>`	PivotForStep.`on(Field<T> field)` Add a list of fields to the `PIVOT` clause.
`TableOnConditionStep`	TableOnStep.`on(String sql)` Add an `ON` clause to the `JOIN` NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectOnConditionStep`	SelectOnStep.`on(String sql)` Add an `ON` clause to the previous `JOIN` NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`MergeOnConditionStep<R>`	MergeOnStep.`on(String sql)` Provide join conditions and proceed to the next step NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`DivideByOnConditionStep`	DivideByOnStep.`on(String sql)` Add a division condition to the `DIVIDE BY` clause NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`TableOnConditionStep`	TableOnStep.`on(String sql, Object... bindings)` Add an `ON` clause to the `JOIN` NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectOnConditionStep`	SelectOnStep.`on(String sql, Object... bindings)` Add an `ON` clause to the previous `JOIN` NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`MergeOnConditionStep<R>`	MergeOnStep.`on(String sql, Object... bindings)` Provide join conditions and proceed to the next step NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`DivideByOnConditionStep`	DivideByOnStep.`on(String sql, Object... bindings)` Add a division condition to the `DIVIDE BY` clause NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`TableOnConditionStep`	TableOnStep.`on(String sql, QueryPart... parts)` Add an `ON` clause to the `JOIN` NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectOnConditionStep`	SelectOnStep.`on(String sql, QueryPart... parts)` Add an `ON` clause to the previous `JOIN` NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`MergeOnConditionStep<R>`	MergeOnStep.`on(String sql, QueryPart... parts)` Provide join conditions and proceed to the next step NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`DivideByOnConditionStep`	DivideByOnStep.`on(String sql, QueryPart... parts)` Add a division condition to the `DIVIDE BY` clause NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`LoaderOptionsStep<R>`	LoaderOptionsStep.`onDuplicateKeyError()` Instruct the `Loader` to cause an error in loading if there are any duplicate records.
`LoaderOptionsStep<R>`	LoaderOptionsStep.`onDuplicateKeyIgnore()` Instruct the `Loader` to skip duplicate records if the main unique key's value is already in the database.
`InsertFinalStep<R>`	InsertOnDuplicateStep.`onDuplicateKeyIgnore()` Add an `ON DUPLICATE KEY IGNORE` clause to this insert query.
`void`	InsertQuery.`onDuplicateKeyIgnore(boolean flag)` Whether an `ON DUPLICATE KEY IGNORE` clause should be added to this `INSERT` statement.
`LoaderOptionsStep<R>`	LoaderOptionsStep.`onDuplicateKeyUpdate()` Instruct the `Loader` to update duplicate records if the main unique key's value is already in the database.
`InsertOnDuplicateSetStep<R>`	InsertOnDuplicateStep.`onDuplicateKeyUpdate()` Add an `ON DUPLICATE KEY UPDATE` clause to this insert query.
`void`	InsertQuery.`onDuplicateKeyUpdate(boolean flag)` Whether a `ON DUPLICATE KEY UPDATE` clause should be added to this `INSERT` statement.
`LoaderOptionsStep<R>`	LoaderOptionsStep.`onErrorAbort()` Instruct the `Loader` to abort loading after the first error that might occur when inserting a record.
`LoaderOptionsStep<R>`	LoaderOptionsStep.`onErrorIgnore()` Instruct the `Loader` to ignore any errors that might occur when inserting a record.
`TableOnConditionStep`	TableOnStep.`onKey()` Join the table on a non-ambiguous foreign key relationship between the two joined tables.
`SelectJoinStep`	SelectOnStep.`onKey()` Join the previous table on a non-ambiguous foreign key relationship between the two joined tables.
`TableOnConditionStep`	TableOnStep.`onKey(ForeignKey<?,?> key)` Join the table on a non-ambiguous foreign key relationship between the two joined tables.
`SelectJoinStep`	SelectOnStep.`onKey(ForeignKey<?,?> key)` Join the table on a non-ambiguous foreign key relationship between the two joined tables.
`TableOnConditionStep`	TableOnStep.`onKey(TableField<?,?>... keyFields)` Join the table on a non-ambiguous foreign key relationship between the two joined tables.
`SelectJoinStep`	SelectOnStep.`onKey(TableField<?,?>... keyFields)` Join the previous table on a non-ambiguous foreign key relationship between the two joined tables.
`UpdateConditionStep<R>`	UpdateConditionStep.`or(Condition condition)` Combine the currently assembled conditions with another one using the `Operator.OR` operator
`TableOnConditionStep`	TableOnConditionStep.`or(Condition condition)` Combine the currently assembled conditions with another one using the `Operator.OR` operator.
`SimpleSelectConditionStep<R>`	SimpleSelectConditionStep.`or(Condition condition)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectOnConditionStep`	SelectOnConditionStep.`or(Condition condition)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectHavingConditionStep`	SelectHavingConditionStep.`or(Condition condition)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectConditionStep`	SelectConditionStep.`or(Condition condition)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`MergeOnConditionStep<R>`	MergeOnConditionStep.`or(Condition condition)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`DivideByOnConditionStep`	DivideByOnConditionStep.`or(Condition condition)` Combine the currently assembled conditions with another one using the `Operator.OR` operator.
`Condition`	Condition.`or(Condition other)` Combine this condition with another one using the `Operator.OR` operator.
`UpdateConditionStep<R>`	UpdateConditionStep.`or(String sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`TableOnConditionStep`	TableOnConditionStep.`or(String sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator.
`SimpleSelectConditionStep<R>`	SimpleSelectConditionStep.`or(String sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectOnConditionStep`	SelectOnConditionStep.`or(String sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectHavingConditionStep`	SelectHavingConditionStep.`or(String sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectConditionStep`	SelectConditionStep.`or(String sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`MergeOnConditionStep<R>`	MergeOnConditionStep.`or(String sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`DivideByOnConditionStep`	DivideByOnConditionStep.`or(String sql)` Combine the currently assembled conditions with another one using the `Operator.OR` operator.
`Condition`	Condition.`or(String sql)` Combine this condition with another one using the `Operator.OR` operator.
`UpdateConditionStep<R>`	UpdateConditionStep.`or(String sql, Object... bindings)` Combine the currently assembled conditions with another one using the `Operator.OR` operator NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`TableOnConditionStep`	TableOnConditionStep.`or(String sql, Object... bindings)` Combine the currently assembled conditions with another one using the `Operator.OR` operator.
`SimpleSelectConditionStep<R>`	SimpleSelectConditionStep.`or(String sql, Object... bindings)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectOnConditionStep`	SelectOnConditionStep.`or(String sql, Object... bindings)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectHavingConditionStep`	SelectHavingConditionStep.`or(String sql, Object... bindings)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectConditionStep`	SelectConditionStep.`or(String sql, Object... bindings)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`MergeOnConditionStep<R>`	MergeOnConditionStep.`or(String sql, Object... bindings)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`DivideByOnConditionStep`	DivideByOnConditionStep.`or(String sql, Object... bindings)` Combine the currently assembled conditions with another one using the `Operator.OR` operator.
`Condition`	Condition.`or(String sql, Object... bindings)` Combine this condition with another one using the `Operator.OR` operator.
`UpdateConditionStep<R>`	UpdateConditionStep.`or(String sql, QueryPart... parts)` Combine the currently assembled conditions with another one using the `Operator.OR` operator NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`TableOnConditionStep`	TableOnConditionStep.`or(String sql, QueryPart... parts)` Combine the currently assembled conditions with another one using the `Operator.OR` operator.
`SimpleSelectConditionStep<R>`	SimpleSelectConditionStep.`or(String sql, QueryPart... parts)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectOnConditionStep`	SelectOnConditionStep.`or(String sql, QueryPart... parts)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectHavingConditionStep`	SelectHavingConditionStep.`or(String sql, QueryPart... parts)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`SelectConditionStep`	SelectConditionStep.`or(String sql, QueryPart... parts)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`MergeOnConditionStep<R>`	MergeOnConditionStep.`or(String sql, QueryPart... parts)` Combine the currently assembled conditions with another one using the `Operator.OR` operator and proceed to the next step.
`DivideByOnConditionStep`	DivideByOnConditionStep.`or(String sql, QueryPart... parts)` Combine the currently assembled conditions with another one using the `Operator.OR` operator.
`Condition`	Condition.`or(String sql, QueryPart... parts)` Combine this condition with another one using the `Operator.OR` operator.
`WindowRowsStep<T>`	WindowOrderByStep.`orderBy(Collection<SortField<?>> fields)` Add an `ORDER BY` clause to the window function.
`SimpleSelectLimitStep<R>`	SimpleSelectOrderByStep.`orderBy(Collection<SortField<?>> fields)` Add an `ORDER BY` clause to the query
`SelectLimitStep`	SelectOrderByStep.`orderBy(Collection<SortField<?>> fields)` Add an `ORDER BY` clause to the query
`GroupConcatSeparatorStep`	GroupConcatOrderByStep.`orderBy(Collection<SortField<?>> fields)` Add an `ORDER BY` clause to the query
`WindowRowsStep<T>`	WindowOrderByStep.`orderBy(Field<?>... fields)` Add an `ORDER BY` clause to the window function.
`SimpleSelectLimitStep<R>`	SimpleSelectOrderByStep.`orderBy(Field<?>... fields)` Add an `ORDER BY` clause to the query
`SelectLimitStep`	SelectOrderByStep.`orderBy(Field<?>... fields)` Add an `ORDER BY` clause to the query
`GroupConcatSeparatorStep`	GroupConcatOrderByStep.`orderBy(Field<?>... fields)` Add an `ORDER BY` clause to the query
`SimpleSelectLimitStep<R>`	SimpleSelectOrderByStep.`orderBy(int... fieldIndexes)` Add an `ORDER BY` clause to the query Indexes start at `1` in SQL!
`SelectLimitStep`	SelectOrderByStep.`orderBy(int... fieldIndexes)` Add an `ORDER BY` clause to the query Indexes start at `1` in SQL!
`WindowRowsStep<T>`	WindowOrderByStep.`orderBy(SortField<?>... fields)` Add an `ORDER BY` clause to the window function.
`SimpleSelectLimitStep<R>`	SimpleSelectOrderByStep.`orderBy(SortField<?>... fields)` Add an `ORDER BY` clause to the query
`SelectLimitStep`	SelectOrderByStep.`orderBy(SortField<?>... fields)` Add an `ORDER BY` clause to the query
`GroupConcatSeparatorStep`	GroupConcatOrderByStep.`orderBy(SortField<?>... fields)` Add an `ORDER BY` clause to the query
`SimpleSelectLimitStep<R>`	SimpleSelectOrderByStep.`orderSiblingsBy(Collection<SortField<?>> fields)` Add an `ORDER SIBLINGS BY` clause to the query This clause can be used only along with Oracle's `CONNECT BY` clause, to indicate that the hierarchical ordering should be preserved and elements of each hierarchy should be ordered among themselves.
`SelectLimitStep`	SelectOrderByStep.`orderSiblingsBy(Collection<SortField<?>> fields)` Add an `ORDER SIBLINGS BY` clause to the query This clause can be used only along with Oracle's `CONNECT BY` clause, to indicate that the hierarchical ordering should be preserved and elements of each hierarchy should be ordered among themselves.
`SimpleSelectLimitStep<R>`	SimpleSelectOrderByStep.`orderSiblingsBy(Field<?>... fields)` Add an `ORDER SIBLINGS BY` clause to the query This clause can be used only along with Oracle's `CONNECT BY` clause, to indicate that the hierarchical ordering should be preserved and elements of each hierarchy should be ordered among themselves.
`SelectLimitStep`	SelectOrderByStep.`orderSiblingsBy(Field<?>... fields)` Add an `ORDER SIBLINGS BY` clause to the query This clause can be used only along with Oracle's `CONNECT BY` clause, to indicate that the hierarchical ordering should be preserved and elements of each hierarchy should be ordered among themselves.
`SimpleSelectLimitStep<R>`	SimpleSelectOrderByStep.`orderSiblingsBy(int... fieldIndexes)` Add an `ORDER SIBLINGS BY` clause to the query This clause can be used only along with Oracle's `CONNECT BY` clause, to indicate that the hierarchical ordering should be preserved and elements of each hierarchy should be ordered among themselves.
`SelectLimitStep`	SelectOrderByStep.`orderSiblingsBy(int... fieldIndexes)` Add an `ORDER SIBLINGS BY` clause to the query This clause can be used only along with Oracle's `CONNECT BY` clause, to indicate that the hierarchical ordering should be preserved and elements of each hierarchy should be ordered among themselves.
`SimpleSelectLimitStep<R>`	SimpleSelectOrderByStep.`orderSiblingsBy(SortField<?>... fields)` Add an `ORDER SIBLINGS BY` clause to the query This clause can be used only along with Oracle's `CONNECT BY` clause, to indicate that the hierarchical ordering should be preserved and elements of each hierarchy should be ordered among themselves.
`SelectLimitStep`	SelectOrderByStep.`orderSiblingsBy(SortField<?>... fields)` Add an `ORDER SIBLINGS BY` clause to the query This clause can be used only along with Oracle's `CONNECT BY` clause, to indicate that the hierarchical ordering should be preserved and elements of each hierarchy should be ordered among themselves.
`UpdateConditionStep<R>`	UpdateConditionStep.`orExists(Select<?> select)` Combine the currently assembled conditions with an EXISTS clause using the `Operator.OR` operator
`TableOnConditionStep`	TableOnConditionStep.`orExists(Select<?> select)` Combine the currently assembled conditions with an `EXISTS` clause using the `Operator.OR` operator.
`SimpleSelectConditionStep<R>`	SimpleSelectConditionStep.`orExists(Select<?> select)` Combine the currently assembled conditions with an EXISTS clause using the `Operator.OR` operator and proceed to the next step.
`SelectOnConditionStep`	SelectOnConditionStep.`orExists(Select<?> select)` Combine the currently assembled conditions with an EXISTS clause using the `Operator.OR` operator and proceed to the next step.
`SelectHavingConditionStep`	SelectHavingConditionStep.`orExists(Select<?> select)` Combine the currently assembled conditions with an EXISTS clause using the `Operator.OR` operator and proceed to the next step.
`SelectConditionStep`	SelectConditionStep.`orExists(Select<?> select)` Combine the currently assembled conditions with an EXISTS clause using the `Operator.OR` operator and proceed to the next step.
`MergeOnConditionStep<R>`	MergeOnConditionStep.`orExists(Select<?> select)` Combine the currently assembled conditions with an EXISTS clause using the `Operator.OR` operator and proceed to the next step.
`DivideByOnConditionStep`	DivideByOnConditionStep.`orExists(Select<?> select)` Combine the currently assembled conditions with an `EXISTS` clause using the `Operator.OR` operator.
`Condition`	Condition.`orExists(Select<?> select)` Combine this condition with an EXISTS clause using the `Operator.OR` operator.
`UpdateConditionStep<R>`	UpdateConditionStep.`orNot(Condition condition)` Combine the currently assembled conditions with a negated other one using the `Operator.OR` operator
`TableOnConditionStep`	TableOnConditionStep.`orNot(Condition condition)` Combine the currently assembled conditions with a negated other one using the `Operator.OR` operator.
`SimpleSelectConditionStep<R>`	SimpleSelectConditionStep.`orNot(Condition condition)` Combine the currently assembled conditions with a negated other one using the `Operator.OR` operator and proceed to the next step.
`SelectOnConditionStep`	SelectOnConditionStep.`orNot(Condition condition)` Combine the currently assembled conditions with a negated other one using the `Operator.OR` operator and proceed to the next step.
`SelectHavingConditionStep`	SelectHavingConditionStep.`orNot(Condition condition)` Combine the currently assembled conditions with a negated other one using the `Operator.OR` operator and proceed to the next step.
`SelectConditionStep`	SelectConditionStep.`orNot(Condition condition)` Combine the currently assembled conditions with a negated other one using the `Operator.OR` operator and proceed to the next step.
`MergeOnConditionStep<R>`	MergeOnConditionStep.`orNot(Condition condition)` Combine the currently assembled conditions with a negated other one using the `Operator.OR` operator and proceed to the next step.
`DivideByOnConditionStep`	DivideByOnConditionStep.`orNot(Condition condition)` Combine the currently assembled conditions with a negated other one using the `Operator.OR` operator.
`Condition`	Condition.`orNot(Condition other)` Combine this condition with a negated other one using the `Operator.OR` operator.
`UpdateConditionStep<R>`	UpdateConditionStep.`orNotExists(Select<?> select)` Combine the currently assembled conditions with a NOT EXISTS clause using the `Operator.OR` operator
`TableOnConditionStep`	TableOnConditionStep.`orNotExists(Select<?> select)` Combine the currently assembled conditions with a `NOT EXISTS` clause using the `Operator.OR` operator.
`SimpleSelectConditionStep<R>`	SimpleSelectConditionStep.`orNotExists(Select<?> select)` Combine the currently assembled conditions with a NOT EXISTS clause using the `Operator.OR` operator and proceed to the next step.
`SelectOnConditionStep`	SelectOnConditionStep.`orNotExists(Select<?> select)` Combine the currently assembled conditions with a NOT EXISTS clause using the `Operator.OR` operator and proceed to the next step.
`SelectHavingConditionStep`	SelectHavingConditionStep.`orNotExists(Select<?> select)` Combine the currently assembled conditions with a NOT EXISTS clause using the `Operator.OR` operator and proceed to the next step.
`SelectConditionStep`	SelectConditionStep.`orNotExists(Select<?> select)` Combine the currently assembled conditions with a NOT EXISTS clause using the `Operator.OR` operator and proceed to the next step.
`MergeOnConditionStep<R>`	MergeOnConditionStep.`orNotExists(Select<?> select)` Combine the currently assembled conditions with a NOT EXISTS clause using the `Operator.OR` operator and proceed to the next step.
`DivideByOnConditionStep`	DivideByOnConditionStep.`orNotExists(Select<?> select)` Combine the currently assembled conditions with a `NOT EXISTS` clause using the `Operator.OR` operator.
`Condition`	Condition.`orNotExists(Select<?> select)` Combine this condition with a NOT EXIST clause using the `Operator.OR` operator.
`Field<T>`	CaseWhenStep.`otherwise(Field<T> result)` Add an else clause to the already constructed case statement
`Field<T>`	CaseConditionStep.`otherwise(Field<T> result)` Add an else clause to the already constructed case statement
`Field<T>`	CaseWhenStep.`otherwise(T result)` Add an else clause to the already constructed case statement
`Field<T>`	CaseConditionStep.`otherwise(T result)` Add an else clause to the already constructed case statement
`WindowPartitionByStep<T>`	WindowOverStep.`over()` Add an `OVER` clause
`WindowPartitionByStep<T>`	WindowBeforeOverStep.`over()` Add an `OVER` clause
`WindowPartitionByStep<T>`	AggregateFunction.`over()` Turn this aggregate function into a window function.
`Condition`	Row2.`overlaps(Field<T1> t1, Field<T2> t2)` Check if this row value expression overlaps another row value expression The SQL standard specifies a temporal `OVERLAPS` predicate, which comes in two flavours: `(DATE, DATE) OVERLAPS (DATE, DATE)` `(DATE, INTERVAL) OVERLAPS (DATE, INTERVAL)` jOOQ also supports arbitrary 2-degree row value expression comparisons, by simulating them as such `-- This predicate (A, B) OVERLAPS (C, D) -- can be simulated as such (C <= B) AND (A <= D)`
`Condition`	Row2.`overlaps(Row2<T1,T2> row)` Check if this row value expression overlaps another row value expression The SQL standard specifies a temporal `OVERLAPS` predicate, which comes in two flavours: `(DATE, DATE) OVERLAPS (DATE, DATE)` `(DATE, INTERVAL) OVERLAPS (DATE, INTERVAL)` jOOQ also supports arbitrary 2-degree row value expression comparisons, by simulating them as such `-- This predicate (A, B) OVERLAPS (C, D) -- can be simulated as such (C <= B) AND (A <= D)`
`Condition`	Row2.`overlaps(T1 t1, T2 t2)` Check if this row value expression overlaps another row value expression The SQL standard specifies a temporal `OVERLAPS` predicate, which comes in two flavours: `(DATE, DATE) OVERLAPS (DATE, DATE)` `(DATE, INTERVAL) OVERLAPS (DATE, INTERVAL)` jOOQ also supports arbitrary 2-degree row value expression comparisons, by simulating them as such `-- This predicate (A, B) OVERLAPS (C, D) -- can be simulated as such (C <= B) AND (A <= D)`
`TableOnStep`	TablePartitionByStep.`partitionBy(Collection<? extends Field<?>> fields)` Add a `PARTITION BY` clause to the right hand side of the `OUTER JOIN` keywords
`SelectOnStep`	SelectJoinPartitionByStep.`partitionBy(Collection<? extends Field<?>> fields)` Add a `PARTITION BY` clause to the right hand side of the `OUTER JOIN` keywords
`WindowOrderByStep<T>`	WindowPartitionByStep.`partitionBy(Field<?>... fields)` Add a `PARTITION BY` clause to the window functions.
`TableOnStep`	TablePartitionByStep.`partitionBy(Field<?>... fields)` Add a `PARTITION BY` clause to the right hand side of the `OUTER JOIN` keywords
`SelectOnStep`	SelectJoinPartitionByStep.`partitionBy(Field<?>... fields)` Add a `PARTITION BY` clause to the right hand side of the `OUTER JOIN` keywords
`WindowOrderByStep<T>`	WindowPartitionByStep.`partitionByOne()` Add a `PARTITION BY 1` clause to the window functions, where such a clause is required by the syntax of an RDBMS.
`PivotForStep`	Table.`pivot(Collection<? extends Field<?>> aggregateFunctions)` Create a new `TABLE` reference from this table, pivoting it into another form For more details, see `Table.pivot(Field...)`
`PivotForStep`	Table.`pivot(Field<?>... aggregateFunctions)` Create a new `TABLE` reference from this table, pivoting it into another form This has been observed to work with `SQLDialect.ORACLE` `SQLDialect.SQLSERVER` (not yet officially supported) Other dialects by using some means of simulation (not yet officially supported)
`Field<Integer>`	Field.`position(Field<String> search)` This method is part of the pre-2.0 API.
`Field<Integer>`	Field.`position(String search)` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	Field.`power(Number exponent)` This method is part of the pre-2.0 API.
`Query`	FactoryOperations.`query(String sql)` Create a new query holding plain SQL.
`Query`	FactoryOperations.`query(String sql, Object... bindings)` Create a new query holding plain SQL.
`Query`	FactoryOperations.`query(String sql, QueryPart... parts)` Create a new query holding plain SQL.
`LoaderCSVOptionsStep<R>`	LoaderCSVOptionsStep.`quote(char quote)` Specify the quote character.
`Field<BigDecimal>`	Field.`rad()` This method is part of the pre-2.0 API.
`Field<String>`	Field.`repeat(Field<? extends Number> count)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`repeat(Number count)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`replace(Field<String> search)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`replace(Field<String> search, Field<String> replace)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`replace(String search)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`replace(String search, String replace)` This method is part of the pre-2.0 API.
`WindowOverStep<T>`	WindowIgnoreNullsStep.`respectNulls()` Add a `RESPECT NULLS` clause to the window function.
`ResultQuery<Record>`	FactoryOperations.`resultQuery(String sql)` Create a new query holding plain SQL.
`ResultQuery<Record>`	FactoryOperations.`resultQuery(String sql, Object... bindings)` Create a new query holding plain SQL.
`ResultQuery<Record>`	FactoryOperations.`resultQuery(String sql, QueryPart... parts)` Create a new query holding plain SQL.
`InsertResultStep<R>`	InsertReturningStep.`returning()` Configure the `INSERT` statement to return all fields in `R`.
`InsertResultStep<R>`	InsertReturningStep.`returning(Collection<? extends Field<?>> fields)` Configure the `INSERT` statement to return a list of fields in `R`.
`Table<Record>`	DivideByReturningStep.`returning(Collection<? extends Field<?>> fields)` Specify the fields that you want the division to return from the dividend
`InsertResultStep<R>`	InsertReturningStep.`returning(Field<?>... fields)` Configure the `INSERT` statement to return a list of fields in `R`.
`Table<Record>`	DivideByReturningStep.`returning(Field<?>... fields)` Specify the fields that you want the division to return from the dividend
`TablePartitionByStep`	Table.`rightOuterJoin(String sql)` `RIGHT OUTER JOIN` a table to this table.
`SelectJoinPartitionByStep`	SelectJoinStep.`rightOuterJoin(String sql)` Convenience method to `RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.rightOuterJoin(String)` This is only possible where the underlying RDBMS supports it NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`TablePartitionByStep`	Table.`rightOuterJoin(String sql, Object... bindings)` `RIGHT OUTER JOIN` a table to this table.
`SelectJoinPartitionByStep`	SelectJoinStep.`rightOuterJoin(String sql, Object... bindings)` Convenience method to `RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.rightOuterJoin(String, Object...)`
`TablePartitionByStep`	Table.`rightOuterJoin(String sql, QueryPart... parts)` `RIGHT OUTER JOIN` a table to this table.
`SelectJoinPartitionByStep`	SelectJoinStep.`rightOuterJoin(String sql, QueryPart... parts)` Convenience method to `RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.rightOuterJoin(String, QueryPart...)`
`TablePartitionByStep`	Table.`rightOuterJoin(TableLike<?> table)` `RIGHT OUTER JOIN` a table to this table.
`SelectJoinPartitionByStep`	SelectJoinStep.`rightOuterJoin(TableLike<?> table)` Convenience method to `RIGHT OUTER JOIN` a table to the last table added to the `FROM` clause using `Table.rightOuterJoin(TableLike)` This is only possible where the underlying RDBMS supports it
`Field<T>`	Field.`round()` This method is part of the pre-2.0 API.
`Field<T>`	Field.`round(int decimals)` This method is part of the pre-2.0 API.
`WindowRowsAndStep<T>`	WindowRowsStep.`rowsBetweenCurrentRow()` Add a `ROWS BETWEEN CURRENT ROW ...`
`WindowRowsAndStep<T>`	WindowRowsStep.`rowsBetweenFollowing(int number)` Add a `ROWS BETWEEN [number] FOLLOWING ...`
`WindowRowsAndStep<T>`	WindowRowsStep.`rowsBetweenPreceding(int number)` Add a `ROWS BETWEEN [number] PRECEDING ...`
`WindowRowsAndStep<T>`	WindowRowsStep.`rowsBetweenUnboundedFollowing()` Add a `ROWS BETWEEN UNBOUNDED FOLLOWING ...`
`WindowRowsAndStep<T>`	WindowRowsStep.`rowsBetweenUnboundedPreceding()` Add a `ROWS BETWEEN UNBOUNDED PRECEDING ...`
`WindowFinalStep<T>`	WindowRowsStep.`rowsCurrentRow()` Add a `ROWS CURRENT ROW` frame clause to the window function.
`WindowFinalStep<T>`	WindowRowsStep.`rowsFollowing(int number)` Add a `ROWS [number] FOLLOWING` frame clause to the window function.
`WindowFinalStep<T>`	WindowRowsStep.`rowsPreceding(int number)` Add a `ROWS [number] PRECEDING` frame clause to the window function.
`WindowFinalStep<T>`	WindowRowsStep.`rowsUnboundedFollowing()` Add a `ROWS UNBOUNDED FOLLOWING` frame clause to the window function.
`WindowFinalStep<T>`	WindowRowsStep.`rowsUnboundedPreceding()` Add a `ROWS UNBOUNDED PRECEDING` frame clause to the window function.
`Field<String>`	Field.`rpad(Field<? extends Number> length)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`rpad(Field<? extends Number> length, Field<String> character)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`rpad(int length)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`rpad(int length, char character)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`rtrim()` This method is part of the pre-2.0 API.
`SelectSelectStep`	SelectSelectStep.`select(Collection<? extends Field<?>> fields)` Add additional fields to the `SELECT` clause of this query
`SelectSelectStep`	FactoryOperations.`select(Collection<? extends Field<?>> fields)` Create a new DSL select statement.
`SelectSelectStep`	SelectSelectStep.`select(Field<?>... fields)` Add additional fields to the `SELECT` clause of this query
`SelectSelectStep`	FactoryOperations.`select(Field<?>... fields)` Create a new DSL select statement.
`Merge<R>`	MergeValuesStep.`select(Select<?> select)` Use a `SELECT` statement as the source of values for the `MERGE` statement This variant of the `MERGE ..`
`Insert<R>`	InsertValuesStep.`select(Select<?> select)` Use a `SELECT` statement as the source of values for the `INSERT` statement This variant of the `INSERT ..`
`Insert<R>`	InsertSetStep.`select(Select<?> select)` Use a `SELECT` statement as the source of values for the `INSERT` statement This variant of the `INSERT ..`
`SelectSelectStep`	FactoryOperations.`selectCount()` Create a new DSL select statement for `COUNT(*)` Example: `Factory create = new Factory(); create.selectCount() .from(table1) .join(table2).on(field1.equal(field2)) .where(field1.greaterThan(100)) .orderBy(field2);`
`SelectSelectStep`	FactoryOperations.`selectDistinct(Collection<? extends Field<?>> fields)` Create a new DSL select statement.
`SelectSelectStep`	FactoryOperations.`selectDistinct(Field<?>... fields)` Create a new DSL select statement.
`<R extends Record> SimpleSelectWhereStep<R>`	FactoryOperations.`selectFrom(Table<R> table)` Create a new DSL select statement Example: `SELECT * FROM [table] WHERE [conditions] ORDER BY [ordering] LIMIT [limit clause]`
`SelectSelectStep`	FactoryOperations.`selectOne()` Create a new DSL select statement for constant `1` literal Example: `Factory create = new Factory(); create.selectOne() .from(table1) .join(table2).on(field1.equal(field2)) .where(field1.greaterThan(100)) .orderBy(field2);`
`SelectQuery`	FactoryOperations.`selectQuery()` Create a new `SelectQuery`
`<R extends Record> SimpleSelectQuery<R>`	FactoryOperations.`selectQuery(TableLike<R> table)` Create a new `SelectQuery`
`SelectSelectStep`	FactoryOperations.`selectZero()` Create a new DSL select statement for constant `0` literal Example: `Factory create = new Factory(); create.selectZero() .from(table1) .join(table2).on(field1.equal(field2)) .where(field1.greaterThan(100)) .orderBy(field2);`
`LoaderCSVOptionsStep<R>`	LoaderCSVOptionsStep.`separator(char separator)` Specify the separator character.
`AggregateFunction<String>`	GroupConcatSeparatorStep.`separator(String separator)` Specify the separator on the `GROUP_CONCAT` function
`<T> UpdateSetMoreStep<R>`	UpdateSetStep.`set(Field<T> field, Field<T> value)` Set a value for a field in the `UPDATE` statement
`<T> MergeNotMatchedSetMoreStep<R>`	MergeNotMatchedSetStep.`set(Field<T> field, Field<T> value)` Set values for `INSERT` in the `MERGE` statement's `WHEN NOT MATCHED clause`
`<T> MergeMatchedSetMoreStep<R>`	MergeMatchedSetStep.`set(Field<T> field, Field<T> value)` Set values for `UPDATE` in the `MERGE` statement's `WHEN MATCHED` clause
`<T> InsertSetMoreStep<R>`	InsertSetStep.`set(Field<T> field, Field<T> value)` Set a value for a field in the `UPDATE` statement
`<T> InsertOnDuplicateSetMoreStep<R>`	InsertOnDuplicateSetStep.`set(Field<T> field, Field<T> value)` Set values for `UPDATE` in the `INSERT` statement's `ON DUPLICATE KEY UPDATE` clause
`<T> UpdateSetMoreStep<R>`	UpdateSetStep.`set(Field<T> field, T value)` Set a value for a field in the `UPDATE` statement
`<T> MergeNotMatchedSetMoreStep<R>`	MergeNotMatchedSetStep.`set(Field<T> field, T value)` Set values for `INSERT` in the `MERGE` statement's `WHEN NOT MATCHED` clause
`<T> MergeMatchedSetMoreStep<R>`	MergeMatchedSetStep.`set(Field<T> field, T value)` Set values for `UPDATE` in the `MERGE` statement's `WHEN MATCHED` clause
`<T> InsertSetMoreStep<R>`	InsertSetStep.`set(Field<T> field, T value)` Set a value for a field in the `UPDATE` statement
`<T> InsertOnDuplicateSetMoreStep<R>`	InsertOnDuplicateSetStep.`set(Field<T> field, T value)` Set values for `UPDATE` in the `INSERT` statement's `ON DUPLICATE KEY UPDATE` clause
`UpdateSetMoreStep<R>`	UpdateSetStep.`set(Map<? extends Field<?>,?> map)` Set a value for a field in the `UPDATE` statement Please assure that key/value pairs have matching `<T>` types.
`MergeNotMatchedSetMoreStep<R>`	MergeNotMatchedSetStep.`set(Map<? extends Field<?>,?> map)` Set multiple values for `INSERT` in the `MERGE` statement's `WHEN NOT MATCHED` clause.
`MergeMatchedSetMoreStep<R>`	MergeMatchedSetStep.`set(Map<? extends Field<?>,?> map)` Set multiple values for `UPDATE` in the `MERGE` statement's `WHEN MATCHED` clause.
`InsertSetMoreStep<R>`	InsertSetStep.`set(Map<? extends Field<?>,?> map)` Set a value for a field in the `UPDATE` statement Please assure that key/value pairs have matching `<T>` types.
`InsertOnDuplicateSetMoreStep<R>`	InsertOnDuplicateSetStep.`set(Map<? extends Field<?>,?> map)` Set multiple values for `UPDATE` in the `INSERT` statement's `ON DUPLICATE KEY UPDATE` clause Please assure that key/value pairs have matching `<T>` types.
`void`	SelectQuery.`setConnectByStartWith(Condition condition)` Add an Oracle-specific `START WITH` clause to the query's `CONNECT BY` clause
`void`	SelectQuery.`setDistinct(boolean distinct)` Add "distinct" keyword to the select clause
`void`	SimpleSelectQuery.`setForShare(boolean forShare)` Sets the "FOR SHARE" flag onto the query This has been observed to be supported by any of these dialects: MySQL's InnoDB locking reads Postgres FOR UPDATE / FOR SHARE If your dialect does not support this clause, jOOQ will still render it, if you apply it to your query.
`void`	SelectQuery.`setForShare(boolean forShare)` Sets the "FOR SHARE" flag onto the query This has been observed to be supported by any of these dialects: MySQL's InnoDB locking reads Postgres FOR UPDATE / FOR SHARE If your dialect does not support this clause, jOOQ will still render it, if you apply it to your query.
`void`	LockProvider.`setForShare(boolean forShare)` Deprecated. Sets the "FOR SHARE" flag onto the query This has been observed to be supported by any of these dialects: MySQL's InnoDB locking reads Postgres FOR UPDATE / FOR SHARE If your dialect does not support this clause, jOOQ will still render it, if you apply it to your query.
`void`	SimpleSelectQuery.`setForUpdate(boolean forUpdate)` Sets the "FOR UPDATE" flag onto the query Native implementation This has been observed to be supported by any of these dialects:	`void`	SelectQuery.`setForUpdate(boolean forUpdate)` Sets the "FOR UPDATE" flag onto the query Native implementation This has been observed to be supported by any of these dialects:	`void`	LockProvider.`setForUpdate(boolean forUpdate)` Deprecated. Sets the "FOR UPDATE" flag onto the query Native implementation This has been observed to be supported by any of these dialects:	`void`	SimpleSelectQuery.`setForUpdateNoWait()` Some RDBMS allow for specifying the locking mode for the applied `FOR UPDATE` clause.
`void`	SelectQuery.`setForUpdateNoWait()` Some RDBMS allow for specifying the locking mode for the applied `FOR UPDATE` clause.
`void`	LockProvider.`setForUpdateNoWait()` Deprecated. Some RDBMS allow for specifying the locking mode for the applied `FOR UPDATE` clause.
`void`	SimpleSelectQuery.`setForUpdateOf(Collection<? extends Field<?>> fields)` Some RDBMS allow for specifying the fields that should be locked by the `FOR UPDATE` clause, instead of the full row.
`void`	SelectQuery.`setForUpdateOf(Collection<? extends Field<?>> fields)` Some RDBMS allow for specifying the fields that should be locked by the `FOR UPDATE` clause, instead of the full row.
`void`	LockProvider.`setForUpdateOf(Collection<? extends Field<?>> fields)` Deprecated. Some RDBMS allow for specifying the fields that should be locked by the `FOR UPDATE` clause, instead of the full row.
`void`	SimpleSelectQuery.`setForUpdateOf(Field<?>... fields)` Some RDBMS allow for specifying the fields that should be locked by the `FOR UPDATE` clause, instead of the full row.
`void`	SelectQuery.`setForUpdateOf(Field<?>... fields)` Some RDBMS allow for specifying the fields that should be locked by the `FOR UPDATE` clause, instead of the full row.
`void`	LockProvider.`setForUpdateOf(Field<?>... fields)` Deprecated. Some RDBMS allow for specifying the fields that should be locked by the `FOR UPDATE` clause, instead of the full row.
`void`	SimpleSelectQuery.`setForUpdateOf(Table<?>... tables)` Some RDBMS allow for specifying the tables that should be locked by the `FOR UPDATE` clause, instead of the full row.
`void`	SelectQuery.`setForUpdateOf(Table<?>... tables)` Some RDBMS allow for specifying the tables that should be locked by the `FOR UPDATE` clause, instead of the full row.
`void`	LockProvider.`setForUpdateOf(Table<?>... tables)` Deprecated. Some RDBMS allow for specifying the tables that should be locked by the `FOR UPDATE` clause, instead of the full row.
`void`	SimpleSelectQuery.`setForUpdateSkipLocked()` Some RDBMS allow for specifying the locking mode for the applied `FOR UPDATE` clause.
`void`	SelectQuery.`setForUpdateSkipLocked()` Some RDBMS allow for specifying the locking mode for the applied `FOR UPDATE` clause.
`void`	LockProvider.`setForUpdateSkipLocked()` Deprecated. Some RDBMS allow for specifying the locking mode for the applied `FOR UPDATE` clause.
`void`	SimpleSelectQuery.`setForUpdateWait(int seconds)` Some RDBMS allow for specifying the locking mode for the applied `FOR UPDATE` clause.
`void`	SelectQuery.`setForUpdateWait(int seconds)` Some RDBMS allow for specifying the locking mode for the applied `FOR UPDATE` clause.
`void`	LockProvider.`setForUpdateWait(int seconds)` Deprecated. Some RDBMS allow for specifying the locking mode for the applied `FOR UPDATE` clause.
`void`	SimpleSelectQuery.`setOrderBySiblings(boolean orderBySiblings)` Indicate whether the `SIBLINGS` keyword should be used in an `ORDER BY` clause to form an `ORDER SIBLINGS BY` clause.
`void`	SelectQuery.`setOrderBySiblings(boolean orderBySiblings)` Indicate whether the `SIBLINGS` keyword should be used in an `ORDER BY` clause to form an `ORDER SIBLINGS BY` clause.
`void`	OrderProvider.`setOrderBySiblings(boolean orderBySiblings)` Deprecated. Indicate whether the `SIBLINGS` keyword should be used in an `ORDER BY` clause to form an `ORDER SIBLINGS BY` clause.
`void`	StoreQuery.`setRecord(R record)` Add values to the store statement
`void`	InsertQuery.`setReturning()` Configure the `INSERT` statement to return all fields in `R`.
`void`	InsertQuery.`setReturning(Collection<? extends Field<?>> fields)` Configure the `INSERT` statement to return a list of fields in `R`.
`void`	InsertQuery.`setReturning(Field<?>... fields)` Configure the `INSERT` statement to return a list of fields in `R`.
`void`	InsertQuery.`setReturning(Identity<R,? extends Number> identity)` Configure the `INSERT` statement to return the generated identity value.
`Field<Integer>`	Field.`sign()` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	Field.`sin()` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	Field.`sinh()` This method is part of the pre-2.0 API.
`SimpleSelectFinalStep<R>`	SimpleSelectForUpdateWaitStep.`skipLocked()` Add a `WAIT` clause to the `FOR UPDATE` clause at the end of the query.
`SelectFinalStep`	SelectForUpdateWaitStep.`skipLocked()` Add a `WAIT` clause to the `FOR UPDATE` clause at the end of the query.
`<Z> SortField<Z>`	Field.`sort(Map<T,Z> sortMap)` Create a sort field of the form (in pseudo code)`CASE [this] WHEN [sortMap.key(0)] THEN sortMap.value(0) WHEN [sortMap.key(1)] THEN sortMap.value(1) ...`
`SortField<T>`	Field.`sort(SortOrder order)` Create an ascending/descending sort field from this field
`SortField<Integer>`	Field.`sortAsc(Collection<T> sortList)` Create a sort field of the form `CASE [this] WHEN [sortList.get(0)] THEN 0 WHEN [sortList.get(1)] THEN 1 ...`
`SortField<Integer>`	Field.`sortAsc(T... sortList)` Create a sort field of the form `CASE [this] WHEN [sortList[0]] THEN 0 WHEN [sortList[1]] THEN 1 ...`
`SortField<Integer>`	Field.`sortDesc(Collection<T> sortList)` Create a sort field of the form `CASE [this] WHEN [sortList.get(0)] THEN 0 WHEN [sortList.get(1)] THEN 1 ...`
`SortField<Integer>`	Field.`sortDesc(T... sortList)` Create a sort field of the form `CASE [this] WHEN [sortList[0]] THEN 0 WHEN [sortList[1]] THEN 1 ...`
`Field<BigDecimal>`	Field.`sqrt()` This method is part of the pre-2.0 API.
`Condition`	Field.`startsWith(Field<T> value)` Convenience method for `Field.like(String, char)` including proper adding of wildcards and escaping SQL: `this like (escape(value, '\') \|\| '%') escape '\'` Note: This also works with numbers, for instance `val(1133).startsWith(11)`
`Condition`	Field.`startsWith(T value)` Convenience method for `Field.like(String, char)` including proper adding of wildcards and escaping SQL: `this like (escape(value, '\') \|\| '%') escape '\'` Note: This also works with numbers, for instance `val(1133).startsWith(11)`
`SelectGroupByStep`	SelectStartWithStep.`startWith(Condition condition)` Add an Oracle-specific `START WITH` clause to the query's `CONNECT BY` clause
`SelectGroupByStep`	SelectStartWithStep.`startWith(String sql)` Add an Oracle-specific `START WITH` clause to the query's `CONNECT BY` clause NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectGroupByStep`	SelectStartWithStep.`startWith(String sql, Object... bindings)` Add an Oracle-specific `START WITH` clause to the query's `CONNECT BY` clause NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectGroupByStep`	SelectStartWithStep.`startWith(String sql, QueryPart... parts)` Add an Oracle-specific `START WITH` clause to the query's `CONNECT BY` clause NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`Field<BigDecimal>`	Field.`stddevPop()` This method is part of the pre-2.0 API.
`WindowPartitionByStep<BigDecimal>`	Field.`stddevPopOver()` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	Field.`stddevSamp()` This method is part of the pre-2.0 API.
`WindowPartitionByStep<BigDecimal>`	Field.`stddevSampOver()` This method is part of the pre-2.0 API.
`Field<T>`	Field.`sub(Field<?> value)` An arithmetic expression subtracting value from this.
`Field<T>`	Field.`sub(Number value)` An arithmetic expression subtracting value from this.
`Field<String>`	Field.`substring(Field<? extends Number> startingPosition)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`substring(Field<? extends Number> startingPosition, Field<? extends Number> length)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`substring(int startingPosition)` This method is part of the pre-2.0 API.
`Field<String>`	Field.`substring(int startingPosition, int length)` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	Field.`sum()` This method is part of the pre-2.0 API.
`WindowPartitionByStep<BigDecimal>`	Field.`sumOver()` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	Field.`tan()` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	Field.`tanh()` This method is part of the pre-2.0 API.
`Field<String>`	Field.`trim()` This method is part of the pre-2.0 API.
`<R extends Record> Truncate<R>`	FactoryOperations.`truncate(Table<R> table)` Create a new DSL truncate statement.
`Select<R>`	Select.`union(Select<R> select)` Combine with other selects
`Select<R>`	Select.`unionAll(Select<R> select)` Combine with other selects
`<R extends Record> UpdateSetStep<R>`	FactoryOperations.`update(Table<R> table)` Create a new DSL update statement.
`<R extends Record> UpdateQuery<R>`	FactoryOperations.`updateQuery(Table<R> table)` Create a new `UpdateQuery`
`Field<String>`	Field.`upper()` This method is part of the pre-2.0 API.
`int`	FactoryOperations.`use(Schema schema)` Use a schema as the default schema of the underlying connection.
`int`	FactoryOperations.`use(String schema)` Use a schema as the default schema of the underlying connection.
`Table<Record>`	TableOnStep.`using(Collection<? extends Field<?>> fields)` Join the table with the `USING(column [, column...])`
`SelectJoinStep`	SelectOnStep.`using(Collection<? extends Field<?>> fields)` Join the previous table with the `USING(column [, column...])`
`Table<Record>`	TableOnStep.`using(Field<?>... fields)` Join the table with the `USING(column [, column...])`
`SelectJoinStep`	SelectOnStep.`using(Field<?>... fields)` Join the previous table with the `USING(column [, column...])`
`MergeOnStep<R>`	MergeUsingStep.`using(TableLike<?> table)` Add the `USING` clause to the SQL standard `MERGE` statement
`MergeOnStep<R>`	MergeUsingStep.`usingDual()` Add a dummy `USING` clause to the SQL standard `MERGE` statement This results in `USING(SELECT 1 FROM DUAL)` for most RDBMS, or in `USING(SELECT 1) AS [dummy_table(dummy_field)]` in SQL Server, where derived tables need to be aliased.
`<V> CaseValueStep<V>`	Case.`value(Field<V> value)` This construct can be used to create expressions of the type `CASE value WHEN 1 THEN 'one' WHEN 2 THEN 'two' ELSE 'three' END`
`<V> CaseValueStep<V>`	Case.`value(V value)` This construct can be used to create expressions of the type `CASE value WHEN 1 THEN 'one' WHEN 2 THEN 'two' ELSE 'three' END`
`Merge<R>`	MergeValuesStep.`values(Collection<?> values)` Specify a `VALUES` clause
`MergeNotMatchedWhereStep<R>`	MergeNotMatchedValuesStep.`values(Collection<?> values)` Set `VALUES` for `INSERT` in the `MERGE` statement's `WHEN NOT MATCHED THEN INSERT` clause.
`InsertValuesStep<R>`	InsertValuesStep.`values(Collection<?> values)` Add values to the insert statement
`InsertValuesStep<R>`	InsertSetStep.`values(Collection<?> values)` Add values to the insert statement with implicit field names
`Merge<R>`	MergeValuesStep.`values(Field<?>... values)` Specify a `VALUES` clause
`MergeNotMatchedWhereStep<R>`	MergeNotMatchedValuesStep.`values(Field<?>... values)` Set `VALUES` for `INSERT` in the `MERGE` statement's `WHEN NOT MATCHED THEN INSERT` clause.
`InsertValuesStep<R>`	InsertValuesStep.`values(Field<?>... values)` Add values to the insert statement
`InsertValuesStep<R>`	InsertSetStep.`values(Field<?>... values)` Add values to the insert statement with implicit field names
`Merge<R>`	MergeValuesStep.`values(Object... values)` Specify a `VALUES` clause
`MergeNotMatchedWhereStep<R>`	MergeNotMatchedValuesStep.`values(Object... values)` Set `VALUES` for `INSERT` in the `MERGE` statement's `WHEN NOT MATCHED THEN INSERT` clause.
`InsertValuesStep<R>`	InsertValuesStep.`values(Object... values)` Add values to the insert statement
`InsertValuesStep<R>`	InsertSetStep.`values(Object... values)` Add values to the insert statement with implicit field names
`Field<BigDecimal>`	Field.`varPop()` This method is part of the pre-2.0 API.
`WindowPartitionByStep<BigDecimal>`	Field.`varPopOver()` This method is part of the pre-2.0 API.
`Field<BigDecimal>`	Field.`varSamp()` This method is part of the pre-2.0 API.
`WindowPartitionByStep<BigDecimal>`	Field.`varSampOver()` This method is part of the pre-2.0 API.
`SimpleSelectFinalStep<R>`	SimpleSelectForUpdateWaitStep.`wait(int seconds)` Add a `WAIT` clause to the `FOR UPDATE` clause at the end of the query.
`SelectFinalStep`	SelectForUpdateWaitStep.`wait(int seconds)` Add a `WAIT` clause to the `FOR UPDATE` clause at the end of the query.
`CaseConditionStep<T>`	CaseConditionStep.`when(Condition condition, Field<T> result)` Compare a condition to the already constructed case statement, return result if the condition holds true
`<T> CaseConditionStep<T>`	Case.`when(Condition condition, Field<T> result)` This construct can be used to create expressions of the type `CASE WHEN x < 1 THEN 'one' WHEN x >= 2 THEN 'two' ELSE 'three' END` Instances of Case are created through the
`CaseConditionStep<T>`	CaseConditionStep.`when(Condition condition, T result)` Compare a condition to the already constructed case statement, return result if the condition holds true
`<T> CaseConditionStep<T>`	Case.`when(Condition condition, T result)` This construct can be used to create expressions of the type `CASE WHEN x < 1 THEN 'one' WHEN x >= 2 THEN 'two' ELSE 'three' END` Instances of Case are created through the
`CaseWhenStep<V,T>`	CaseWhenStep.`when(Field<V> compareValue, Field<T> result)` Compare a value to the already constructed case statement, return result if values are equal.
`<T> CaseWhenStep<V,T>`	CaseValueStep.`when(Field<V> compareValue, Field<T> result)` Compare a value to the already constructed case statement, return result if values are equal.
`CaseWhenStep<V,T>`	CaseWhenStep.`when(Field<V> compareValue, T result)` Compare a value to the already constructed case statement, return result if values are equal.
`<T> CaseWhenStep<V,T>`	CaseValueStep.`when(Field<V> compareValue, T result)` Compare a value to the already constructed case statement, return result if values are equal.
`CaseWhenStep<V,T>`	CaseWhenStep.`when(V compareValue, Field<T> result)` Compare a value to the already constructed case statement, return result if values are equal.
`<T> CaseWhenStep<V,T>`	CaseValueStep.`when(V compareValue, Field<T> result)` Compare a value to the already constructed case statement, return result if values are equal.
`CaseWhenStep<V,T>`	CaseWhenStep.`when(V compareValue, T result)` Compare a value to the already constructed case statement, return result if values are equal.
`<T> CaseWhenStep<V,T>`	CaseValueStep.`when(V compareValue, T result)` Compare a value to the already constructed case statement, return result if values are equal.
`MergeMatchedSetStep<R>`	MergeMatchedStep.`whenMatchedThenUpdate()` Add the `WHEN MATCHED THEN UPDATE` clause to the `MERGE` statement
`MergeNotMatchedSetStep<R>`	MergeNotMatchedStep.`whenNotMatchedThenInsert()` Add the `WHEN NOT MATCHED THEN INSERT` clause to the `MERGE` statement.
`MergeNotMatchedValuesStep<R>`	MergeNotMatchedStep.`whenNotMatchedThenInsert(Collection<? extends Field<?>> fields)` Add the `WHEN MATCHED THEN UPDATE` clause to the `MERGE` statement
`MergeNotMatchedValuesStep<R>`	MergeNotMatchedStep.`whenNotMatchedThenInsert(Field<?>... fields)` Add the `WHEN NOT MATCHED THEN INSERT` clause to the `MERGE` statement
`UpdateConditionStep<R>`	UpdateWhereStep.`where(Collection<Condition> conditions)` Add conditions to the query
`SimpleSelectConditionStep<R>`	SimpleSelectWhereStep.`where(Collection<Condition> conditions)` Add a `WHERE` clause to the query
`SelectConditionStep`	SelectWhereStep.`where(Collection<Condition> conditions)` Add a `WHERE` clause to the query
`DeleteConditionStep<R>`	DeleteWhereStep.`where(Collection<Condition> conditions)` Add conditions to the query
`UpdateConditionStep<R>`	UpdateWhereStep.`where(Condition... conditions)` Add conditions to the query
`SimpleSelectConditionStep<R>`	SimpleSelectWhereStep.`where(Condition... conditions)` Add a `WHERE` clause to the query
`SelectConditionStep`	SelectWhereStep.`where(Condition... conditions)` Add a `WHERE` clause to the query
`DeleteConditionStep<R>`	DeleteWhereStep.`where(Condition... conditions)` Add conditions to the query
`MergeFinalStep<R>`	MergeNotMatchedWhereStep.`where(Condition condition)` Add an additional `WHERE` clause to the preceding `WHEN NOT MATCHED THEN INSERT` clause.
`MergeMatchedDeleteStep<R>`	MergeMatchedWhereStep.`where(Condition condition)` Add an additional `WHERE` clause to the preceding `WHEN MATCHED THEN UPDATE` clause.
`UpdateConditionStep<R>`	UpdateWhereStep.`where(String sql)` Add conditions to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SimpleSelectConditionStep<R>`	SimpleSelectWhereStep.`where(String sql)` Add a `WHERE` clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectConditionStep`	SelectWhereStep.`where(String sql)` Add a `WHERE` clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`DeleteConditionStep<R>`	DeleteWhereStep.`where(String sql)` Add conditions to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`UpdateConditionStep<R>`	UpdateWhereStep.`where(String sql, Object... bindings)` Add conditions to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SimpleSelectConditionStep<R>`	SimpleSelectWhereStep.`where(String sql, Object... bindings)` Add a `WHERE` clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectConditionStep`	SelectWhereStep.`where(String sql, Object... bindings)` Add a `WHERE` clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`DeleteConditionStep<R>`	DeleteWhereStep.`where(String sql, Object... bindings)` Add conditions to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`UpdateConditionStep<R>`	UpdateWhereStep.`where(String sql, QueryPart... parts)` Add conditions to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SimpleSelectConditionStep<R>`	SimpleSelectWhereStep.`where(String sql, QueryPart... parts)` Add a `WHERE` clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`SelectConditionStep`	SelectWhereStep.`where(String sql, QueryPart... parts)` Add a `WHERE` clause to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`DeleteConditionStep<R>`	DeleteWhereStep.`where(String sql, QueryPart... parts)` Add conditions to the query NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity.
`UpdateConditionStep<R>`	UpdateWhereStep.`whereExists(Select<?> select)` Add an EXISTS clause to the query
`SimpleSelectConditionStep<R>`	SimpleSelectWhereStep.`whereExists(Select<?> select)` Add a `WHERE EXISTS` clause to the query
`SelectConditionStep`	SelectWhereStep.`whereExists(Select<?> select)` Add a `WHERE EXISTS` clause to the query
`DeleteConditionStep<R>`	DeleteWhereStep.`whereExists(Select<?> select)` Add an EXISTS clause to the query
`UpdateConditionStep<R>`	UpdateWhereStep.`whereNotExists(Select<?> select)` Add a NOT EXISTS clause to the query
`SimpleSelectConditionStep<R>`	SimpleSelectWhereStep.`whereNotExists(Select<?> select)` Add a `WHERE NOT EXISTS` clause to the query
`SelectConditionStep`	SelectWhereStep.`whereNotExists(Select<?> select)` Add a `WHERE NOT EXISTS` clause to the query
`DeleteConditionStep<R>`	DeleteWhereStep.`whereNotExists(Select<?> select)` Add a NOT EXISTS clause to the query
`AggregateFunction<T>`	OrderedAggregateFunction.`withinGroupOrderBy(Collection<SortField<?>> fields)` Add an `WITHIN GROUP (ORDER BY ..)`
`AggregateFunction<T>`	OrderedAggregateFunction.`withinGroupOrderBy(Field<?>... fields)` Add an `WITHIN GROUP (ORDER BY ..)`
`AggregateFunction<T>`	OrderedAggregateFunction.`withinGroupOrderBy(SortField<?>... fields)` Add an `WITHIN GROUP (ORDER BY ..)`






Uses of Support in org.jooq.impl

Methods in org.jooq.impl with annotations of type Support 

Modifier and Type
Method and Description



static <T extends Number> 
Field<T>
Factory.abs(Field<T> field)
Get the absolute value of a numeric field: abs(field)
 
 This renders the same on all dialects:
 abs([field])



static <T extends Number> 
Field<T>
Factory.abs(T value)
Get the absolute value of a numeric field: abs(field)



static Field<BigDecimal>
Factory.acos(Field<? extends Number> field)
Get the arc cosine(field) function
 
 This renders the acos function where available:
 acos([field])



static Field<BigDecimal>
Factory.acos(Number value)
Get the arc cosine(field) function



static Field<Integer>
Factory.ascii(Field<String> field)
Get the ascii(field) function
 
 This renders the ascii function:
 ascii([field])



static Field<Integer>
Factory.ascii(String field)
Get the ascii(field) function



static Field<BigDecimal>
Factory.asin(Field<? extends Number> field)
Get the arc sine(field) function
 
 This renders the asin function where available:
 asin([field])



static Field<BigDecimal>
Factory.asin(Number value)
Get the arc sine(field) function



static Field<BigDecimal>
Factory.atan(Field<? extends Number> field)
Get the arc tangent(field) function
 
 This renders the atan function where available:
 atan([field])



static Field<BigDecimal>
Factory.atan(Number value)
Get the arc tangent(field) function



static Field<BigDecimal>
Factory.atan2(Field<? extends Number> x,
     Field<? extends Number> y)
Get the atan2(field, y) function
 
 This renders the atan2 or atn2 function where available:
 atan2([x], [y]) or
 atn2([x], [y])



static Field<BigDecimal>
Factory.atan2(Field<? extends Number> x,
     Number y)
Get the atan2(field, y) function



static Field<BigDecimal>
Factory.atan2(Number x,
     Field<? extends Number> y)
Get the atan2(field, y) function



static Field<BigDecimal>
Factory.atan2(Number x,
     Number y)
Get the atan2(field, y) function



static AggregateFunction<BigDecimal>
Factory.avg(Field<? extends Number> field)
Get the average over a numeric field: avg(field)



static AggregateFunction<BigDecimal>
Factory.avgDistinct(Field<? extends Number> field)
Get the average over a numeric field: avg(distinct field)



static <T extends Number> 
Field<T>
Factory.bitAnd(Field<T> field1,
      Field<T> field2)
The bitwise and operator.



static <T extends Number> 
Field<T>
Factory.bitAnd(Field<T> value1,
      T value2)
The bitwise and operator.



static <T extends Number> 
Field<T>
Factory.bitAnd(T value1,
      Field<T> value2)
The bitwise and operator.



static <T extends Number> 
Field<T>
Factory.bitAnd(T value1,
      T value2)
The bitwise and operator.



static Field<Integer>
Factory.bitCount(Field<? extends Number> field)
The MySQL BIT_COUNT(field) function, counting the number of
 bits that are set in this number.



static Field<Integer>
Factory.bitCount(Number value)
The MySQL BIT_COUNT(field) function, counting the number of
 bits that are set in this number.



static Field<Integer>
Factory.bitLength(Field<String> field)
Get the bit_length(field) function
 
 This translates into any dialect



static Field<Integer>
Factory.bitLength(String value)
Get the bit_length(field) function
 
 This translates into any dialect



static <T extends Number> 
Field<T>
Factory.bitNand(Field<T> field1,
       Field<T> field2)
The bitwise not and operator.



static <T extends Number> 
Field<T>
Factory.bitNand(Field<T> value1,
       T value2)
The bitwise not and operator.



static <T extends Number> 
Field<T>
Factory.bitNand(T value1,
       Field<T> value2)
The bitwise not and operator.



static <T extends Number> 
Field<T>
Factory.bitNand(T value1,
       T value2)
The bitwise not and operator.



static <T extends Number> 
Field<T>
Factory.bitNor(Field<T> field1,
      Field<T> field2)
The bitwise not or operator.



static <T extends Number> 
Field<T>
Factory.bitNor(Field<T> value1,
      T value2)
The bitwise not or operator.



static <T extends Number> 
Field<T>
Factory.bitNor(T value1,
      Field<T> value2)
The bitwise not or operator.



static <T extends Number> 
Field<T>
Factory.bitNor(T value1,
      T value2)
The bitwise not or operator.



static <T extends Number> 
Field<T>
Factory.bitNot(Field<T> field)
The bitwise not operator.



static <T extends Number> 
Field<T>
Factory.bitNot(T value)
The bitwise not operator.



static <T extends Number> 
Field<T>
Factory.bitOr(Field<T> field1,
     Field<T> field2)
The bitwise or operator.



static <T extends Number> 
Field<T>
Factory.bitOr(Field<T> value1,
     T value2)
The bitwise or operator.



static <T extends Number> 
Field<T>
Factory.bitOr(T value1,
     Field<T> value2)
The bitwise or operator.



static <T extends Number> 
Field<T>
Factory.bitOr(T value1,
     T value2)
The bitwise or operator.



static <T extends Number> 
Field<T>
Factory.bitXNor(Field<T> field1,
       Field<T> field2)
The bitwise not xor operator.



static <T extends Number> 
Field<T>
Factory.bitXNor(Field<T> value1,
       T value2)
The bitwise not xor operator.



static <T extends Number> 
Field<T>
Factory.bitXNor(T value1,
       Field<T> value2)
The bitwise not xor operator.



static <T extends Number> 
Field<T>
Factory.bitXNor(T value1,
       T value2)
The bitwise not xor operator.



static <T extends Number> 
Field<T>
Factory.bitXor(Field<T> field1,
      Field<T> field2)
The bitwise xor operator.



static <T extends Number> 
Field<T>
Factory.bitXor(Field<T> value1,
      T value2)
The bitwise xor operator.



static <T extends Number> 
Field<T>
Factory.bitXor(T value1,
      Field<T> value2)
The bitwise xor operator.



static <T extends Number> 
Field<T>
Factory.bitXor(T value1,
      T value2)
The bitwise xor operator.



static <T> Field<T>
Factory.cast(Object value,
    Class<? extends T> type)
Cast a value to another type



static <T> Field<T>
Factory.cast(Object value,
    DataType<T> type)
Cast a value to another type



static <T> Field<T>
Factory.cast(Object value,
    Field<T> as)
Cast a value to the type of another field.



static <T> Field<T>
Factory.castNull(Class<? extends T> type)
Cast null to a type



static <T> Field<T>
Factory.castNull(DataType<T> type)
Cast null to a type



static <T> Field<T>
Factory.castNull(Field<T> as)
Cast null to the type of another field.



static <T extends Number> 
Field<T>
Factory.ceil(Field<T> field)
Get the smallest integer value not less than [field]
 
 This renders the ceil or ceiling function where available:
 ceil([field]) or
 ceiling([field])
 ... or simulates it elsewhere using round:
 round([field] + 0.499999999999999)



static <T extends Number> 
Field<T>
Factory.ceil(T value)
Get the smallest integer value not less than [this]



static Field<Integer>
Factory.charLength(Field<String> field)
Get the char_length(field) function
 
 This translates into any dialect



static Field<Integer>
Factory.charLength(String value)
Get the char_length(field) function
 
 This translates into any dialect



static <T> Field<T>
Factory.coalesce(Field<T> field,
        Field<?>... fields)
Gets the Oracle-style COALESCE(field1, field2, ... , field n)
 function
 
 Returns the dialect's equivalent to COALESCE:
 
 Oracle COALESCE
 
 



static <T> Field<T>
Factory.coalesce(T value,
        T... values)
Gets the Oracle-style COALESCE(value1, value2, ... , value n)
 function



static Field<String>
Factory.concat(Field<?>... fields)
Get the concat(field[, field, ...]) function
 
 This creates fields[0] || fields[1] || ...




static Field<String>
Factory.concat(String... values)
Get the concat(value[, value, ...]) function



static Condition
Factory.condition(String sql)
Create a new condition holding plain SQL.



static Condition
Factory.condition(String sql,
         Object... bindings)
Create a new condition holding plain SQL.



static Condition
Factory.condition(String sql,
         QueryPart... parts)
A custom SQL clause that can render arbitrary SQL elements.



static Field<Boolean>
Factory.connectByIsCycle()
Retrieve the Oracle-specific CONNECT_BY_ISCYCLE pseudo-field
 (to be used along with CONNECT BY clauses)



static Field<Boolean>
Factory.connectByIsLeaf()
Retrieve the Oracle-specific CONNECT_BY_ISLEAF pseudo-field
 (to be used along with CONNECT BY clauses)



static <T> Field<T>
Factory.connectByRoot(Field<T> field)
Retrieve the Oracle-specific CONNECT_BY_ROOT pseudo-column
 (to be used along with CONNECT BY clauses)



static Field<BigDecimal>
Factory.cos(Field<? extends Number> field)
Get the cosine(field) function
 
 This renders the cos function where available:
 cos([field])



static Field<BigDecimal>
Factory.cos(Number value)
Get the cosine(field) function



static Field<BigDecimal>
Factory.cosh(Field<? extends Number> field)
Get the hyperbolic cosine function: cosh(field)
 
 This renders the cosh function where available:
 cosh([field]) ... or simulates it elsewhere using
 exp: (exp([field] * 2) + 1) / (exp([field] * 2))



static Field<BigDecimal>
Factory.cosh(Number value)
Get the hyperbolic cosine function: cosh(field)



static Field<BigDecimal>
Factory.cot(Field<? extends Number> field)
Get the cotangent(field) function
 
 This renders the cot function where available:
 cot([field]) ... or simulates it elsewhere using
 sin and cos: cos([field]) / sin([field])



static Field<BigDecimal>
Factory.cot(Number value)
Get the cotangent(field) function



static Field<BigDecimal>
Factory.coth(Field<? extends Number> field)
Get the hyperbolic cotangent function: coth(field)
 
 This is not supported by any RDBMS, but simulated using exp exp:
 (exp([field] * 2) + 1) / (exp([field] * 2) - 1)



static Field<BigDecimal>
Factory.coth(Number value)
Get the hyperbolic cotangent function: coth(field)



static AggregateFunction<Integer>
Factory.count()
Get the count(*) function



static AggregateFunction<Integer>
Factory.count(Field<?> field)
Get the count(field) function



static AggregateFunction<Integer>
Factory.countDistinct(Field<?>... fields)
Get the count(distinct field1, field2) function
 
 Some dialects support several expressions in the COUNT(DISTINCT expr1, expr2) aggregate function.



static AggregateFunction<Integer>
Factory.countDistinct(Field<?> field)
Get the count(distinct field) function



static Field<?>
Factory.cube(Field<?>... fields)
Create a CUBE(field1, field2, .., fieldn) grouping field
 
 This has been observed to work with the following databases:
 
 DB2
 Oracle
 SQL Server
 Sybase SQL Anywhere
 
 
 Please check the SQL Server documentation for a very nice explanation of
 CUBE, ROLLUP, and GROUPING SETS
 clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx



static WindowOverStep<BigDecimal>
Factory.cumeDist()
The cume_dist() over ([analytic clause]) function.



static Field<Date>
Factory.currentDate()
Get the current_date() function
 
 This translates into any dialect



static Field<Time>
Factory.currentTime()
Get the current_time() function
 
 This translates into any dialect



static Field<Timestamp>
Factory.currentTimestamp()
Get the current_timestamp() function
 
 This translates into any dialect



static Field<String>
Factory.currentUser()
Get the current_user() function
 
 This translates into any dialect



static Field<Date>
Factory.dateAdd(Date date,
       Number interval)
Add an interval to a date
 
 This translates into any dialect



static Field<Date>
Factory.dateAdd(Field<Date> date,
       Field<? extends Number> interval)
Add an interval to a date
 
 This translates into any dialect



static Field<Integer>
Factory.dateDiff(Date date1,
        Date date2)
Get the date difference in number of days
 
 This translates into any dialect



static Field<Integer>
Factory.dateDiff(Date date1,
        Field<Date> date2)
Get the date difference in number of days
 
 This translates into any dialect



static Field<Integer>
Factory.dateDiff(Field<Date> date1,
        Date date2)
Get the date difference in number of days
 
 This translates into any dialect



static Field<Integer>
Factory.dateDiff(Field<Date> date1,
        Field<Date> date2)
Get the date difference in number of days
 
 This translates into any dialect



static Field<Integer>
Factory.day(Date value)
Get the day part of a date
 
 This is the same as calling Factory.extract(java.util.Date, DatePart)
 with DatePart.DAY



static Field<Integer>
Factory.day(Field<? extends Date> field)
Get the day part of a date
 
 This is the same as calling Factory.extract(Field, DatePart)
 with DatePart.DAY



static Case
Factory.decode()
Initialise a Case statement.



static <Z,T> Field<Z>
Factory.decode(Field<T> value,
      Field<T> search,
      Field<Z> result)
Gets the Oracle-style
 DECODE(expression, search, result[, search , result]... [, default])
 function



static <Z,T> Field<Z>
Factory.decode(Field<T> value,
      Field<T> search,
      Field<Z> result,
      Field<?>... more)
Gets the Oracle-style
 DECODE(expression, search, result[, search , result]... [, default])
 function
 
 Returns the dialect's equivalent to DECODE:
 
 Oracle DECODE
 
 
 Other dialects: 
 CASE WHEN [this = search] THEN [result],
     [WHEN more...




static <Z,T> Field<Z>
Factory.decode(T value,
      T search,
      Z result)
Gets the Oracle-style
 DECODE(expression, search, result[, search , result]... [, default])
 function



static <Z,T> Field<Z>
Factory.decode(T value,
      T search,
      Z result,
      Object... more)
Gets the Oracle-style
 DECODE(expression, search, result[, search , result]... [, default])
 function



static Field<BigDecimal>
Factory.deg(Field<? extends Number> field)
Calculate degrees from radians from this field
 
 This renders the degrees function where available:
 degrees([field]) ... or simulates it elsewhere:
 [field] * 180 / PI



static Field<BigDecimal>
Factory.deg(Number value)
Calculate degrees from radians from this field



static WindowOverStep<Integer>
Factory.denseRank()
The dense_rank() over ([analytic clause]) function.



static Field<BigDecimal>
Factory.e()
The E literal (Euler number)
 
 This will be any of the following:
 
 The underlying RDBMS' E literal or E() function
 Math.E
 



static Field<String>
Factory.escape(Field<String> field,
      char escape)
Convenience method for Factory.replace(Field, String, String) to escape
 data for use with Field.like(Field, char)
 
 Essentially, this escapes % and _ characters



static String
Factory.escape(String value,
      char escape)
Convenience method for Factory.replace(Field, String, String) to escape
 data for use with Field.like(Field, char)
 
 Essentially, this escapes % and _ characters



static Condition
Factory.exists(Select<?> query)
Create an exists condition.



static Field<BigDecimal>
Factory.exp(Field<? extends Number> field)
Get the exp(field) function, taking this field as the power of e
 
 This renders the same on all dialects:
 exp([field])



static Field<BigDecimal>
Factory.exp(Number value)
Get the exp(field) function, taking this field as the power of e



static Field<Integer>
Factory.extract(Date value,
       DatePart datePart)
Get the extract(field, datePart) function
 
 This translates into any dialect



static Field<Integer>
Factory.extract(Field<? extends Date> field,
       DatePart datePart)
Get the extract(field, datePart) function
 
 This translates into any dialect



static Condition
Factory.falseCondition()
Return a Condition that will always evaluate to false



static Field<Object>
Factory.field(String sql)
A PlainSQLField is a field that can contain user-defined plain SQL,
 because sometimes it is easier to express things directly in SQL, for
 instance complex proprietary functions.



static <T> Field<T>
Factory.field(String sql,
     Class<T> type)
A PlainSQLField is a field that can contain user-defined plain SQL,
 because sometimes it is easier to express things directly in SQL, for
 instance complex proprietary functions.



static <T> Field<T>
Factory.field(String sql,
     Class<T> type,
     Object... bindings)
A PlainSQLField is a field that can contain user-defined plain SQL,
 because sometimes it is easier to express things directly in SQL, for
 instance complex proprietary functions.



static <T> Field<T>
Factory.field(String sql,
     DataType<T> type)
A PlainSQLField is a field that can contain user-defined plain SQL,
 because sometimes it is easier to express things directly in SQL, for
 instance complex proprietary functions.



static <T> Field<T>
Factory.field(String sql,
     DataType<T> type,
     Object... bindings)
A PlainSQLField is a field that can contain user-defined plain SQL,
 because sometimes it is easier to express things directly in SQL, for
 instance complex proprietary functions.



static Field<Object>
Factory.field(String sql,
     Object... bindings)
A PlainSQLField is a field that can contain user-defined plain SQL,
 because sometimes it is easier to express things directly in SQL, for
 instance complex proprietary functions.



static <T> Field<T>
Factory.fieldByName(Class<T> type,
           String... qualifiedName)
Create a qualified field, given its (qualified) field name.



static <T> Field<T>
Factory.fieldByName(DataType<T> type,
           String... qualifiedName)
Create a qualified field, given its (qualified) field name.



static Field<Object>
Factory.fieldByName(String... qualifiedName)
Create a qualified field, given its (qualified) field name.



static <T> WindowIgnoreNullsStep<T>
Factory.firstValue(Field<T> field)
The first_value(field) over ([analytic clause]) function.



static <T extends Number> 
Field<T>
Factory.floor(Field<T> field)
Get the largest integer value not greater than [this]
 
 This renders the floor function where available:
 floor([this])
 ... or simulates it elsewhere using round:
 round([this] - 0.499999999999999)



static <T extends Number> 
Field<T>
Factory.floor(T value)
Get the largest integer value not greater than [this]



static <T> Field<T>
Factory.function(String name,
        Class<T> type,
        Field<?>... arguments)
function() can be used to access native functions that are
 not yet or insufficiently supported by jOOQ
 
 NOTE: When inserting plain SQL into jOOQ objects, you must
 guarantee syntax integrity.



static <T> Field<T>
Factory.function(String name,
        DataType<T> type,
        Field<?>... arguments)
function() can be used to access native functions that are
 not yet or insufficiently supported by jOOQ
 
 NOTE: When inserting plain SQL into jOOQ objects, you must
 guarantee syntax integrity.



static <T> DataType<T>
Factory.getDataType(Class<? extends T> type)
Get the default data type for the Factory's underlying
 SQLDialect and a given Java type.



static <T> Field<T>
Factory.greatest(Field<T> field,
        Field<?>... others)
Find the greatest among all values
 
 This function has no equivalent in Adaptive Server, Derby, SQL Server and
 Sybase SQL Anywhere.



static <T> Field<T>
Factory.greatest(T value,
        T... values)
Find the greatest among all values
 
 This function has no equivalent in Adaptive Server, Derby, SQL Server and
 Sybase SQL Anywhere.



static GroupConcatOrderByStep
Factory.groupConcat(Field<?> field)
Get the aggregated concatenation for a field.



static GroupConcatOrderByStep
Factory.groupConcatDistinct(Field<?> field)
Get the aggregated concatenation for a field.



static Field<Integer>
Factory.grouping(Field<?> field)
Create a GROUPING(field) aggregation field to be used along with
 CUBE, ROLLUP, and GROUPING SETS
 groupings
 
 This has been observed to work with the following databases:
 
 DB2
 Oracle
 SQL Server
 Sybase SQL Anywhere
 



static Field<Integer>
Factory.groupingId(Field<?>... fields)
Create a GROUPING_ID(field1, field2, .., fieldn) aggregation field to be
 used along with CUBE, ROLLUP, and
 GROUPING SETS groupings
 
 This has been observed to work with the following databases:
 
 Oracle
 SQL Server
 



static Field<?>
Factory.groupingSets(Collection<Field<?>>... fieldSets)
Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna,
 fieldnb)) grouping field
 
 This has been observed to work with the following databases:
 
 DB2
 Oracle
 SQL Server
 Sybase SQL Anywhere
 
 
 Please check the SQL Server documentation for a very nice explanation of
 CUBE, ROLLUP, and GROUPING SETS
 clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx



static Field<?>
Factory.groupingSets(Field<?>... fields)
Create a GROUPING SETS(field1, field2, .., fieldn) grouping field where
 each grouping set only consists of a single field.



static Field<?>
Factory.groupingSets(Field<?>[]... fieldSets)
Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna,
 fieldnb)) grouping field
 
 This has been observed to work with the following databases:
 
 DB2
 Oracle
 SQL Server
 Sybase SQL Anywhere
 
 
 Please check the SQL Server documentation for a very nice explanation of
 CUBE, ROLLUP, and GROUPING SETS
 clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx



static Field<Integer>
Factory.hour(Date value)
Get the hour part of a date
 
 This is the same as calling Factory.extract(java.util.Date, DatePart)
 with DatePart.HOUR



static Field<Integer>
Factory.hour(Field<? extends Date> field)
Get the hour part of a date
 
 This is the same as calling Factory.extract(Field, DatePart)
 with DatePart.HOUR



static Param<String>
Factory.inline(char character)
Create a bind value, that is always inlined.



static Param<String>
Factory.inline(Character character)
Create a bind value, that is always inlined.



static Param<String>
Factory.inline(CharSequence character)
Create a bind value, that is always inlined.



static <T> Param<T>
Factory.inline(Object value,
      Class<? extends T> type)
Create a bind value, that is always inlined.



static <T> Param<T>
Factory.inline(Object value,
      DataType<T> type)
Create a bind value, that is always inlined.



static <T> Param<T>
Factory.inline(Object value,
      Field<T> field)
Create a bind value, that is always inlined.



static <T> Param<T>
Factory.inline(T value)
Create a bind value, that is always inlined.



static <T> WindowIgnoreNullsStep<T>
Factory.lag(Field<T> field)
The lag(field) over ([analytic clause]) function.



static <T> WindowIgnoreNullsStep<T>
Factory.lag(Field<T> field,
   int offset)
The lag(field, offset) over ([analytic clause]) function.



static <T> WindowIgnoreNullsStep<T>
Factory.lag(Field<T> field,
   int offset,
   Field<T> defaultValue)
The
 lag(field, offset, defaultValue) over ([analytic clause])
 function.



static <T> WindowIgnoreNullsStep<T>
Factory.lag(Field<T> field,
   int offset,
   T defaultValue)
The
 lag(field, offset, defaultValue) over ([analytic clause])
 function.



static <T> WindowIgnoreNullsStep<T>
Factory.lastValue(Field<T> field)
The last_value(field) over ([analytic clause]) function.



static <T> WindowIgnoreNullsStep<T>
Factory.lead(Field<T> field)
The lead(field) over ([analytic clause]) function.



static <T> WindowIgnoreNullsStep<T>
Factory.lead(Field<T> field,
    int offset)
The lead(field, offset) over ([analytic clause]) function.



static <T> WindowIgnoreNullsStep<T>
Factory.lead(Field<T> field,
    int offset,
    Field<T> defaultValue)
The
 lead(field, offset, defaultValue) over ([analytic clause])
 function.



static <T> WindowIgnoreNullsStep<T>
Factory.lead(Field<T> field,
    int offset,
    T defaultValue)
The
 lead(field, offset, defaultValue) over ([analytic clause])
 function.



static <T> Field<T>
Factory.least(Field<T> field,
     Field<?>... others)
Find the least among all values
 
 This function has no equivalent in Adaptive Server, Derby, SQL Server and
 Sybase SQL Anywhere.



static <T> Field<T>
Factory.least(T value,
     T... values)
Find the least among all values
 
 This function has no equivalent in Adaptive Server, Derby, SQL Server and
 Sybase SQL Anywhere.



static Field<Integer>
Factory.length(Field<String> field)
Get the length of a VARCHAR type.



static Field<Integer>
Factory.length(String value)
Get the length of a VARCHAR type.



static Field<Integer>
Factory.level()
Retrieve the Oracle-specific LEVEL pseudo-field (to be used
 along with CONNECT BY clauses)



static OrderedAggregateFunction<String>
Factory.listAgg(Field<?> field)
Get the aggregated concatenation for a field.



static OrderedAggregateFunction<String>
Factory.listAgg(Field<?> field,
       String separator)
Get the aggregated concatenation for a field.



static <T> Field<T>
Factory.literal(Object literal,
       Class<T> type)
Deprecated. 
- 2.3.0 - Use Factory.field(String, Class), or
             Factory.inline(Object, Class) instead.




static <T> Field<T>
Factory.literal(Object literal,
       DataType<T> type)
Deprecated. 
- 2.3.0 - Use Factory.field(String, DataType), or
             Factory.inline(Object, DataType) instead.




static <T> Field<T>
Factory.literal(T literal)
Deprecated. 
- 2.3.0 - Use Factory.field(String), or
             Factory.inline(Object) instead.




static Field<BigDecimal>
Factory.ln(Field<? extends Number> field)
Get the ln(field) function, taking the natural logarithm of this field
 
 This renders the ln or log function where available:
 ln([field]) or
 log([field])



static Field<BigDecimal>
Factory.ln(Number value)
Get the ln(field) function, taking the natural logarithm of this field



static Field<BigDecimal>
Factory.log(Field<? extends Number> field,
   int base)
Get the log(field, base) function
 
 This renders the log function where available:
 log([field]) ... or simulates it elsewhere (in
 most RDBMS) using the natural logarithm:
 ln([field]) / ln([base])



static Field<BigDecimal>
Factory.log(Number value,
   int base)
Get the log(field, base) function



static Field<String>
Factory.lower(Field<String> value)
Get the lower(field) function
 
 This renders the lower function in all dialects:
 lower([field])



static Field<String>
Factory.lower(String value)
Get the lower(field) function



static Field<String>
Factory.lpad(Field<String> field,
    Field<? extends Number> length)
Get the lpad(field, length) function
 
 This renders the lpad function where available:
 lpad([field], [length]) ... or simulates it
 elsewhere using concat, repeat, and length, which may be simulated as
 well, depending on the RDBMS:
 concat(repeat(' ', [length] - length([field])), [field])



static Field<String>
Factory.lpad(Field<String> field,
    Field<? extends Number> length,
    Field<String> character)
Get the lpad(field, length, character) function
 
 This renders the lpad function where available:
 lpad([field], [length]) ... or simulates it
 elsewhere using concat, repeat, and length, which may be simulated as
 well, depending on the RDBMS:
 concat(repeat([character], [length] - length([field])), [field])
 
 In SQLDialect.SQLITE, this is simulated as such:
 replace(replace(substr(quote(zeroblob(([length] + 1) / 2)), 3, ([length] - length([field]))), '''', ''), '0', [character]) || [field]



static Field<String>
Factory.lpad(Field<String> field,
    int length)
Get the lpad(field, length) function



static Field<String>
Factory.lpad(Field<String> field,
    int length,
    char character)
Get the lpad(field, length, character) function



static Field<String>
Factory.lpad(Field<String> field,
    int length,
    String character)
Get the lpad(field, length, character) function



static Field<String>
Factory.ltrim(Field<String> field)
Get the ltrim(field) function
 
 This renders the ltrim function in all dialects:
 ltrim([field])



static Field<String>
Factory.ltrim(String value)
Get the ltrim(field) function



static <T> AggregateFunction<T>
Factory.max(Field<T> field)
Get the max value over a field: max(field)



static <T> AggregateFunction<T>
Factory.maxDistinct(Field<T> field)
Get the max value over a field: max(distinct field)



static AggregateFunction<BigDecimal>
Factory.median(Field<? extends Number> field)
Get the median over a numeric field: median(field)



static <T> AggregateFunction<T>
Factory.min(Field<T> field)
Get the min value over a field: min(field)



static <T> AggregateFunction<T>
Factory.minDistinct(Field<T> field)
Get the min value over a field: min(distinct field)



static Field<Integer>
Factory.minute(Date value)
Get the minute part of a date
 
 This is the same as calling Factory.extract(java.util.Date, DatePart)
 with DatePart.MINUTE



static Field<Integer>
Factory.minute(Field<? extends Date> field)
Get the minute part of a date
 
 This is the same as calling Factory.extract(Field, DatePart)
 with DatePart.MINUTE



static Field<Integer>
Factory.month(Date value)
Get the month part of a date
 
 This is the same as calling Factory.extract(java.util.Date, DatePart)
 with DatePart.MONTH



static Field<Integer>
Factory.month(Field<? extends Date> field)
Get the month part of a date
 
 This is the same as calling Factory.extract(Field, DatePart)
 with DatePart.MONTH



static Condition
Factory.not(Condition condition)
Invert a condition
 
 This is the same as calling Condition.not()



static Condition
Factory.notExists(Select<?> query)
Create a not exists condition.



static WindowOverStep<Integer>
Factory.ntile(int number)
The ntile([number]) over ([analytic clause]) function.



static <T> Field<T>
Factory.nullif(Field<T> value,
      Field<T> other)
Gets the Oracle-style NULLIF(value, other) function
 
 Returns the dialect's equivalent to NULLIF:
 
 Oracle NULLIF
 
 



static <T> Field<T>
Factory.nullif(Field<T> value,
      T other)
Gets the Oracle-style NULLIF(value, other) function



static <T> Field<T>
Factory.nullif(T value,
      Field<T> other)
Gets the Oracle-style NULLIF(value, other) function



static <T> Field<T>
Factory.nullif(T value,
      T other)
Gets the Oracle-style NULLIF(value, other) function



static <T> Field<T>
Factory.nvl(Field<T> value,
   Field<T> defaultValue)
Gets the Oracle-style NVL(value, defaultValue) function
 
 Returns the dialect's equivalent to NVL:
 
 DB2 
static <T> Field<T>
Factory.nvl(Field<T> value,
   T defaultValue)
Gets the Oracle-style NVL(value, defaultValue) function



static <T> Field<T>
Factory.nvl(T value,
   Field<T> defaultValue)
Gets the Oracle-style NVL(value, defaultValue) function



static <T> Field<T>
Factory.nvl(T value,
   T defaultValue)
Gets the Oracle-style NVL(value, defaultValue) function



static <Z> Field<Z>
Factory.nvl2(Field<?> value,
    Field<Z> valueIfNotNull,
    Field<Z> valueIfNull)
Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function
 
 Returns the dialect's equivalent to NVL2:
 
 Oracle NVL2
 
 
 Other dialects:
 CASE WHEN [value] IS NULL THEN [valueIfNull] ELSE [valueIfNotNull] END



static <Z> Field<Z>
Factory.nvl2(Field<?> value,
    Field<Z> valueIfNotNull,
    Z valueIfNull)
Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function



static <Z> Field<Z>
Factory.nvl2(Field<?> value,
    Z valueIfNotNull,
    Field<Z> valueIfNull)
Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function



static <Z> Field<Z>
Factory.nvl2(Field<?> value,
    Z valueIfNotNull,
    Z valueIfNull)
Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function



static Field<Integer>
Factory.octetLength(Field<String> field)
Get the octet_length(field) function
 
 This translates into any dialect



static Field<Integer>
Factory.octetLength(String value)
Get the octet_length(field) function
 
 This translates into any dialect



static Field<Integer>
Factory.one()
A 1 literal.



static Param<Object>
Factory.param(String name)
Create a named parameter with a generic type (Object /
 SQLDataType.OTHER) and no initial value.



static <T> Param<T>
Factory.param(String name,
     Class<? extends T> type)
Create a named parameter with a defined type and no initial value.



static <T> Param<T>
Factory.param(String name,
     DataType<T> type)
Create a named parameter with a defined type and no initial value.



static <T> Param<T>
Factory.param(String name,
     T value)
Create a named parameter with an initial value.



static WindowOverStep<BigDecimal>
Factory.percentRank()
The precent_rank() over ([analytic clause]) function.



static Field<BigDecimal>
Factory.pi()
The PI literal.



static Field<Integer>
Factory.position(Field<String> in,
        Field<String> search)
Get the position(in, search) function
 
 This renders the position or any equivalent function:
 position([search] in [in]) or
 locate([in], [search]) or
 locate([search], [in]) or
 instr([in], [search]) or
 charindex([search], [in])



static Field<Integer>
Factory.position(Field<String> in,
        String search)
Get the position(in, search) function



static Field<Integer>
Factory.position(String in,
        Field<String> search)
Get the position(in, search) function



static Field<Integer>
Factory.position(String in,
        String search)
Get the position(in, search) function



static Field<BigDecimal>
Factory.power(Field<? extends Number> field,
     Field<? extends Number> exponent)
Get the power(field, exponent) function
 
 This renders the power function where available:
 power([field], [exponent]) ... or simulates it
 elsewhere using ln and exp:
 exp(ln([field]) * [exponent])



static Field<BigDecimal>
Factory.power(Field<? extends Number> field,
     Number exponent)
Get the power(field, exponent) function



static Field<BigDecimal>
Factory.power(Number value,
     Field<? extends Number> exponent)
Get the power(field, exponent) function



static Field<BigDecimal>
Factory.power(Number value,
     Number exponent)
Get the power(field, exponent) function



static <T> Field<T>
Factory.prior(Field<T> field)
Add the Oracle-specific PRIOR unary operator before a field
 (to be used along with CONNECT BY clauses)



static Field<BigDecimal>
Factory.rad(Field<? extends Number> field)
Calculate radians from degrees from this field
 
 This renders the degrees function where available:
 degrees([field]) ... or simulates it elsewhere:
 [field] * PI / 180



static Field<BigDecimal>
Factory.rad(Number value)
Calculate radians from degrees from this field



static Field<BigDecimal>
Factory.rand()
Get the rand() function



static WindowOverStep<Integer>
Factory.rank()
The rank_over() over ([analytic clause]) function.



static AggregateFunction<BigDecimal>
Factory.regrAvgX(Field<? extends Number> y,
        Field<? extends Number> x)
Get the REGR_AVGX linear regression function
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs.



static AggregateFunction<BigDecimal>
Factory.regrAvgY(Field<? extends Number> y,
        Field<? extends Number> x)
Get the REGR_AVGY linear regression function
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs.



static AggregateFunction<BigDecimal>
Factory.regrCount(Field<? extends Number> y,
         Field<? extends Number> x)
Get the REGR_COUNT linear regression function
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs.



static AggregateFunction<BigDecimal>
Factory.regrIntercept(Field<? extends Number> y,
             Field<? extends Number> x)
Get the REGR_INTERCEPT linear regression function
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs.



static AggregateFunction<BigDecimal>
Factory.regrR2(Field<? extends Number> y,
      Field<? extends Number> x)
Get the REGR_R2 linear regression function
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs.



static AggregateFunction<BigDecimal>
Factory.regrSlope(Field<? extends Number> y,
         Field<? extends Number> x)
Get the REGR_SLOPE linear regression function
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs.



static AggregateFunction<BigDecimal>
Factory.regrSXX(Field<? extends Number> y,
       Field<? extends Number> x)
Get the REGR_SXX linear regression function
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs.



static AggregateFunction<BigDecimal>
Factory.regrSXY(Field<? extends Number> y,
       Field<? extends Number> x)
Get the REGR_SXY linear regression function
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs.



static AggregateFunction<BigDecimal>
Factory.regrSYY(Field<? extends Number> y,
       Field<? extends Number> x)
Get the REGR_SYY linear regression function
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs.



static Field<String>
Factory.repeat(Field<String> field,
      Field<? extends Number> count)
Get the repeat(field, count) function
 
 This renders the repeat or replicate function where available:
 repeat([field], [count]) or
 replicate([field], [count]) ... or simulates it elsewhere
 using rpad and length, which may be simulated as well, depending on the
 RDBMS:
 rpad([field], length([field]) * [count], [field])
 
 In SQLDialect.SQLITE, this is simulated as such:
 replace(substr(quote(zeroblob(([count] + 1) / 2)), 3, [count]), '0', [field])



static Field<String>
Factory.repeat(Field<String> field,
      int count)
Get the repeat(count) function



static Field<String>
Factory.repeat(String field,
      Field<? extends Number> count)
Get the repeat(field, count) function



static Field<String>
Factory.repeat(String field,
      int count)
Get the repeat(field, count) function



static Field<String>
Factory.replace(Field<String> field,
       Field<String> search)
Get the replace(field, search) function
 
 This renders the replace or str_replace function where available:
 replace([field], [search]) or
 str_replace([field], [search]) ... or simulates it elsewhere
 using the three-argument replace function:
 replace([field], [search], '')



static Field<String>
Factory.replace(Field<String> field,
       Field<String> search,
       Field<String> replace)
Get the replace(field, search, replace) function
 
 This renders the replace or str_replace function:
 replace([field], [search]) or
 str_replace([field], [search])



static Field<String>
Factory.replace(Field<String> field,
       String search)
Get the replace(field, search) function



static Field<String>
Factory.replace(Field<String> field,
       String search,
       String replace)
Get the replace(field, search, replace) function



static Field<?>
Factory.rollup(Field<?>... fields)
Create a ROLLUP(field1, field2, .., fieldn) grouping field
 
 This has been observed to work with the following databases:
 
 CUBRID (simulated using the GROUP BY ..



static <T extends Number> 
Field<T>
Factory.round(Field<T> field)
Get rounded value of a numeric field: round(field)
 
 This renders the round function where available:
 round([field]) or
 round([field], 0)
 ... or simulates it elsewhere using floor and ceil



static <T extends Number> 
Field<T>
Factory.round(Field<T> field,
     int decimals)
Get rounded value of a numeric field: round(field, decimals)
 
 This renders the round function where available:
 round([field], [decimals])
 ... or simulates it elsewhere using floor and ceil



static <T extends Number> 
Field<T>
Factory.round(T value)
Get rounded value of a numeric field: round(field)



static <T extends Number> 
Field<T>
Factory.round(T value,
     int decimals)
Get rounded value of a numeric field: round(field, decimals)



static RowN
Factory.row(Field<?>... values)
Create a row value expression of degree N > 8
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1> Row1<T1>
Factory.row(Field<T1> t1)
Create a row value expression of degree 1
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2> Row2<T1,T2>
Factory.row(Field<T1> t1,
   Field<T2> t2)
Create a row value expression of degree 2
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3> Row3<T1,T2,T3>
Factory.row(Field<T1> t1,
   Field<T2> t2,
   Field<T3> t3)
Create a row value expression of degree 3
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3,T4> 
Row4<T1,T2,T3,T4>
Factory.row(Field<T1> t1,
   Field<T2> t2,
   Field<T3> t3,
   Field<T4> t4)
Create a row value expression of degree 4
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3,T4,T5> 
Row5<T1,T2,T3,T4,T5>
Factory.row(Field<T1> t1,
   Field<T2> t2,
   Field<T3> t3,
   Field<T4> t4,
   Field<T5> t5)
Create a row value expression of degree 5
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3,T4,T5,T6> 
Row6<T1,T2,T3,T4,T5,T6>
Factory.row(Field<T1> t1,
   Field<T2> t2,
   Field<T3> t3,
   Field<T4> t4,
   Field<T5> t5,
   Field<T6> t6)
Create a row value expression of degree 6
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3,T4,T5,T6,T7> 
Row7<T1,T2,T3,T4,T5,T6,T7>
Factory.row(Field<T1> t1,
   Field<T2> t2,
   Field<T3> t3,
   Field<T4> t4,
   Field<T5> t5,
   Field<T6> t6,
   Field<T7> t7)
Create a row value expression of degree 7
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3,T4,T5,T6,T7,T8> 
Row8<T1,T2,T3,T4,T5,T6,T7,T8>
Factory.row(Field<T1> t1,
   Field<T2> t2,
   Field<T3> t3,
   Field<T4> t4,
   Field<T5> t5,
   Field<T6> t6,
   Field<T7> t7,
   Field<T8> t8)
Create a row value expression of degree 8
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static RowN
Factory.row(Object... values)
Create a row value expression of degree N > 8
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1> Row1<T1>
Factory.row(T1 t1)
Create a row value expression of degree 1
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2> Row2<T1,T2>
Factory.row(T1 t1,
   T2 t2)
Create a row value expression of degree 2
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3> Row3<T1,T2,T3>
Factory.row(T1 t1,
   T2 t2,
   T3 t3)
Create a row value expression of degree 3
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3,T4> 
Row4<T1,T2,T3,T4>
Factory.row(T1 t1,
   T2 t2,
   T3 t3,
   T4 t4)
Create a row value expression of degree 4
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3,T4,T5> 
Row5<T1,T2,T3,T4,T5>
Factory.row(T1 t1,
   T2 t2,
   T3 t3,
   T4 t4,
   T5 t5)
Create a row value expression of degree 5
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3,T4,T5,T6> 
Row6<T1,T2,T3,T4,T5,T6>
Factory.row(T1 t1,
   T2 t2,
   T3 t3,
   T4 t4,
   T5 t5,
   T6 t6)
Create a row value expression of degree 6
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3,T4,T5,T6,T7> 
Row7<T1,T2,T3,T4,T5,T6,T7>
Factory.row(T1 t1,
   T2 t2,
   T3 t3,
   T4 t4,
   T5 t5,
   T6 t6,
   T7 t7)
Create a row value expression of degree 7
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static <T1,T2,T3,T4,T5,T6,T7,T8> 
Row8<T1,T2,T3,T4,T5,T6,T7,T8>
Factory.row(T1 t1,
   T2 t2,
   T3 t3,
   T4 t4,
   T5 t5,
   T6 t6,
   T7 t7,
   T8 t8)
Create a row value expression of degree 8
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be simulated on all databases.



static WindowOverStep<Integer>
Factory.rowNumber()
The row_number() over ([analytic clause]) function.



static Field<String>
Factory.rpad(Field<String> field,
    Field<? extends Number> length)
Get the rpad(field, length) function
 
 This renders the rpad function where available:
 rpad([field], [length]) ... or simulates it
 elsewhere using concat, repeat, and length, which may be simulated as
 well, depending on the RDBMS:
 concat([field], repeat(' ', [length] - length([field])))



static Field<String>
Factory.rpad(Field<String> field,
    Field<? extends Number> length,
    Field<String> character)
Get the rpad(field, length, character) function
 
 This renders the rpad function where available:
 rpad([field], [length]) ... or simulates it
 elsewhere using concat, repeat, and length, which may be simulated as
 well, depending on the RDBMS:
 concat([field], repeat([character], [length] - length([field])))
 
 In SQLDialect.SQLITE, this is simulated as such:
 [field] || replace(replace(substr(quote(zeroblob(([length] + 1) / 2)), 3, ([length] - length([field]))), '''', ''), '0', [character])



static Field<String>
Factory.rpad(Field<String> field,
    int length)
Get the rpad(field, length) function



static Field<String>
Factory.rpad(Field<String> field,
    int length,
    char character)
Get the rpad(field, length, character) function



static Field<String>
Factory.rpad(Field<String> field,
    int length,
    String character)
Get the rpad(field, length, character) function



static Field<String>
Factory.rtrim(Field<String> field)
Get the rtrim(field) function
 
 This renders the rtrim function in all dialects:
 rtrim([field])



static Field<String>
Factory.rtrim(String value)
Get the rtrim(field) function



static Schema
Factory.schemaByName(String name)
Create a qualified schema, given its schema name
 
 This constructs a schema reference given the schema's qualified name.



static Field<Integer>
Factory.second(Date value)
Get the second part of a date
 
 This is the same as calling Factory.extract(java.util.Date, DatePart)
 with DatePart.SECOND



static Field<Integer>
Factory.second(Field<? extends Date> field)
Get the second part of a date
 
 This is the same as calling Factory.extract(Field, DatePart)
 with DatePart.SECOND



static <T extends Number> 
Field<T>
Factory.shl(Field<T> field1,
   Field<T> field2)
The bitwise left shift operator.



static <T extends Number> 
Field<T>
Factory.shl(Field<T> value1,
   T value2)
The bitwise left shift operator.



static <T extends Number> 
Field<T>
Factory.shl(T value1,
   Field<T> value2)
The bitwise left shift operator.



static <T extends Number> 
Field<T>
Factory.shl(T value1,
   T value2)
The bitwise left shift operator.



static <T extends Number> 
Field<T>
Factory.shr(Field<T> field1,
   Field<T> field2)
The bitwise right shift operator.



static <T extends Number> 
Field<T>
Factory.shr(Field<T> value1,
   T value2)
The bitwise right shift operator.



static <T extends Number> 
Field<T>
Factory.shr(T value1,
   Field<T> value2)
The bitwise right shift operator.



static <T extends Number> 
Field<T>
Factory.shr(T value1,
   T value2)
The bitwise right shift operator.



static Field<Integer>
Factory.sign(Field<? extends Number> field)
Get the sign of a numeric field: sign(field)
 
 This renders the sign function where available:
 sign([field])
 ... or simulates it elsewhere (without bind variables on values -1, 0, 1):
 
 CASE WHEN [this] > 0 THEN 1
      WHEN [this] < 0 THEN -1
      ELSE 0
 END




static Field<Integer>
Factory.sign(Number value)
Get the sign of a numeric field: sign(field)



static Field<BigDecimal>
Factory.sin(Field<? extends Number> field)
Get the sine(field) function
 
 This renders the sin function where available:
 sin([field])



static Field<BigDecimal>
Factory.sin(Number value)
Get the sine(field) function



static Field<BigDecimal>
Factory.sinh(Field<? extends Number> field)
Get the hyperbolic sine function: sinh(field)
 
 This renders the sinh function where available:
 sinh([field]) ... or simulates it elsewhere using
 exp: (exp([field] * 2) - 1) / (exp([field] * 2))



static Field<BigDecimal>
Factory.sinh(Number value)
Get the hyperbolic sine function: sinh(field)



static Field<BigDecimal>
Factory.sqrt(Field<? extends Number> field)
Get the sqrt(field) function
 
 This renders the sqrt function where available:
 sqrt([field]) ... or simulates it elsewhere using
 power (which in turn may also be simulated using ln and exp functions):
 power([field], 0.5)



static Field<BigDecimal>
Factory.sqrt(Number value)
Get the sqrt(field) function



static AggregateFunction<BigDecimal>
Factory.stddevPop(Field<? extends Number> field)
Get the population standard deviation of a numeric field: stddev_pop(field)



static AggregateFunction<BigDecimal>
Factory.stddevSamp(Field<? extends Number> field)
Get the sample standard deviation of a numeric field: stddev_samp(field)



static Field<String>
Factory.substring(Field<String> field,
         Field<? extends Number> startingPosition)
Get the substring(field, startingPosition) function
 
 This renders the substr or substring function:
 substr([field], [startingPosition]) or
 substring([field], [startingPosition])



static Field<String>
Factory.substring(Field<String> field,
         Field<? extends Number> startingPosition,
         Field<? extends Number> length)
Get the substring(field, startingPosition, length) function
 
 This renders the substr or substring function:
 substr([field], [startingPosition], [length]) or
 substring([field], [startingPosition], [length])



static Field<String>
Factory.substring(Field<String> field,
         int startingPosition)
Get the substring(field, startingPosition) function



static Field<String>
Factory.substring(Field<String> field,
         int startingPosition,
         int length)
Get the substring(field, startingPosition, length) function



static AggregateFunction<BigDecimal>
Factory.sum(Field<? extends Number> field)
Get the sum over a numeric field: sum(field)



static AggregateFunction<BigDecimal>
Factory.sumDistinct(Field<? extends Number> field)
Get the sum over a numeric field: sum(distinct field)



static Field<String>
Factory.sysConnectByPath(Field<?> field,
                String separator)
Retrieve the Oracle-specific
 SYS_CONNECT_BY_PATH(field, separator) function (to be used
 along with CONNECT BY clauses).



static Table<?>
Factory.table(ArrayRecord<?> array)
A synonym for Factory.unnest(ArrayRecord)



static Table<?>
Factory.table(Field<?> cursor)
A synonym for Factory.unnest(Field)



static Table<?>
Factory.table(List<?> list)
A synonym for Factory.unnest(List)



static Table<?>
Factory.table(Object[] array)
A synonym for Factory.unnest(Object[])



static Table<Record>
Factory.table(String sql)
A custom SQL clause that can render arbitrary table expressions.



static Table<Record>
Factory.table(String sql,
     Object... bindings)
A custom SQL clause that can render arbitrary table expressions.



static Table<Record>
Factory.table(String sql,
     QueryPart... parts)
A custom SQL clause that can render arbitrary table expressions.



static Table<Record>
Factory.tableByName(String... qualifiedName)
Create a qualified table, given its table name
 
 This constructs a table reference given the table's qualified name. jOOQ
 will render the table name according to your
 Settings.getRenderNameStyle() settings.



static Field<BigDecimal>
Factory.tan(Field<? extends Number> field)
Get the tangent(field) function
 
 This renders the tan function where available:
 tan([field])



static Field<BigDecimal>
Factory.tan(Number value)
Get the tangent(field) function



static Field<BigDecimal>
Factory.tanh(Field<? extends Number> field)
Get the hyperbolic tangent function: tanh(field)
 
 This renders the tanh function where available:
 tanh([field]) ... or simulates it elsewhere using
 exp:
 (exp([field] * 2) - 1) / (exp([field] * 2) + 1)



static Field<BigDecimal>
Factory.tanh(Number value)
Get the hyperbolic tangent function: tanh(field)



static Field<Timestamp>
Factory.timestampAdd(Field<Timestamp> timestamp,
            Field<? extends Number> interval)
Add an interval to a timestamp
 
 This translates into any dialect



static Field<Timestamp>
Factory.timestampAdd(Timestamp timestamp,
            Number interval)
Add an interval to a timestamp
 
 This translates into any dialect



static Field<DayToSecond>
Factory.timestampDiff(Field<Timestamp> timestamp1,
             Field<Timestamp> timestamp2)
Get the timestamp difference as a INTERVAL DAY TO SECOND
 type
 
 This translates into any dialect



static Field<DayToSecond>
Factory.timestampDiff(Field<Timestamp> timestamp1,
             Timestamp timestamp2)
Get the timestamp difference as a INTERVAL DAY TO SECOND
 type
 
 This translates into any dialect



static Field<DayToSecond>
Factory.timestampDiff(Timestamp timestamp1,
             Field<Timestamp> timestamp2)
Get the timestamp difference as a INTERVAL DAY TO SECOND
 type
 
 This translates into any dialect



static Field<DayToSecond>
Factory.timestampDiff(Timestamp timestamp1,
             Timestamp timestamp2)
Get the timestamp difference as a INTERVAL DAY TO SECOND
 type
 
 This translates into any dialect



static Field<String>
Factory.trim(Field<String> field)
Get the trim(field) function
 
 This renders the trim function where available:
 trim([field]) ... or simulates it elsewhere using
 rtrim and ltrim: ltrim(rtrim([field]))



static Field<String>
Factory.trim(String value)
Get the trim(field) function



static Condition
Factory.trueCondition()
Return a Condition that will always evaluate to true



static <T extends Number> 
Field<T>
Factory.trunc(Field<T> number,
     Field<Integer> decimals)
Truncate a number to a given number of decimals
 
 This function truncates number to the amount of decimals
 specified in decimals.



static <T extends Number> 
Field<T>
Factory.trunc(Field<T> number,
     int decimals)
Truncate a number to a given number of decimals



static <T extends Number> 
Field<T>
Factory.trunc(T number)
Truncate a number to a given number of decimals



static <T extends Number> 
Field<T>
Factory.trunc(T number,
     Field<Integer> decimals)
Truncate a number to a given number of decimals



static <T extends Number> 
Field<T>
Factory.trunc(T number,
     int decimals)
Truncate a number to a given number of decimals



static Field<Integer>
Factory.two()
A 2 literal.



static Table<?>
Factory.unnest(ArrayRecord<?> array)
Create a table from an array of values
 
 This wraps the argument array in a TABLE function for
 Oracle.



static Table<?>
Factory.unnest(Field<?> cursor)
Create a table from a field.



static Table<?>
Factory.unnest(List<?> list)
Create a table from a list of values
 
 This is equivalent to the TABLE function for H2, or the
 UNNEST function in HSQLDB and Postgres
 
 For Oracle, use Factory.table(ArrayRecord) instead, as Oracle knows only
 typed arrays
 
 In all other dialects, unnesting of arrays is simulated using several
 UNION ALL connected subqueries.



static Table<?>
Factory.unnest(Object[] array)
Create a table from an array of values
 
 This is equivalent to the TABLE function for H2, or the
 UNNEST function in HSQLDB and Postgres
 
 For Oracle, use Factory.table(ArrayRecord) instead, as Oracle knows only
 typed arrays
 
 In all other dialects, unnesting of arrays is simulated using several
 UNION ALL connected subqueries.



static Field<String>
Factory.upper(Field<String> field)
Get the upper(field) function
 
 This renders the upper function in all dialects:
 upper([field])



static Field<String>
Factory.upper(String value)
Get the upper(field) function



static <T> Field<T>
Factory.val(Object value,
   Class<? extends T> type)
Get a bind value with an associated type, taken from a field



static <T> Field<T>
Factory.val(Object value,
   DataType<T> type)
Get a bind value with an associated type
 
 This will try to bind value as type in a
 PreparedStatement.



static <T> Field<T>
Factory.val(Object value,
   Field<T> field)
Get a bind value with an associated type, taken from a field



static <T> Field<T>
Factory.val(T value)
Get a bind value
 
 jOOQ tries to derive the RDBMS DataType from the provided Java
 type <T>.



static List<Field<?>>
Factory.vals(Object... values)
Get a list of bind values and fields



static <T> Field<T>
Factory.value(Object value,
     Class<? extends T> type)
A synonym for Factory.val(Object, Class) to be used in Scala and Groovy, where
 val is a reserved keyword.



static <T> Field<T>
Factory.value(Object value,
     DataType<T> type)
A synonym for Factory.val(Object, DataType) to be used in Scala and Groovy, where
 val is a reserved keyword.



static <T> Field<T>
Factory.value(Object value,
     Field<T> field)
A synonym for Factory.val(Object, Field) to be used in Scala and Groovy, where
 val is a reserved keyword.



static <T> Field<T>
Factory.value(T value)
A synonym for Factory.val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.



static AggregateFunction<BigDecimal>
Factory.varPop(Field<? extends Number> field)
Get the population variance of a numeric field: var_pop(field)



static AggregateFunction<BigDecimal>
Factory.varSamp(Field<? extends Number> field)
Get the sample variance of a numeric field: var_samp(field)



static Field<Integer>
Factory.year(Date value)
Get the year part of a date
 
 This is the same as calling Factory.extract(java.util.Date, DatePart)
 with DatePart.YEAR



static Field<Integer>
Factory.year(Field<? extends Date> field)
Get the year part of a date
 
 This is the same as calling Factory.extract(Field, DatePart)
 with DatePart.YEAR



static Field<Integer>
Factory.zero()
A 0 literal.








Uses of Support in org.jooq.util.oracle

Methods in org.jooq.util.oracle with annotations of type Support 

Modifier and Type
Method and Description



static Field<BigDecimal>
OracleFactory.catsearch(Field<String> field,
         String textQuery,
         String structuredQuery)
The Oracle-Text specific CATSEARCH function



static Field<BigDecimal>
OracleFactory.contains(Field<String> field,
        String query)
The Oracle-Text specific CONTAINS function



static Field<BigDecimal>
OracleFactory.contains(Field<String> field,
        String query,
        int label)
The Oracle-Text specific CONTAINS function



static Field<BigDecimal>
OracleFactory.matches(Field<String> field,
       String query)
The Oracle-Text specific MATCHES function



static Field<BigDecimal>
OracleFactory.matches(Field<String> field,
       String query,
       int label)
The Oracle-Text specific CONTAINS function



static Field<BigDecimal>
OracleFactory.matchScore(int label)
The Oracle-Text specific MATCH_SCORE function



static Field<String>
OracleFactory.rowid()
Retrieve the Oracle-specific ROWID pseudo-field



static Field<Integer>
OracleFactory.rownum()
Retrieve the Oracle-specific ROWNUM pseudo-field



static Field<BigDecimal>
OracleFactory.score(int label)
The Oracle-Text specific SCORE function



static Field<String>
OracleFactory.sysContext(String namespace,
          String parameter)
The Oracle-specific SYS_CONTEXT function



static Field<String>
OracleFactory.sysContext(String namespace,
          String parameter,
          int length)
The Oracle-specific SYS_CONTEXT function









Overview
Package
Class
Use
Deprecated
Index
Help




Prev
Next


Frames
No Frames


All Classes








Copyright © 2013. All Rights Reserved.

Uses of Classorg.jooq.Support

Uses of Support in org.jooq

Uses of Support in org.jooq.impl

Uses of Support in org.jooq.util.oracle

Uses of Class
org.jooq.Support